?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update mojo sdk to rev 1dc8a9a5db73d3718d99917fadf31f5fb2ebad4f
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / test / speedtest1.c
blob8e5b74c56e4c019a6c7ef1879308d3585c1f28e9
1 /*
2 ** A program for performance testing.
3 **
4 ** The available command-line options are described below:
5 */
6 static const char zHelp[] =
7 "Usage: %s [--options] DATABASE\n"
8 "Options:\n"
9 " --autovacuum Enable AUTOVACUUM mode\n"
10 " --cachesize N Set the cache size to N\n"
11 " --exclusive Enable locking_mode=EXCLUSIVE\n"
12 " --explain Like --sqlonly but with added EXPLAIN keywords\n"
13 " --heap SZ MIN Memory allocator uses SZ bytes & min allocation MIN\n"
14 " --incrvacuum Enable incremenatal vacuum mode\n"
15 " --journalmode M Set the journal_mode to MODE\n"
16 " --key KEY Set the encryption key to KEY\n"
17 " --lookaside N SZ Configure lookaside for N slots of SZ bytes each\n"
18 " --nosync Set PRAGMA synchronous=OFF\n"
19 " --notnull Add NOT NULL constraints to table columns\n"
20 " --pagesize N Set the page size to N\n"
21 " --pcache N SZ Configure N pages of pagecache each of size SZ bytes\n"
22 " --primarykey Use PRIMARY KEY instead of UNIQUE where appropriate\n"
23 " --reprepare Reprepare each statement upon every invocation\n"
24 " --scratch N SZ Configure scratch memory for N slots of SZ bytes each\n"
25 " --sqlonly No-op. Only show the SQL that would have been run.\n"
26 " --size N Relative test size. Default=100\n"
27 " --stats Show statistics at the end\n"
28 " --testset T Run test-set T\n"
29 " --trace Turn on SQL tracing\n"
30 " --threads N Use up to N threads for sorting\n"
31 " --utf16be Set text encoding to UTF-16BE\n"
32 " --utf16le Set text encoding to UTF-16LE\n"
33 " --verify Run additional verification steps.\n"
34 " --without-rowid Use WITHOUT ROWID where appropriate\n"
35 ;
36
37
38 #include "sqlite3.h"
39 #include <assert.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <stdarg.h>
43 #include <string.h>
44 #include <ctype.h>
45
46 /* All global state is held in this structure */
47 static struct Global {
48 sqlite3 *db; /* The open database connection */
49 sqlite3_stmt *pStmt; /* Current SQL statement */
50 sqlite3_int64 iStart; /* Start-time for the current test */
51 sqlite3_int64 iTotal; /* Total time */
52 int bWithoutRowid; /* True for --without-rowid */
53 int bReprepare; /* True to reprepare the SQL on each rerun */
54 int bSqlOnly; /* True to print the SQL once only */
55 int bExplain; /* Print SQL with EXPLAIN prefix */
56 int bVerify; /* Try to verify that results are correct */
57 int szTest; /* Scale factor for test iterations */
58 const char *zWR; /* Might be WITHOUT ROWID */
59 const char *zNN; /* Might be NOT NULL */
60 const char *zPK; /* Might be UNIQUE or PRIMARY KEY */
61 unsigned int x, y; /* Pseudo-random number generator state */
62 int nResult; /* Size of the current result */
63 char zResult[3000]; /* Text of the current result */
64 } g;
65
66
67 /* Print an error message and exit */
68 static void fatal_error(const char *zMsg, ...){
69 va_list ap;
70 va_start(ap, zMsg);
71 vfprintf(stderr, zMsg, ap);
72 va_end(ap);
73 exit(1);
74 }
75
76 /*
77 ** Return the value of a hexadecimal digit. Return -1 if the input
78 ** is not a hex digit.
79 */
80 static int hexDigitValue(char c){
81 if( c>='0' && c<='9' ) return c - '0';
82 if( c>='a' && c<='f' ) return c - 'a' + 10;
83 if( c>='A' && c<='F' ) return c - 'A' + 10;
84 return -1;
85 }
86
87 /* Provide an alternative to sqlite3_stricmp() in older versions of
88 ** SQLite */
89 #if SQLITE_VERSION_NUMBER<3007011
90 # define sqlite3_stricmp strcmp
91 #endif
92
93 /*
94 ** Interpret zArg as an integer value, possibly with suffixes.
95 */
96 static int integerValue(const char *zArg){
97 sqlite3_int64 v = 0;
98 static const struct { char *zSuffix; int iMult; } aMult[] = {
99 { "KiB", 1024 },
100 { "MiB", 1024*1024 },
101 { "GiB", 1024*1024*1024 },
102 { "KB", 1000 },
103 { "MB", 1000000 },
104 { "GB", 1000000000 },
105 { "K", 1000 },
106 { "M", 1000000 },
107 { "G", 1000000000 },
108 };
109 int i;
110 int isNeg = 0;
111 if( zArg[0]=='-' ){
112 isNeg = 1;
113 zArg++;
114 }else if( zArg[0]=='+' ){
115 zArg++;
116 }
117 if( zArg[0]=='0' && zArg[1]=='x' ){
118 int x;
119 zArg += 2;
120 while( (x = hexDigitValue(zArg[0]))>=0 ){
121 v = (v<<4) + x;
122 zArg++;
123 }
124 }else{
125 while( isdigit(zArg[0]) ){
126 v = v*10 + zArg[0] - '0';
127 zArg++;
128 }
129 }
130 for(i=0; i<sizeof(aMult)/sizeof(aMult[0]); i++){
131 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
132 v *= aMult[i].iMult;
133 break;
134 }
135 }
136 if( v>0x7fffffff ) fatal_error("parameter too large - max 2147483648");
137 return (int)(isNeg? -v : v);
138 }
139
140 /* Return the current wall-clock time, in milliseconds */
141 sqlite3_int64 speedtest1_timestamp(void){
142 static sqlite3_vfs *clockVfs = 0;
143 sqlite3_int64 t;
144 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
145 #if SQLITE_VERSION_NUMBER>=3007000
146 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
147 clockVfs->xCurrentTimeInt64(clockVfs, &t);
148 }else
149 #endif
150 {
151 double r;
152 clockVfs->xCurrentTime(clockVfs, &r);
153 t = (sqlite3_int64)(r*86400000.0);
154 }
155 return t;
156 }
157
158 /* Return a pseudo-random unsigned integer */
159 unsigned int speedtest1_random(void){
160 g.x = (g.x>>1) ^ ((1+~(g.x&1)) & 0xd0000001);
161 g.y = g.y*1103515245 + 12345;
162 return g.x ^ g.y;
163 }
164
165 /* Map the value in within the range of 1...limit into another
166 ** number in a way that is chatic and invertable.
167 */
168 unsigned swizzle(unsigned in, unsigned limit){
169 unsigned out = 0;
170 while( limit ){
171 out = (out<<1) | (in&1);
172 in >>= 1;
173 limit >>= 1;
174 }
175 return out;
176 }
177
178 /* Round up a number so that it is a power of two minus one
179 */
180 unsigned roundup_allones(unsigned limit){
181 unsigned m = 1;
182 while( m<limit ) m = (m<<1)+1;
183 return m;
184 }
185
186 /* The speedtest1_numbername procedure below converts its argment (an integer)
187 ** into a string which is the English-language name for that number.
188 ** The returned string should be freed with sqlite3_free().
189 **
190 ** Example:
191 **
192 ** speedtest1_numbername(123) -> "one hundred twenty three"
193 */
194 int speedtest1_numbername(unsigned int n, char *zOut, int nOut){
195 static const char *ones[] = { "zero", "one", "two", "three", "four", "five",
196 "six", "seven", "eight", "nine", "ten", "eleven", "twelve",
197 "thirteen", "fourteen", "fifteen", "sixteen", "seventeen",
198 "eighteen", "nineteen" };
199 static const char *tens[] = { "", "ten", "twenty", "thirty", "forty",
200 "fifty", "sixty", "seventy", "eighty", "ninety" };
201 int i = 0;
202
203 if( n>=1000000000 ){
204 i += speedtest1_numbername(n/1000000000, zOut+i, nOut-i);
205 sqlite3_snprintf(nOut-i, zOut+i, " billion");
206 i += (int)strlen(zOut+i);
207 n = n % 1000000000;
208 }
209 if( n>=1000000 ){
210 if( i && i<nOut-1 ) zOut[i++] = ' ';
211 i += speedtest1_numbername(n/1000000, zOut+i, nOut-i);
212 sqlite3_snprintf(nOut-i, zOut+i, " million");
213 i += (int)strlen(zOut+i);
214 n = n % 1000000;
215 }
216 if( n>=1000 ){
217 if( i && i<nOut-1 ) zOut[i++] = ' ';
218 i += speedtest1_numbername(n/1000, zOut+i, nOut-i);
219 sqlite3_snprintf(nOut-i, zOut+i, " thousand");
220 i += (int)strlen(zOut+i);
221 n = n % 1000;
222 }
223 if( n>=100 ){
224 if( i && i<nOut-1 ) zOut[i++] = ' ';
225 sqlite3_snprintf(nOut-i, zOut+i, "%s hundred", ones[n/100]);
226 i += (int)strlen(zOut+i);
227 n = n % 100;
228 }
229 if( n>=20 ){
230 if( i && i<nOut-1 ) zOut[i++] = ' ';
231 sqlite3_snprintf(nOut-i, zOut+i, "%s", tens[n/10]);
232 i += (int)strlen(zOut+i);
233 n = n % 10;
234 }
235 if( n>0 ){
236 if( i && i<nOut-1 ) zOut[i++] = ' ';
237 sqlite3_snprintf(nOut-i, zOut+i, "%s", ones[n]);
238 i += (int)strlen(zOut+i);
239 }
240 if( i==0 ){
241 sqlite3_snprintf(nOut-i, zOut+i, "zero");
242 i += (int)strlen(zOut+i);
243 }
244 return i;
245 }
246
247
248 /* Start a new test case */
249 #define NAMEWIDTH 60
250 static const char zDots[] =
251 ".......................................................................";
252 void speedtest1_begin_test(int iTestNum, const char *zTestName, ...){
253 int n = (int)strlen(zTestName);
254 char *zName;
255 va_list ap;
256 va_start(ap, zTestName);
257 zName = sqlite3_vmprintf(zTestName, ap);
258 va_end(ap);
259 n = (int)strlen(zName);
260 if( n>NAMEWIDTH ){
261 zName[NAMEWIDTH] = 0;
262 n = NAMEWIDTH;
263 }
264 if( g.bSqlOnly ){
265 printf("/* %4d - %s%.*s */\n", iTestNum, zName, NAMEWIDTH-n, zDots);
266 }else{
267 printf("%4d - %s%.*s ", iTestNum, zName, NAMEWIDTH-n, zDots);
268 fflush(stdout);
269 }
270 sqlite3_free(zName);
271 g.nResult = 0;
272 g.iStart = speedtest1_timestamp();
273 g.x = 0xad131d0b;
274 g.y = 0x44f9eac8;
275 }
276
277 /* Complete a test case */
278 void speedtest1_end_test(void){
279 sqlite3_int64 iElapseTime = speedtest1_timestamp() - g.iStart;
280 if( !g.bSqlOnly ){
281 g.iTotal += iElapseTime;
282 printf("%4d.%03ds\n", (int)(iElapseTime/1000), (int)(iElapseTime%1000));
283 }
284 if( g.pStmt ){
285 sqlite3_finalize(g.pStmt);
286 g.pStmt = 0;
287 }
288 }
289
290 /* Report end of testing */
291 void speedtest1_final(void){
292 if( !g.bSqlOnly ){
293 printf(" TOTAL%.*s %4d.%03ds\n", NAMEWIDTH-5, zDots,
294 (int)(g.iTotal/1000), (int)(g.iTotal%1000));
295 }
296 }
297
298 /* Print an SQL statement to standard output */
299 static void printSql(const char *zSql){
300 int n = (int)strlen(zSql);
301 while( n>0 && (zSql[n-1]==';' || isspace(zSql[n-1])) ){ n--; }
302 if( g.bExplain ) printf("EXPLAIN ");
303 printf("%.*s;\n", n, zSql);
304 if( g.bExplain
305 #if SQLITE_VERSION_NUMBER>=3007010
306 && ( sqlite3_strglob("CREATE *", zSql)==0
307 || sqlite3_strglob("DROP *", zSql)==0
308 || sqlite3_strglob("ALTER *", zSql)==0
309 )
310 #endif
311 ){
312 printf("%.*s;\n", n, zSql);
313 }
314 }
315
316 /* Run SQL */
317 void speedtest1_exec(const char *zFormat, ...){
318 va_list ap;
319 char *zSql;
320 va_start(ap, zFormat);
321 zSql = sqlite3_vmprintf(zFormat, ap);
322 va_end(ap);
323 if( g.bSqlOnly ){
324 printSql(zSql);
325 }else{
326 char *zErrMsg = 0;
327 int rc = sqlite3_exec(g.db, zSql, 0, 0, &zErrMsg);
328 if( zErrMsg ) fatal_error("SQL error: %s\n%s\n", zErrMsg, zSql);
329 if( rc!=SQLITE_OK ) fatal_error("exec error: %s\n", sqlite3_errmsg(g.db));
330 }
331 sqlite3_free(zSql);
332 }
333
334 /* Prepare an SQL statement */
335 void speedtest1_prepare(const char *zFormat, ...){
336 va_list ap;
337 char *zSql;
338 va_start(ap, zFormat);
339 zSql = sqlite3_vmprintf(zFormat, ap);
340 va_end(ap);
341 if( g.bSqlOnly ){
342 printSql(zSql);
343 }else{
344 int rc;
345 if( g.pStmt ) sqlite3_finalize(g.pStmt);
346 rc = sqlite3_prepare_v2(g.db, zSql, -1, &g.pStmt, 0);
347 if( rc ){
348 fatal_error("SQL error: %s\n", sqlite3_errmsg(g.db));
349 }
350 }
351 sqlite3_free(zSql);
352 }
353
354 /* Run an SQL statement previously prepared */
355 void speedtest1_run(void){
356 int i, n, len;
357 if( g.bSqlOnly ) return;
358 assert( g.pStmt );
359 g.nResult = 0;
360 while( sqlite3_step(g.pStmt)==SQLITE_ROW ){
361 n = sqlite3_column_count(g.pStmt);
362 for(i=0; i<n; i++){
363 const char *z = (const char*)sqlite3_column_text(g.pStmt, i);
364 if( z==0 ) z = "nil";
365 len = (int)strlen(z);
366 if( g.nResult+len<sizeof(g.zResult)-2 ){
367 if( g.nResult>0 ) g.zResult[g.nResult++] = ' ';
368 memcpy(g.zResult + g.nResult, z, len+1);
369 g.nResult += len;
370 }
371 }
372 }
373 if( g.bReprepare ){
374 sqlite3_stmt *pNew;
375 sqlite3_prepare_v2(g.db, sqlite3_sql(g.pStmt), -1, &pNew, 0);
376 sqlite3_finalize(g.pStmt);
377 g.pStmt = pNew;
378 }else{
379 sqlite3_reset(g.pStmt);
380 }
381 }
382
383 /* The sqlite3_trace() callback function */
384 static void traceCallback(void *NotUsed, const char *zSql){
385 int n = (int)strlen(zSql);
386 while( n>0 && (zSql[n-1]==';' || isspace(zSql[n-1])) ) n--;
387 fprintf(stderr,"%.*s;\n", n, zSql);
388 }
389
390 /* Substitute random() function that gives the same random
391 ** sequence on each run, for repeatability. */
392 static void randomFunc(
393 sqlite3_context *context,
394 int NotUsed,
395 sqlite3_value **NotUsed2
396 ){
397 sqlite3_result_int64(context, (sqlite3_int64)speedtest1_random());
398 }
399
400 /* Estimate the square root of an integer */
401 static int est_square_root(int x){
402 int y0 = x/2;
403 int y1;
404 int n;
405 for(n=0; y0>0 && n<10; n++){
406 y1 = (y0 + x/y0)/2;
407 if( y1==y0 ) break;
408 y0 = y1;
409 }
410 return y0;
411 }
412
413 /*
414 ** The main and default testset
415 */
416 void testset_main(void){
417 int i; /* Loop counter */
418 int n; /* iteration count */
419 int sz; /* Size of the tables */
420 int maxb; /* Maximum swizzled value */
421 unsigned x1, x2; /* Parameters */
422 int len; /* Length of the zNum[] string */
423 char zNum[2000]; /* A number name */
424
425 sz = n = g.szTest*500;
426 maxb = roundup_allones(sz);
427 speedtest1_begin_test(100, "%d INSERTs into table with no index", n);
428 speedtest1_exec("BEGIN");
429 speedtest1_exec("CREATE TABLE t1(a INTEGER %s, b INTEGER %s, c TEXT %s);",
430 g.zNN, g.zNN, g.zNN);
431 speedtest1_prepare("INSERT INTO t1 VALUES(?1,?2,?3); -- %d times", n);
432 for(i=1; i<=n; i++){
433 x1 = swizzle(i,maxb);
434 speedtest1_numbername(x1, zNum, sizeof(zNum));
435 sqlite3_bind_int64(g.pStmt, 1, (sqlite3_int64)x1);
436 sqlite3_bind_int(g.pStmt, 2, i);
437 sqlite3_bind_text(g.pStmt, 3, zNum, -1, SQLITE_STATIC);
438 speedtest1_run();
439 }
440 speedtest1_exec("COMMIT");
441 speedtest1_end_test();
442
443
444 n = sz;
445 speedtest1_begin_test(110, "%d ordered INSERTS with one index/PK", n);
446 speedtest1_exec("BEGIN");
447 speedtest1_exec("CREATE TABLE t2(a INTEGER %s %s, b INTEGER %s, c TEXT %s) %s",
448 g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
449 speedtest1_prepare("INSERT INTO t2 VALUES(?1,?2,?3); -- %d times", n);
450 for(i=1; i<=n; i++){
451 x1 = swizzle(i,maxb);
452 speedtest1_numbername(x1, zNum, sizeof(zNum));
453 sqlite3_bind_int(g.pStmt, 1, i);
454 sqlite3_bind_int64(g.pStmt, 2, (sqlite3_int64)x1);
455 sqlite3_bind_text(g.pStmt, 3, zNum, -1, SQLITE_STATIC);
456 speedtest1_run();
457 }
458 speedtest1_exec("COMMIT");
459 speedtest1_end_test();
460
461
462 n = sz;
463 speedtest1_begin_test(120, "%d unordered INSERTS with one index/PK", n);
464 speedtest1_exec("BEGIN");
465 speedtest1_exec("CREATE TABLE t3(a INTEGER %s %s, b INTEGER %s, c TEXT %s) %s",
466 g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
467 speedtest1_prepare("INSERT INTO t3 VALUES(?1,?2,?3); -- %d times", n);
468 for(i=1; i<=n; i++){
469 x1 = swizzle(i,maxb);
470 speedtest1_numbername(x1, zNum, sizeof(zNum));
471 sqlite3_bind_int(g.pStmt, 2, i);
472 sqlite3_bind_int64(g.pStmt, 1, (sqlite3_int64)x1);
473 sqlite3_bind_text(g.pStmt, 3, zNum, -1, SQLITE_STATIC);
474 speedtest1_run();
475 }
476 speedtest1_exec("COMMIT");
477 speedtest1_end_test();
478
479
480 n = 25;
481 speedtest1_begin_test(130, "%d SELECTS, numeric BETWEEN, unindexed", n);
482 speedtest1_exec("BEGIN");
483 speedtest1_prepare(
484 "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
485 " WHERE b BETWEEN ?1 AND ?2; -- %d times", n
486 );
487 for(i=1; i<=n; i++){
488 x1 = speedtest1_random()%maxb;
489 x2 = speedtest1_random()%10 + sz/5000 + x1;
490 sqlite3_bind_int(g.pStmt, 1, x1);
491 sqlite3_bind_int(g.pStmt, 2, x2);
492 speedtest1_run();
493 }
494 speedtest1_exec("COMMIT");
495 speedtest1_end_test();
496
497
498 n = 10;
499 speedtest1_begin_test(140, "%d SELECTS, LIKE, unindexed", n);
500 speedtest1_exec("BEGIN");
501 speedtest1_prepare(
502 "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
503 " WHERE c LIKE ?1; -- %d times", n
504 );
505 for(i=1; i<=n; i++){
506 x1 = speedtest1_random()%maxb;
507 zNum[0] = '%';
508 len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
509 zNum[len] = '%';
510 zNum[len+1] = 0;
511 sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
512 speedtest1_run();
513 }
514 speedtest1_exec("COMMIT");
515 speedtest1_end_test();
516
517
518 n = 10;
519 speedtest1_begin_test(142, "%d SELECTS w/ORDER BY, unindexed", n);
520 speedtest1_exec("BEGIN");
521 speedtest1_prepare(
522 "SELECT a, b, c FROM t1 WHERE c LIKE ?1\n"
523 " ORDER BY a; -- %d times", n
524 );
525 for(i=1; i<=n; i++){
526 x1 = speedtest1_random()%maxb;
527 zNum[0] = '%';
528 len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
529 zNum[len] = '%';
530 zNum[len+1] = 0;
531 sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
532 speedtest1_run();
533 }
534 speedtest1_exec("COMMIT");
535 speedtest1_end_test();
536
537 n = 10; //g.szTest/5;
538 speedtest1_begin_test(145, "%d SELECTS w/ORDER BY and LIMIT, unindexed", n);
539 speedtest1_exec("BEGIN");
540 speedtest1_prepare(
541 "SELECT a, b, c FROM t1 WHERE c LIKE ?1\n"
542 " ORDER BY a LIMIT 10; -- %d times", n
543 );
544 for(i=1; i<=n; i++){
545 x1 = speedtest1_random()%maxb;
546 zNum[0] = '%';
547 len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
548 zNum[len] = '%';
549 zNum[len+1] = 0;
550 sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
551 speedtest1_run();
552 }
553 speedtest1_exec("COMMIT");
554 speedtest1_end_test();
555
556
557 speedtest1_begin_test(150, "CREATE INDEX five times");
558 speedtest1_exec("BEGIN;");
559 speedtest1_exec("CREATE UNIQUE INDEX t1b ON t1(b);");
560 speedtest1_exec("CREATE INDEX t1c ON t1(c);");
561 speedtest1_exec("CREATE UNIQUE INDEX t2b ON t2(b);");
562 speedtest1_exec("CREATE INDEX t2c ON t2(c DESC);");
563 speedtest1_exec("CREATE INDEX t3bc ON t3(b,c);");
564 speedtest1_exec("COMMIT;");
565 speedtest1_end_test();
566
567
568 n = sz/5;
569 speedtest1_begin_test(160, "%d SELECTS, numeric BETWEEN, indexed", n);
570 speedtest1_exec("BEGIN");
571 speedtest1_prepare(
572 "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
573 " WHERE b BETWEEN ?1 AND ?2; -- %d times", n
574 );
575 for(i=1; i<=n; i++){
576 x1 = speedtest1_random()%maxb;
577 x2 = speedtest1_random()%10 + sz/5000 + x1;
578 sqlite3_bind_int(g.pStmt, 1, x1);
579 sqlite3_bind_int(g.pStmt, 2, x2);
580 speedtest1_run();
581 }
582 speedtest1_exec("COMMIT");
583 speedtest1_end_test();
584
585
586 n = sz/5;
587 speedtest1_begin_test(161, "%d SELECTS, numeric BETWEEN, PK", n);
588 speedtest1_exec("BEGIN");
589 speedtest1_prepare(
590 "SELECT count(*), avg(b), sum(length(c)) FROM t2\n"
591 " WHERE a BETWEEN ?1 AND ?2; -- %d times", n
592 );
593 for(i=1; i<=n; i++){
594 x1 = speedtest1_random()%maxb;
595 x2 = speedtest1_random()%10 + sz/5000 + x1;
596 sqlite3_bind_int(g.pStmt, 1, x1);
597 sqlite3_bind_int(g.pStmt, 2, x2);
598 speedtest1_run();
599 }
600 speedtest1_exec("COMMIT");
601 speedtest1_end_test();
602
603
604 n = sz/5;
605 speedtest1_begin_test(170, "%d SELECTS, text BETWEEN, indexed", n);
606 speedtest1_exec("BEGIN");
607 speedtest1_prepare(
608 "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
609 " WHERE c BETWEEN ?1 AND (?1||'~'); -- %d times", n
610 );
611 for(i=1; i<=n; i++){
612 x1 = swizzle(i, maxb);
613 len = speedtest1_numbername(x1, zNum, sizeof(zNum)-1);
614 sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
615 speedtest1_run();
616 }
617 speedtest1_exec("COMMIT");
618 speedtest1_end_test();
619
620 n = sz;
621 speedtest1_begin_test(180, "%d INSERTS with three indexes", n);
622 speedtest1_exec("BEGIN");
623 speedtest1_exec(
624 "CREATE TABLE t4(\n"
625 " a INTEGER %s %s,\n"
626 " b INTEGER %s,\n"
627 " c TEXT %s\n"
628 ") %s",
629 g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
630 speedtest1_exec("CREATE INDEX t4b ON t4(b)");
631 speedtest1_exec("CREATE INDEX t4c ON t4(c)");
632 speedtest1_exec("INSERT INTO t4 SELECT * FROM t1");
633 speedtest1_exec("COMMIT");
634 speedtest1_end_test();
635
636 n = sz;
637 speedtest1_begin_test(190, "DELETE and REFILL one table", n);
638 speedtest1_exec("DELETE FROM t2;");
639 speedtest1_exec("INSERT INTO t2 SELECT * FROM t1;");
640 speedtest1_end_test();
641
642
643 speedtest1_begin_test(200, "VACUUM");
644 speedtest1_exec("VACUUM");
645 speedtest1_end_test();
646
647
648 speedtest1_begin_test(210, "ALTER TABLE ADD COLUMN, and query");
649 speedtest1_exec("ALTER TABLE t2 ADD COLUMN d DEFAULT 123");
650 speedtest1_exec("SELECT sum(d) FROM t2");
651 speedtest1_end_test();
652
653
654 n = sz/5;
655 speedtest1_begin_test(230, "%d UPDATES, numeric BETWEEN, indexed", n);
656 speedtest1_exec("BEGIN");
657 speedtest1_prepare(
658 "UPDATE t2 SET d=b*2 WHERE b BETWEEN ?1 AND ?2; -- %d times", n
659 );
660 for(i=1; i<=n; i++){
661 x1 = speedtest1_random()%maxb;
662 x2 = speedtest1_random()%10 + sz/5000 + x1;
663 sqlite3_bind_int(g.pStmt, 1, x1);
664 sqlite3_bind_int(g.pStmt, 2, x2);
665 speedtest1_run();
666 }
667 speedtest1_exec("COMMIT");
668 speedtest1_end_test();
669
670
671 n = sz;
672 speedtest1_begin_test(240, "%d UPDATES of individual rows", n);
673 speedtest1_exec("BEGIN");
674 speedtest1_prepare(
675 "UPDATE t2 SET d=b*3 WHERE a=?1; -- %d times", n
676 );
677 for(i=1; i<=n; i++){
678 x1 = speedtest1_random()%sz + 1;
679 sqlite3_bind_int(g.pStmt, 1, x1);
680 speedtest1_run();
681 }
682 speedtest1_exec("COMMIT");
683 speedtest1_end_test();
684
685 speedtest1_begin_test(250, "One big UPDATE of the whole %d-row table", sz);
686 speedtest1_exec("UPDATE t2 SET d=b*4");
687 speedtest1_end_test();
688
689
690 speedtest1_begin_test(260, "Query added column after filling");
691 speedtest1_exec("SELECT sum(d) FROM t2");
692 speedtest1_end_test();
693
694
695
696 n = sz/5;
697 speedtest1_begin_test(270, "%d DELETEs, numeric BETWEEN, indexed", n);
698 speedtest1_exec("BEGIN");
699 speedtest1_prepare(
700 "DELETE FROM t2 WHERE b BETWEEN ?1 AND ?2; -- %d times", n
701 );
702 for(i=1; i<=n; i++){
703 x1 = speedtest1_random()%maxb + 1;
704 x2 = speedtest1_random()%10 + sz/5000 + x1;
705 sqlite3_bind_int(g.pStmt, 1, x1);
706 sqlite3_bind_int(g.pStmt, 2, x2);
707 speedtest1_run();
708 }
709 speedtest1_exec("COMMIT");
710 speedtest1_end_test();
711
712
713 n = sz;
714 speedtest1_begin_test(280, "%d DELETEs of individual rows", n);
715 speedtest1_exec("BEGIN");
716 speedtest1_prepare(
717 "DELETE FROM t3 WHERE a=?1; -- %d times", n
718 );
719 for(i=1; i<=n; i++){
720 x1 = speedtest1_random()%sz + 1;
721 sqlite3_bind_int(g.pStmt, 1, x1);
722 speedtest1_run();
723 }
724 speedtest1_exec("COMMIT");
725 speedtest1_end_test();
726
727
728 speedtest1_begin_test(290, "Refill two %d-row tables using REPLACE", sz);
729 speedtest1_exec("REPLACE INTO t2(a,b,c) SELECT a,b,c FROM t1");
730 speedtest1_exec("REPLACE INTO t3(a,b,c) SELECT a,b,c FROM t1");
731 speedtest1_end_test();
732
733 speedtest1_begin_test(300, "Refill a %d-row table using (b&1)==(a&1)", sz);
734 speedtest1_exec("DELETE FROM t2;");
735 speedtest1_exec("INSERT INTO t2(a,b,c)\n"
736 " SELECT a,b,c FROM t1 WHERE (b&1)==(a&1);");
737 speedtest1_exec("INSERT INTO t2(a,b,c)\n"
738 " SELECT a,b,c FROM t1 WHERE (b&1)<>(a&1);");
739 speedtest1_end_test();
740
741
742 n = sz/5;
743 speedtest1_begin_test(310, "%d four-ways joins", n);
744 speedtest1_exec("BEGIN");
745 speedtest1_prepare(
746 "SELECT t1.c FROM t1, t2, t3, t4\n"
747 " WHERE t4.a BETWEEN ?1 AND ?2\n"
748 " AND t3.a=t4.b\n"
749 " AND t2.a=t3.b\n"
750 " AND t1.c=t2.c"
751 );
752 for(i=1; i<=n; i++){
753 x1 = speedtest1_random()%sz + 1;
754 x2 = speedtest1_random()%10 + x1 + 4;
755 sqlite3_bind_int(g.pStmt, 1, x1);
756 sqlite3_bind_int(g.pStmt, 2, x2);
757 speedtest1_run();
758 }
759 speedtest1_exec("COMMIT");
760 speedtest1_end_test();
761
762 speedtest1_begin_test(320, "subquery in result set", n);
763 speedtest1_prepare(
764 "SELECT sum(a), max(c),\n"
765 " avg((SELECT a FROM t2 WHERE 5+t2.b=t1.b) AND rowid<?1), max(c)\n"
766 " FROM t1 WHERE rowid<?1;"
767 );
768 sqlite3_bind_int(g.pStmt, 1, est_square_root(g.szTest)*50);
769 speedtest1_run();
770 speedtest1_end_test();
771
772 speedtest1_begin_test(980, "PRAGMA integrity_check");
773 speedtest1_exec("PRAGMA integrity_check");
774 speedtest1_end_test();
775
776
777 speedtest1_begin_test(990, "ANALYZE");
778 speedtest1_exec("ANALYZE");
779 speedtest1_end_test();
780 }
781
782 /*
783 ** A testset for common table expressions. This exercises code
784 ** for views, subqueries, co-routines, etc.
785 */
786 void testset_cte(void){
787 static const char *azPuzzle[] = {
788 /* Easy */
789 "534...9.."
790 "67.195..."
791 ".98....6."
792 "8...6...3"
793 "4..8.3..1"
794 "....2...6"
795 ".6....28."
796 "...419..5"
797 "...28..79",
798
799 /* Medium */
800 "53....9.."
801 "6..195..."
802 ".98....6."
803 "8...6...3"
804 "4..8.3..1"
805 "....2...6"
806 ".6....28."
807 "...419..5"
808 "....8..79",
809
810 /* Hard */
811 "53......."
812 "6..195..."
813 ".98....6."
814 "8...6...3"
815 "4..8.3..1"
816 "....2...6"
817 ".6....28."
818 "...419..5"
819 "....8..79",
820 };
821 const char *zPuz;
822 double rSpacing;
823 int nElem;
824
825 if( g.szTest<25 ){
826 zPuz = azPuzzle[0];
827 }else if( g.szTest<70 ){
828 zPuz = azPuzzle[1];
829 }else{
830 zPuz = azPuzzle[2];
831 }
832 speedtest1_begin_test(100, "Sudoku with recursive 'digits'");
833 speedtest1_prepare(
834 "WITH RECURSIVE\n"
835 " input(sud) AS (VALUES(?1)),\n"
836 " digits(z,lp) AS (\n"
837 " VALUES('1', 1)\n"
838 " UNION ALL\n"
839 " SELECT CAST(lp+1 AS TEXT), lp+1 FROM digits WHERE lp<9\n"
840 " ),\n"
841 " x(s, ind) AS (\n"
842 " SELECT sud, instr(sud, '.') FROM input\n"
843 " UNION ALL\n"
844 " SELECT\n"
845 " substr(s, 1, ind-1) || z || substr(s, ind+1),\n"
846 " instr( substr(s, 1, ind-1) || z || substr(s, ind+1), '.' )\n"
847 " FROM x, digits AS z\n"
848 " WHERE ind>0\n"
849 " AND NOT EXISTS (\n"
850 " SELECT 1\n"
851 " FROM digits AS lp\n"
852 " WHERE z.z = substr(s, ((ind-1)/9)*9 + lp, 1)\n"
853 " OR z.z = substr(s, ((ind-1)%%9) + (lp-1)*9 + 1, 1)\n"
854 " OR z.z = substr(s, (((ind-1)/3) %% 3) * 3\n"
855 " + ((ind-1)/27) * 27 + lp\n"
856 " + ((lp-1) / 3) * 6, 1)\n"
857 " )\n"
858 " )\n"
859 "SELECT s FROM x WHERE ind=0;"
860 );
861 sqlite3_bind_text(g.pStmt, 1, zPuz, -1, SQLITE_STATIC);
862 speedtest1_run();
863 speedtest1_end_test();
864
865 speedtest1_begin_test(200, "Sudoku with VALUES 'digits'");
866 speedtest1_prepare(
867 "WITH RECURSIVE\n"
868 " input(sud) AS (VALUES(?1)),\n"
869 " digits(z,lp) AS (VALUES('1',1),('2',2),('3',3),('4',4),('5',5),\n"
870 " ('6',6),('7',7),('8',8),('9',9)),\n"
871 " x(s, ind) AS (\n"
872 " SELECT sud, instr(sud, '.') FROM input\n"
873 " UNION ALL\n"
874 " SELECT\n"
875 " substr(s, 1, ind-1) || z || substr(s, ind+1),\n"
876 " instr( substr(s, 1, ind-1) || z || substr(s, ind+1), '.' )\n"
877 " FROM x, digits AS z\n"
878 " WHERE ind>0\n"
879 " AND NOT EXISTS (\n"
880 " SELECT 1\n"
881 " FROM digits AS lp\n"
882 " WHERE z.z = substr(s, ((ind-1)/9)*9 + lp, 1)\n"
883 " OR z.z = substr(s, ((ind-1)%%9) + (lp-1)*9 + 1, 1)\n"
884 " OR z.z = substr(s, (((ind-1)/3) %% 3) * 3\n"
885 " + ((ind-1)/27) * 27 + lp\n"
886 " + ((lp-1) / 3) * 6, 1)\n"
887 " )\n"
888 " )\n"
889 "SELECT s FROM x WHERE ind=0;"
890 );
891 sqlite3_bind_text(g.pStmt, 1, zPuz, -1, SQLITE_STATIC);
892 speedtest1_run();
893 speedtest1_end_test();
894
895 rSpacing = 5.0/g.szTest;
896 speedtest1_begin_test(300, "Mandelbrot Set with spacing=%f", rSpacing);
897 speedtest1_prepare(
898 "WITH RECURSIVE \n"
899 " xaxis(x) AS (VALUES(-2.0) UNION ALL SELECT x+?1 FROM xaxis WHERE x<1.2),\n"
900 " yaxis(y) AS (VALUES(-1.0) UNION ALL SELECT y+?2 FROM yaxis WHERE y<1.0),\n"
901 " m(iter, cx, cy, x, y) AS (\n"
902 " SELECT 0, x, y, 0.0, 0.0 FROM xaxis, yaxis\n"
903 " UNION ALL\n"
904 " SELECT iter+1, cx, cy, x*x-y*y + cx, 2.0*x*y + cy FROM m \n"
905 " WHERE (x*x + y*y) < 4.0 AND iter<28\n"
906 " ),\n"
907 " m2(iter, cx, cy) AS (\n"
908 " SELECT max(iter), cx, cy FROM m GROUP BY cx, cy\n"
909 " ),\n"
910 " a(t) AS (\n"
911 " SELECT group_concat( substr(' .+*#', 1+min(iter/7,4), 1), '') \n"
912 " FROM m2 GROUP BY cy\n"
913 " )\n"
914 "SELECT group_concat(rtrim(t),x'0a') FROM a;"
915 );
916 sqlite3_bind_double(g.pStmt, 1, rSpacing*.05);
917 sqlite3_bind_double(g.pStmt, 2, rSpacing);
918 speedtest1_run();
919 speedtest1_end_test();
920
921 nElem = 10000*g.szTest;
922 speedtest1_begin_test(400, "EXCEPT operator on %d-element tables", nElem);
923 speedtest1_prepare(
924 "WITH RECURSIVE \n"
925 " t1(x) AS (VALUES(2) UNION ALL SELECT x+2 FROM t1 WHERE x<%d),\n"
926 " t2(y) AS (VALUES(3) UNION ALL SELECT y+3 FROM t2 WHERE y<%d)\n"
927 "SELECT count(x), avg(x) FROM (\n"
928 " SELECT x FROM t1 EXCEPT SELECT y FROM t2 ORDER BY 1\n"
929 ");",
930 nElem, nElem
931 );
932 speedtest1_run();
933 speedtest1_end_test();
934
935 }
936
937 #ifdef SQLITE_ENABLE_RTREE
938 /* Generate two numbers between 1 and mx. The first number is less than
939 ** the second. Usually the numbers are near each other but can sometimes
940 ** be far apart.
941 */
942 static void twoCoords(
943 int p1, int p2, /* Parameters adjusting sizes */
944 unsigned mx, /* Range of 1..mx */
945 unsigned *pX0, unsigned *pX1 /* OUT: write results here */
946 ){
947 unsigned d, x0, x1, span;
948
949 span = mx/100 + 1;
950 if( speedtest1_random()%3==0 ) span *= p1;
951 if( speedtest1_random()%p2==0 ) span = mx/2;
952 d = speedtest1_random()%span + 1;
953 x0 = speedtest1_random()%(mx-d) + 1;
954 x1 = x0 + d;
955 *pX0 = x0;
956 *pX1 = x1;
957 }
958 #endif
959
960 #ifdef SQLITE_ENABLE_RTREE
961 /* The following routine is an R-Tree geometry callback. It returns
962 ** true if the object overlaps a slice on the Y coordinate between the
963 ** two values given as arguments. In other words
964 **
965 ** SELECT count(*) FROM rt1 WHERE id MATCH xslice(10,20);
966 **
967 ** Is the same as saying:
968 **
969 ** SELECT count(*) FROM rt1 WHERE y1>=10 AND y0<=20;
970 */
971 static int xsliceGeometryCallback(
972 sqlite3_rtree_geometry *p,
973 int nCoord,
974 double *aCoord,
975 int *pRes
976 ){
977 *pRes = aCoord[3]>=p->aParam[0] && aCoord[2]<=p->aParam[1];
978 return SQLITE_OK;
979 }
980 #endif /* SQLITE_ENABLE_RTREE */
981
982 #ifdef SQLITE_ENABLE_RTREE
983 /*
984 ** A testset for the R-Tree virtual table
985 */
986 void testset_rtree(int p1, int p2){
987 unsigned i, n;
988 unsigned mxCoord;
989 unsigned x0, x1, y0, y1, z0, z1;
990 unsigned iStep;
991 int *aCheck = sqlite3_malloc( sizeof(int)*g.szTest*100 );
992
993 mxCoord = 15000;
994 n = g.szTest*100;
995 speedtest1_begin_test(100, "%d INSERTs into an r-tree", n);
996 speedtest1_exec("BEGIN");
997 speedtest1_exec("CREATE VIRTUAL TABLE rt1 USING rtree(id,x0,x1,y0,y1,z0,z1)");
998 speedtest1_prepare("INSERT INTO rt1(id,x0,x1,y0,y1,z0,z1)"
999 "VALUES(?1,?2,?3,?4,?5,?6,?7)");
1000 for(i=1; i<=n; i++){
1001 twoCoords(p1, p2, mxCoord, &x0, &x1);
1002 twoCoords(p1, p2, mxCoord, &y0, &y1);
1003 twoCoords(p1, p2, mxCoord, &z0, &z1);
1004 sqlite3_bind_int(g.pStmt, 1, i);
1005 sqlite3_bind_int(g.pStmt, 2, x0);
1006 sqlite3_bind_int(g.pStmt, 3, x1);
1007 sqlite3_bind_int(g.pStmt, 4, y0);
1008 sqlite3_bind_int(g.pStmt, 5, y1);
1009 sqlite3_bind_int(g.pStmt, 6, z0);
1010 sqlite3_bind_int(g.pStmt, 7, z1);
1011 speedtest1_run();
1012 }
1013 speedtest1_exec("COMMIT");
1014 speedtest1_end_test();
1015
1016 speedtest1_begin_test(101, "Copy from rtree to a regular table");
1017 speedtest1_exec("CREATE TABLE t1(id INTEGER PRIMARY KEY,x0,x1,y0,y1,z0,z1)");
1018 speedtest1_exec("INSERT INTO t1 SELECT * FROM rt1");
1019 speedtest1_end_test();
1020
1021 n = g.szTest*20;
1022 speedtest1_begin_test(110, "%d one-dimensional intersect slice queries", n);
1023 speedtest1_prepare("SELECT count(*) FROM rt1 WHERE x0>=?1 AND x1<=?2");
1024 iStep = mxCoord/n;
1025 for(i=0; i<n; i++){
1026 sqlite3_bind_int(g.pStmt, 1, i*iStep);
1027 sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
1028 speedtest1_run();
1029 aCheck[i] = atoi(g.zResult);
1030 }
1031 speedtest1_end_test();
1032
1033 if( g.bVerify ){
1034 n = g.szTest*20;
1035 speedtest1_begin_test(111, "Verify result from 1-D intersect slice queries");
1036 speedtest1_prepare("SELECT count(*) FROM t1 WHERE x0>=?1 AND x1<=?2");
1037 iStep = mxCoord/n;
1038 for(i=0; i<n; i++){
1039 sqlite3_bind_int(g.pStmt, 1, i*iStep);
1040 sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
1041 speedtest1_run();
1042 if( aCheck[i]!=atoi(g.zResult) ){
1043 fatal_error("Count disagree step %d: %d..%d. %d vs %d",
1044 i, i*iStep, (i+1)*iStep, aCheck[i], atoi(g.zResult));
1045 }
1046 }
1047 speedtest1_end_test();
1048 }
1049
1050 n = g.szTest*20;
1051 speedtest1_begin_test(120, "%d one-dimensional overlap slice queries", n);
1052 speedtest1_prepare("SELECT count(*) FROM rt1 WHERE y1>=?1 AND y0<=?2");
1053 iStep = mxCoord/n;
1054 for(i=0; i<n; i++){
1055 sqlite3_bind_int(g.pStmt, 1, i*iStep);
1056 sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
1057 speedtest1_run();
1058 aCheck[i] = atoi(g.zResult);
1059 }
1060 speedtest1_end_test();
1061
1062 if( g.bVerify ){
1063 n = g.szTest*20;
1064 speedtest1_begin_test(121, "Verify result from 1-D overlap slice queries");
1065 speedtest1_prepare("SELECT count(*) FROM t1 WHERE y1>=?1 AND y0<=?2");
1066 iStep = mxCoord/n;
1067 for(i=0; i<n; i++){
1068 sqlite3_bind_int(g.pStmt, 1, i*iStep);
1069 sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
1070 speedtest1_run();
1071 if( aCheck[i]!=atoi(g.zResult) ){
1072 fatal_error("Count disagree step %d: %d..%d. %d vs %d",
1073 i, i*iStep, (i+1)*iStep, aCheck[i], atoi(g.zResult));
1074 }
1075 }
1076 speedtest1_end_test();
1077 }
1078
1079
1080 n = g.szTest*20;
1081 speedtest1_begin_test(125, "%d custom geometry callback queries", n);
1082 sqlite3_rtree_geometry_callback(g.db, "xslice", xsliceGeometryCallback, 0);
1083 speedtest1_prepare("SELECT count(*) FROM rt1 WHERE id MATCH xslice(?1,?2)");
1084 iStep = mxCoord/n;
1085 for(i=0; i<n; i++){
1086 sqlite3_bind_int(g.pStmt, 1, i*iStep);
1087 sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
1088 speedtest1_run();
1089 if( aCheck[i]!=atoi(g.zResult) ){
1090 fatal_error("Count disagree step %d: %d..%d. %d vs %d",
1091 i, i*iStep, (i+1)*iStep, aCheck[i], atoi(g.zResult));
1092 }
1093 }
1094 speedtest1_end_test();
1095
1096 n = g.szTest*80;
1097 speedtest1_begin_test(130, "%d three-dimensional intersect box queries", n);
1098 speedtest1_prepare("SELECT count(*) FROM rt1 WHERE x1>=?1 AND x0<=?2"
1099 " AND y1>=?1 AND y0<=?2 AND z1>=?1 AND z0<=?2");
1100 iStep = mxCoord/n;
1101 for(i=0; i<n; i++){
1102 sqlite3_bind_int(g.pStmt, 1, i*iStep);
1103 sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
1104 speedtest1_run();
1105 aCheck[i] = atoi(g.zResult);
1106 }
1107 speedtest1_end_test();
1108
1109 n = g.szTest*100;
1110 speedtest1_begin_test(140, "%d rowid queries", n);
1111 speedtest1_prepare("SELECT * FROM rt1 WHERE id=?1");
1112 for(i=1; i<=n; i++){
1113 sqlite3_bind_int(g.pStmt, 1, i);
1114 speedtest1_run();
1115 }
1116 speedtest1_end_test();
1117 }
1118 #endif /* SQLITE_ENABLE_RTREE */
1119
1120 /*
1121 ** A testset used for debugging speedtest1 itself.
1122 */
1123 void testset_debug1(void){
1124 unsigned i, n;
1125 unsigned x1, x2;
1126 char zNum[2000]; /* A number name */
1127
1128 n = g.szTest;
1129 for(i=1; i<=n; i++){
1130 x1 = swizzle(i, n);
1131 x2 = swizzle(x1, n);
1132 speedtest1_numbername(x1, zNum, sizeof(zNum));
1133 printf("%5d %5d %5d %s\n", i, x1, x2, zNum);
1134 }
1135 }
1136
1137 int main(int argc, char **argv){
1138 int doAutovac = 0; /* True for --autovacuum */
1139 int cacheSize = 0; /* Desired cache size. 0 means default */
1140 int doExclusive = 0; /* True for --exclusive */
1141 int nHeap = 0, mnHeap = 0; /* Heap size from --heap */
1142 int doIncrvac = 0; /* True for --incrvacuum */
1143 const char *zJMode = 0; /* Journal mode */
1144 const char *zKey = 0; /* Encryption key */
1145 int nLook = 0, szLook = 0; /* --lookaside configuration */
1146 int noSync = 0; /* True for --nosync */
1147 int pageSize = 0; /* Desired page size. 0 means default */
1148 int nPCache = 0, szPCache = 0;/* --pcache configuration */
1149 int nScratch = 0, szScratch=0;/* --scratch configuration */
1150 int showStats = 0; /* True for --stats */
1151 int nThread = 0; /* --threads value */
1152 const char *zTSet = "main"; /* Which --testset torun */
1153 int doTrace = 0; /* True for --trace */
1154 const char *zEncoding = 0; /* --utf16be or --utf16le */
1155 const char *zDbName = 0; /* Name of the test database */
1156
1157 void *pHeap = 0; /* Allocated heap space */
1158 void *pLook = 0; /* Allocated lookaside space */
1159 void *pPCache = 0; /* Allocated storage for pcache */
1160 void *pScratch = 0; /* Allocated storage for scratch */
1161 int iCur, iHi; /* Stats values, current and "highwater" */
1162 int i; /* Loop counter */
1163 int rc; /* API return code */
1164
1165 /* Process command-line arguments */
1166 g.zWR = "";
1167 g.zNN = "";
1168 g.zPK = "UNIQUE";
1169 g.szTest = 100;
1170 for(i=1; i<argc; i++){
1171 const char *z = argv[i];
1172 if( z[0]=='-' ){
1173 do{ z++; }while( z[0]=='-' );
1174 if( strcmp(z,"autovacuum")==0 ){
1175 doAutovac = 1;
1176 }else if( strcmp(z,"cachesize")==0 ){
1177 if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
1178 i++;
1179 cacheSize = integerValue(argv[i]);
1180 }else if( strcmp(z,"exclusive")==0 ){
1181 doExclusive = 1;
1182 }else if( strcmp(z,"explain")==0 ){
1183 g.bSqlOnly = 1;
1184 g.bExplain = 1;
1185 }else if( strcmp(z,"heap")==0 ){
1186 if( i>=argc-2 ) fatal_error("missing arguments on %s\n", argv[i]);
1187 nHeap = integerValue(argv[i+1]);
1188 mnHeap = integerValue(argv[i+2]);
1189 i += 2;
1190 }else if( strcmp(z,"incrvacuum")==0 ){
1191 doIncrvac = 1;
1192 }else if( strcmp(z,"journal")==0 ){
1193 if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
1194 zJMode = argv[++i];
1195 }else if( strcmp(z,"key")==0 ){
1196 if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
1197 zKey = argv[++i];
1198 }else if( strcmp(z,"lookaside")==0 ){
1199 if( i>=argc-2 ) fatal_error("missing arguments on %s\n", argv[i]);
1200 nLook = integerValue(argv[i+1]);
1201 szLook = integerValue(argv[i+2]);
1202 i += 2;
1203 }else if( strcmp(z,"nosync")==0 ){
1204 noSync = 1;
1205 }else if( strcmp(z,"notnull")==0 ){
1206 g.zNN = "NOT NULL";
1207 }else if( strcmp(z,"pagesize")==0 ){
1208 if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
1209 pageSize = integerValue(argv[++i]);
1210 }else if( strcmp(z,"pcache")==0 ){
1211 if( i>=argc-2 ) fatal_error("missing arguments on %s\n", argv[i]);
1212 nPCache = integerValue(argv[i+1]);
1213 szPCache = integerValue(argv[i+2]);
1214 i += 2;
1215 }else if( strcmp(z,"primarykey")==0 ){
1216 g.zPK = "PRIMARY KEY";
1217 }else if( strcmp(z,"reprepare")==0 ){
1218 g.bReprepare = 1;
1219 }else if( strcmp(z,"scratch")==0 ){
1220 if( i>=argc-2 ) fatal_error("missing arguments on %s\n", argv[i]);
1221 nScratch = integerValue(argv[i+1]);
1222 szScratch = integerValue(argv[i+2]);
1223 i += 2;
1224 }else if( strcmp(z,"sqlonly")==0 ){
1225 g.bSqlOnly = 1;
1226 }else if( strcmp(z,"size")==0 ){
1227 if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
1228 g.szTest = integerValue(argv[++i]);
1229 }else if( strcmp(z,"stats")==0 ){
1230 showStats = 1;
1231 }else if( strcmp(z,"testset")==0 ){
1232 if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
1233 zTSet = argv[++i];
1234 }else if( strcmp(z,"trace")==0 ){
1235 doTrace = 1;
1236 }else if( strcmp(z,"threads")==0 ){
1237 if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
1238 nThread = integerValue(argv[++i]);
1239 }else if( strcmp(z,"utf16le")==0 ){
1240 zEncoding = "utf16le";
1241 }else if( strcmp(z,"utf16be")==0 ){
1242 zEncoding = "utf16be";
1243 }else if( strcmp(z,"verify")==0 ){
1244 g.bVerify = 1;
1245 }else if( strcmp(z,"without-rowid")==0 ){
1246 g.zWR = "WITHOUT ROWID";
1247 g.zPK = "PRIMARY KEY";
1248 }else if( strcmp(z, "help")==0 || strcmp(z,"?")==0 ){
1249 printf(zHelp, argv[0]);
1250 exit(0);
1251 }else{
1252 fatal_error("unknown option: %s\nUse \"%s -?\" for help\n",
1253 argv[i], argv[0]);
1254 }
1255 }else if( zDbName==0 ){
1256 zDbName = argv[i];
1257 }else{
1258 fatal_error("surplus argument: %s\nUse \"%s -?\" for help\n",
1259 argv[i], argv[0]);
1260 }
1261 }
1262 #if 0
1263 if( zDbName==0 ){
1264 fatal_error(zHelp, argv[0]);
1265 }
1266 #endif
1267 if( nHeap>0 ){
1268 pHeap = malloc( nHeap );
1269 if( pHeap==0 ) fatal_error("cannot allocate %d-byte heap\n", nHeap);
1270 rc = sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nHeap, mnHeap);
1271 if( rc ) fatal_error("heap configuration failed: %d\n", rc);
1272 }
1273 if( nPCache>0 && szPCache>0 ){
1274 pPCache = malloc( nPCache*(sqlite3_int64)szPCache );
1275 if( pPCache==0 ) fatal_error("cannot allocate %lld-byte pcache\n",
1276 nPCache*(sqlite3_int64)szPCache);
1277 rc = sqlite3_config(SQLITE_CONFIG_PAGECACHE, pPCache, szPCache, nPCache);
1278 if( rc ) fatal_error("pcache configuration failed: %d\n", rc);
1279 }
1280 if( nScratch>0 && szScratch>0 ){
1281 pScratch = malloc( nScratch*(sqlite3_int64)szScratch );
1282 if( pScratch==0 ) fatal_error("cannot allocate %lld-byte scratch\n",
1283 nScratch*(sqlite3_int64)szScratch);
1284 rc = sqlite3_config(SQLITE_CONFIG_SCRATCH, pScratch, szScratch, nScratch);
1285 if( rc ) fatal_error("scratch configuration failed: %d\n", rc);
1286 }
1287 if( nLook>0 ){
1288 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, 0, 0);
1289 }
1290
1291 /* Open the database and the input file */
1292 if( sqlite3_open(zDbName, &g.db) ){
1293 fatal_error("Cannot open database file: %s\n", zDbName);
1294 }
1295 if( nLook>0 && szLook>0 ){
1296 pLook = malloc( nLook*szLook );
1297 rc = sqlite3_db_config(g.db, SQLITE_DBCONFIG_LOOKASIDE, pLook, szLook,nLook);
1298 if( rc ) fatal_error("lookaside configuration failed: %d\n", rc);
1299 }
1300
1301 /* Set database connection options */
1302 sqlite3_create_function(g.db, "random", 0, SQLITE_UTF8, 0, randomFunc, 0, 0);
1303 if( doTrace ) sqlite3_trace(g.db, traceCallback, 0);
1304 speedtest1_exec("PRAGMA threads=%d", nThread);
1305 if( zKey ){
1306 speedtest1_exec("PRAGMA key('%s')", zKey);
1307 }
1308 if( zEncoding ){
1309 speedtest1_exec("PRAGMA encoding=%s", zEncoding);
1310 }
1311 if( doAutovac ){
1312 speedtest1_exec("PRAGMA auto_vacuum=FULL");
1313 }else if( doIncrvac ){
1314 speedtest1_exec("PRAGMA auto_vacuum=INCREMENTAL");
1315 }
1316 if( pageSize ){
1317 speedtest1_exec("PRAGMA page_size=%d", pageSize);
1318 }
1319 if( cacheSize ){
1320 speedtest1_exec("PRAGMA cache_size=%d", cacheSize);
1321 }
1322 if( noSync ) speedtest1_exec("PRAGMA synchronous=OFF");
1323 if( doExclusive ){
1324 speedtest1_exec("PRAGMA locking_mode=EXCLUSIVE");
1325 }
1326 if( zJMode ){
1327 speedtest1_exec("PRAGMA journal_mode=%s", zJMode);
1328 }
1329
1330 if( g.bExplain ) printf(".explain\n.echo on\n");
1331 if( strcmp(zTSet,"main")==0 ){
1332 testset_main();
1333 }else if( strcmp(zTSet,"debug1")==0 ){
1334 testset_debug1();
1335 }else if( strcmp(zTSet,"cte")==0 ){
1336 testset_cte();
1337 }else if( strcmp(zTSet,"rtree")==0 ){
1338 #ifdef SQLITE_ENABLE_RTREE
1339 testset_rtree(6, 147);
1340 #else
1341 fatal_error("compile with -DSQLITE_ENABLE_RTREE to enable "
1342 "the R-Tree tests\n");
1343 #endif
1344 }else{
1345 fatal_error("unknown testset: \"%s\"\nChoices: main debug1 cte rtree\n",
1346 zTSet);
1347 }
1348 speedtest1_final();
1349
1350 /* Database connection statistics printed after both prepared statements
1351 ** have been finalized */
1352 #if SQLITE_VERSION_NUMBER>=3007009
1353 if( showStats ){
1354 sqlite3_db_status(g.db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHi, 0);
1355 printf("-- Lookaside Slots Used: %d (max %d)\n", iCur,iHi);
1356 sqlite3_db_status(g.db, SQLITE_DBSTATUS_LOOKASIDE_HIT, &iCur, &iHi, 0);
1357 printf("-- Successful lookasides: %d\n", iHi);
1358 sqlite3_db_status(g.db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, &iCur,&iHi,0);
1359 printf("-- Lookaside size faults: %d\n", iHi);
1360 sqlite3_db_status(g.db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, &iCur,&iHi,0);
1361 printf("-- Lookaside OOM faults: %d\n", iHi);
1362 sqlite3_db_status(g.db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHi, 0);
1363 printf("-- Pager Heap Usage: %d bytes\n", iCur);
1364 sqlite3_db_status(g.db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHi, 1);
1365 printf("-- Page cache hits: %d\n", iCur);
1366 sqlite3_db_status(g.db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHi, 1);
1367 printf("-- Page cache misses: %d\n", iCur);
1368 #if SQLITE_VERSION_NUMBER>=3007012
1369 sqlite3_db_status(g.db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHi, 1);
1370 printf("-- Page cache writes: %d\n", iCur);
1371 #endif
1372 sqlite3_db_status(g.db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHi, 0);
1373 printf("-- Schema Heap Usage: %d bytes\n", iCur);
1374 sqlite3_db_status(g.db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHi, 0);
1375 printf("-- Statement Heap Usage: %d bytes\n", iCur);
1376 }
1377 #endif
1378
1379 sqlite3_close(g.db);
1380
1381 /* Global memory usage statistics printed after the database connection
1382 ** has closed. Memory usage should be zero at this point. */
1383 if( showStats ){
1384 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHi, 0);
1385 printf("-- Memory Used (bytes): %d (max %d)\n", iCur,iHi);
1386 #if SQLITE_VERSION_NUMBER>=3007000
1387 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHi, 0);
1388 printf("-- Outstanding Allocations: %d (max %d)\n", iCur,iHi);
1389 #endif
1390 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHi, 0);
1391 printf("-- Pcache Overflow Bytes: %d (max %d)\n", iCur,iHi);
1392 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHi, 0);
1393 printf("-- Scratch Overflow Bytes: %d (max %d)\n", iCur,iHi);
1394 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHi, 0);
1395 printf("-- Largest Allocation: %d bytes\n",iHi);
1396 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHi, 0);
1397 printf("-- Largest Pcache Allocation: %d bytes\n",iHi);
1398 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHi, 0);
1399 printf("-- Largest Scratch Allocation: %d bytes\n", iHi);
1400 }
1401
1402 /* Release memory */
1403 free( pLook );
1404 free( pPCache );
1405 free( pScratch );
1406 free( pHeap );
1407 return 0;
1408 }