summaryrefslogtreecommitdiffstats
path: root/test/wordcount.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/wordcount.c')
-rw-r--r--test/wordcount.c659
1 files changed, 659 insertions, 0 deletions
diff --git a/test/wordcount.c b/test/wordcount.c
new file mode 100644
index 0000000..4a21d25
--- /dev/null
+++ b/test/wordcount.c
@@ -0,0 +1,659 @@
+/*
+** This C program extracts all "words" from an input document and adds them
+** to an SQLite database. A "word" is any contiguous sequence of alphabetic
+** characters. All digits, punctuation, and whitespace characters are
+** word separators. The database stores a single entry for each distinct
+** word together with a count of the number of occurrences of that word.
+** A fresh database is created automatically on each run.
+**
+** wordcount DATABASE INPUTFILE
+**
+** The INPUTFILE name can be omitted, in which case input it taken from
+** standard input.
+**
+** Option:
+**
+**
+** Modes:
+**
+** Insert mode means:
+** (1) INSERT OR IGNORE INTO wordcount VALUES($new,1)
+** (2) UPDATE wordcount SET cnt=cnt+1 WHERE word=$new -- if (1) is a noop
+**
+** Update mode means:
+** (1) INSERT OR IGNORE INTO wordcount VALUES($new,0)
+** (2) UPDATE wordcount SET cnt=cnt+1 WHERE word=$new
+**
+** Replace mode means:
+** (1) REPLACE INTO wordcount
+** VALUES($new,ifnull((SELECT cnt FROM wordcount WHERE word=$new),0)+1);
+**
+** Upsert mode means:
+** (1) INSERT INTO wordcount VALUES($new,1)
+** ON CONFLICT(word) DO UPDATE SET cnt=cnt+1
+**
+** Select mode means:
+** (1) SELECT 1 FROM wordcount WHERE word=$new
+** (2) INSERT INTO wordcount VALUES($new,1) -- if (1) returns nothing
+** (3) UPDATE wordcount SET cnt=cnt+1 WHERE word=$new --if (1) return TRUE
+**
+** Delete mode means:
+** (1) DELETE FROM wordcount WHERE word=$new
+**
+** Query mode means:
+** (1) SELECT cnt FROM wordcount WHERE word=$new
+**
+** Note that delete mode and query mode are only useful for preexisting
+** databases. The wordcount table is created using IF NOT EXISTS so this
+** utility can be run multiple times on the same database file. The
+** --without-rowid, --nocase, and --pagesize parameters are only effective
+** when creating a new database and are harmless no-ops on preexisting
+** databases.
+**
+******************************************************************************
+**
+** Compile as follows:
+**
+** gcc -I. wordcount.c sqlite3.c -ldl -lpthreads
+**
+** Or:
+**
+** gcc -I. -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION \
+** wordcount.c sqlite3.c
+*/
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include "sqlite3.h"
+#ifndef _WIN32
+# include <unistd.h>
+#else
+# include <io.h>
+#endif
+#define ISALPHA(X) isalpha((unsigned char)(X))
+
+const char zHelp[] =
+"Usage: wordcount [OPTIONS] DATABASE [INPUT]\n"
+" --all Repeat the test for all test modes\n"
+" --cachesize NNN Use a cache size of NNN\n"
+" --commit NNN Commit after every NNN operations\n"
+" --delete Use DELETE mode\n"
+" --insert Use INSERT mode (the default)\n"
+" --journal MMMM Use PRAGMA journal_mode=MMMM\n"
+" --nocase Add the NOCASE collating sequence to the words.\n"
+" --nosync Use PRAGMA synchronous=OFF\n"
+" --pagesize NNN Use a page size of NNN\n"
+" --query Use QUERY mode\n"
+" --replace Use REPLACE mode\n"
+" --select Use SELECT mode\n"
+" --stats Show sqlite3_status() results at the end.\n"
+" --summary Show summary information on the collected data.\n"
+" --tag NAME Tag all output using NAME. Use only stdout.\n"
+" --timer Time the operation of this program\n"
+" --trace Enable sqlite3_trace() output.\n"
+" --update Use UPDATE mode\n"
+" --upsert Use UPSERT mode\n"
+" --without-rowid Use a WITHOUT ROWID table to store the words.\n"
+;
+
+/* Output tag */
+char *zTag = "--";
+
+/* Return the current wall-clock time */
+static sqlite3_int64 realTime(void){
+ static sqlite3_vfs *clockVfs = 0;
+ sqlite3_int64 t;
+ if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
+ if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
+ clockVfs->xCurrentTimeInt64(clockVfs, &t);
+ }else{
+ double r;
+ clockVfs->xCurrentTime(clockVfs, &r);
+ t = (sqlite3_int64)(r*86400000.0);
+ }
+ return t;
+}
+
+/* Print an error message and exit */
+static void fatal_error(const char *zMsg, ...){
+ va_list ap;
+ va_start(ap, zMsg);
+ vfprintf(stderr, zMsg, ap);
+ va_end(ap);
+ exit(1);
+}
+
+/* Print a usage message and quit */
+static void usage(void){
+ printf("%s",zHelp);
+ exit(0);
+}
+
+/* The sqlite3_trace() callback function */
+static void traceCallback(void *NotUsed, const char *zSql){
+ printf("%s;\n", zSql);
+}
+
+/* An sqlite3_exec() callback that prints results on standard output,
+** each column separated by a single space. */
+static int printResult(void *NotUsed, int nArg, char **azArg, char **azNm){
+ int i;
+ printf("%s", zTag);
+ for(i=0; i<nArg; i++){
+ printf(" %s", azArg[i] ? azArg[i] : "(null)");
+ }
+ printf("\n");
+ return 0;
+}
+
+
+/*
+** Add one character to a hash
+*/
+static void addCharToHash(unsigned int *a, unsigned char x){
+ if( a[0]<4 ){
+ a[1] = (a[1]<<8) | x;
+ a[0]++;
+ }else{
+ a[2] = (a[2]<<8) | x;
+ a[0]++;
+ if( a[0]==8 ){
+ a[3] += a[1] + a[4];
+ a[4] += a[2] + a[3];
+ a[0] = a[1] = a[2] = 0;
+ }
+ }
+}
+
+/*
+** Compute the final hash value.
+*/
+static void finalHash(unsigned int *a, char *z){
+ a[3] += a[1] + a[4] + a[0];
+ a[4] += a[2] + a[3];
+ sqlite3_snprintf(17, z, "%08x%08x", a[3], a[4]);
+}
+
+
+/*
+** Implementation of a checksum() aggregate SQL function
+*/
+static void checksumStep(
+ sqlite3_context *context,
+ int argc,
+ sqlite3_value **argv
+){
+ const unsigned char *zVal;
+ int nVal, i, j;
+ unsigned int *a;
+ a = (unsigned*)sqlite3_aggregate_context(context, sizeof(unsigned int)*5);
+
+ if( a ){
+ for(i=0; i<argc; i++){
+ nVal = sqlite3_value_bytes(argv[i]);
+ zVal = (const unsigned char*)sqlite3_value_text(argv[i]);
+ if( zVal ) for(j=0; j<nVal; j++) addCharToHash(a, zVal[j]);
+ addCharToHash(a, '|');
+ }
+ addCharToHash(a, '\n');
+ }
+}
+static void checksumFinalize(sqlite3_context *context){
+ unsigned int *a;
+ char zResult[24];
+ a = sqlite3_aggregate_context(context, 0);
+ if( a ){
+ finalHash(a, zResult);
+ sqlite3_result_text(context, zResult, -1, SQLITE_TRANSIENT);
+ }
+}
+
+/* Define operating modes */
+#define MODE_INSERT 0
+#define MODE_REPLACE 1
+#define MODE_UPSERT 2
+#define MODE_SELECT 3
+#define MODE_UPDATE 4
+#define MODE_DELETE 5
+#define MODE_QUERY 6
+#define MODE_COUNT 7
+#define MODE_ALL (-1)
+
+/* Mode names */
+static const char *azMode[] = {
+ "--insert",
+ "--replace",
+ "--upsert",
+ "--select",
+ "--update",
+ "--delete",
+ "--query"
+};
+
+/*
+** Determine if another iteration of the test is required. Return true
+** if so. Return zero if all iterations have finished.
+*/
+static int allLoop(
+ int iMode, /* The selected test mode */
+ int *piLoopCnt, /* Iteration loop counter */
+ int *piMode2, /* The test mode to use on the next iteration */
+ int *pUseWithoutRowid /* Whether or not to use --without-rowid */
+){
+ int i;
+ if( iMode!=MODE_ALL ){
+ if( *piLoopCnt ) return 0;
+ *piMode2 = iMode;
+ *piLoopCnt = 1;
+ return 1;
+ }
+ if( (*piLoopCnt)>=MODE_COUNT*2 ) return 0;
+ i = (*piLoopCnt)++;
+ *pUseWithoutRowid = i&1;
+ *piMode2 = i>>1;
+ return 1;
+}
+
+int main(int argc, char **argv){
+ const char *zFileToRead = 0; /* Input file. NULL for stdin */
+ const char *zDbName = 0; /* Name of the database file to create */
+ int useWithoutRowid = 0; /* True for --without-rowid */
+ int iMode = MODE_INSERT; /* One of MODE_xxxxx */
+ int iMode2; /* Mode to use for current --all iteration */
+ int iLoopCnt = 0; /* Which iteration when running --all */
+ int useNocase = 0; /* True for --nocase */
+ int doTrace = 0; /* True for --trace */
+ int showStats = 0; /* True for --stats */
+ int showSummary = 0; /* True for --summary */
+ int showTimer = 0; /* True for --timer */
+ int cacheSize = 0; /* Desired cache size. 0 means default */
+ int pageSize = 0; /* Desired page size. 0 means default */
+ int commitInterval = 0; /* How often to commit. 0 means never */
+ int noSync = 0; /* True for --nosync */
+ const char *zJMode = 0; /* Journal mode */
+ int nOp = 0; /* Operation counter */
+ int i, j; /* Loop counters */
+ sqlite3 *db; /* The SQLite database connection */
+ char *zSql; /* Constructed SQL statement */
+ sqlite3_stmt *pInsert = 0; /* The INSERT statement */
+ sqlite3_stmt *pUpdate = 0; /* The UPDATE statement */
+ sqlite3_stmt *pSelect = 0; /* The SELECT statement */
+ sqlite3_stmt *pDelete = 0; /* The DELETE statement */
+ FILE *in; /* The open input file */
+ int rc; /* Return code from an SQLite interface */
+ int iCur, iHiwtr; /* Statistics values, current and "highwater" */
+ FILE *pTimer = stderr; /* Output channel for the timer */
+ sqlite3_int64 sumCnt = 0; /* Sum in QUERY mode */
+ sqlite3_int64 startTime; /* Time of start */
+ sqlite3_int64 totalTime = 0; /* Total time */
+ char zInput[2000]; /* A single line of input */
+
+ /* Process command-line arguments */
+ for(i=1; i<argc; i++){
+ const char *z = argv[i];
+ if( z[0]=='-' ){
+ do{ z++; }while( z[0]=='-' );
+ if( strcmp(z,"without-rowid")==0 ){
+ useWithoutRowid = 1;
+ }else if( strcmp(z,"replace")==0 ){
+ iMode = MODE_REPLACE;
+ }else if( strcmp(z,"upsert")==0 ){
+ iMode = MODE_UPSERT;
+ }else if( strcmp(z,"select")==0 ){
+ iMode = MODE_SELECT;
+ }else if( strcmp(z,"insert")==0 ){
+ iMode = MODE_INSERT;
+ }else if( strcmp(z,"update")==0 ){
+ iMode = MODE_UPDATE;
+ }else if( strcmp(z,"delete")==0 ){
+ iMode = MODE_DELETE;
+ }else if( strcmp(z,"query")==0 ){
+ iMode = MODE_QUERY;
+ }else if( strcmp(z,"all")==0 ){
+ iMode = MODE_ALL;
+ showTimer = -99;
+ }else if( strcmp(z,"nocase")==0 ){
+ useNocase = 1;
+ }else if( strcmp(z,"trace")==0 ){
+ doTrace = 1;
+ }else if( strcmp(z,"nosync")==0 ){
+ noSync = 1;
+ }else if( strcmp(z,"stats")==0 ){
+ showStats = 1;
+ }else if( strcmp(z,"summary")==0 ){
+ showSummary = 1;
+ }else if( strcmp(z,"timer")==0 ){
+ showTimer = i;
+ }else if( strcmp(z,"cachesize")==0 && i<argc-1 ){
+ i++;
+ cacheSize = atoi(argv[i]);
+ }else if( strcmp(z,"pagesize")==0 && i<argc-1 ){
+ i++;
+ pageSize = atoi(argv[i]);
+ }else if( strcmp(z,"commit")==0 && i<argc-1 ){
+ i++;
+ commitInterval = atoi(argv[i]);
+ }else if( strcmp(z,"journal")==0 && i<argc-1 ){
+ zJMode = argv[++i];
+ }else if( strcmp(z,"tag")==0 && i<argc-1 ){
+ zTag = argv[++i];
+ pTimer = stdout;
+ }else if( strcmp(z, "help")==0 || strcmp(z,"?")==0 ){
+ usage();
+ }else{
+ fatal_error("unknown option: \"%s\"\n"
+ "Use --help for a list of options\n",
+ argv[i]);
+ }
+ }else if( zDbName==0 ){
+ zDbName = argv[i];
+ }else if( zFileToRead==0 ){
+ zFileToRead = argv[i];
+ }else{
+ fatal_error("surplus argument: \"%s\"\n", argv[i]);
+ }
+ }
+ if( zDbName==0 ){
+ usage();
+ }
+ startTime = realTime();
+
+ /* Open the database and the input file */
+ if( zDbName[0] && strcmp(zDbName,":memory:")!=0 ){
+ unlink(zDbName);
+ }
+ if( sqlite3_open(zDbName, &db) ){
+ fatal_error("Cannot open database file: %s\n", zDbName);
+ }
+ if( zFileToRead ){
+ in = fopen(zFileToRead, "rb");
+ if( in==0 ){
+ fatal_error("Could not open input file \"%s\"\n", zFileToRead);
+ }
+ }else{
+ if( iMode==MODE_ALL ){
+ fatal_error("The --all mode cannot be used with stdin\n");
+ }
+ in = stdin;
+ }
+
+ /* Set database connection options */
+ if( doTrace ) sqlite3_trace(db, traceCallback, 0);
+ if( pageSize ){
+ zSql = sqlite3_mprintf("PRAGMA page_size=%d", pageSize);
+ sqlite3_exec(db, zSql, 0, 0, 0);
+ sqlite3_free(zSql);
+ }
+ if( cacheSize ){
+ zSql = sqlite3_mprintf("PRAGMA cache_size=%d", cacheSize);
+ sqlite3_exec(db, zSql, 0, 0, 0);
+ sqlite3_free(zSql);
+ }
+ if( noSync ) sqlite3_exec(db, "PRAGMA synchronous=OFF", 0, 0, 0);
+ if( zJMode ){
+ zSql = sqlite3_mprintf("PRAGMA journal_mode=%s", zJMode);
+ sqlite3_exec(db, zSql, 0, 0, 0);
+ sqlite3_free(zSql);
+ }
+
+ iLoopCnt = 0;
+ while( allLoop(iMode, &iLoopCnt, &iMode2, &useWithoutRowid) ){
+ /* Delete prior content in --all mode */
+ if( iMode==MODE_ALL ){
+ if( sqlite3_exec(db, "DROP TABLE IF EXISTS wordcount; VACUUM;",0,0,0) ){
+ fatal_error("Could not clean up prior iteration\n");
+ }
+ startTime = realTime();
+ rewind(in);
+ }
+
+ /* Construct the "wordcount" table into which to put the words */
+ if( sqlite3_exec(db, "BEGIN IMMEDIATE", 0, 0, 0) ){
+ fatal_error("Could not start a transaction\n");
+ }
+ zSql = sqlite3_mprintf(
+ "CREATE TABLE IF NOT EXISTS wordcount(\n"
+ " word TEXT PRIMARY KEY COLLATE %s,\n"
+ " cnt INTEGER\n"
+ ")%s",
+ useNocase ? "nocase" : "binary",
+ useWithoutRowid ? " WITHOUT ROWID" : ""
+ );
+ if( zSql==0 ) fatal_error("out of memory\n");
+ rc = sqlite3_exec(db, zSql, 0, 0, 0);
+ if( rc ) fatal_error("Could not create the wordcount table: %s.\n",
+ sqlite3_errmsg(db));
+ sqlite3_free(zSql);
+
+ /* Prepare SQL statements that will be needed */
+ if( iMode2==MODE_QUERY ){
+ rc = sqlite3_prepare_v2(db,
+ "SELECT cnt FROM wordcount WHERE word=?1",
+ -1, &pSelect, 0);
+ if( rc ) fatal_error("Could not prepare the SELECT statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+ if( iMode2==MODE_SELECT ){
+ rc = sqlite3_prepare_v2(db,
+ "SELECT 1 FROM wordcount WHERE word=?1",
+ -1, &pSelect, 0);
+ if( rc ) fatal_error("Could not prepare the SELECT statement: %s\n",
+ sqlite3_errmsg(db));
+ rc = sqlite3_prepare_v2(db,
+ "INSERT INTO wordcount(word,cnt) VALUES(?1,1)",
+ -1, &pInsert, 0);
+ if( rc ) fatal_error("Could not prepare the INSERT statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+ if( iMode2==MODE_SELECT || iMode2==MODE_UPDATE || iMode2==MODE_INSERT ){
+ rc = sqlite3_prepare_v2(db,
+ "UPDATE wordcount SET cnt=cnt+1 WHERE word=?1",
+ -1, &pUpdate, 0);
+ if( rc ) fatal_error("Could not prepare the UPDATE statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+ if( iMode2==MODE_INSERT ){
+ rc = sqlite3_prepare_v2(db,
+ "INSERT OR IGNORE INTO wordcount(word,cnt) VALUES(?1,1)",
+ -1, &pInsert, 0);
+ if( rc ) fatal_error("Could not prepare the INSERT statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+ if( iMode2==MODE_UPDATE ){
+ rc = sqlite3_prepare_v2(db,
+ "INSERT OR IGNORE INTO wordcount(word,cnt) VALUES(?1,0)",
+ -1, &pInsert, 0);
+ if( rc ) fatal_error("Could not prepare the INSERT statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+ if( iMode2==MODE_REPLACE ){
+ rc = sqlite3_prepare_v2(db,
+ "REPLACE INTO wordcount(word,cnt)"
+ "VALUES(?1,coalesce((SELECT cnt FROM wordcount WHERE word=?1),0)+1)",
+ -1, &pInsert, 0);
+ if( rc ) fatal_error("Could not prepare the REPLACE statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+ if( iMode2==MODE_UPSERT ){
+ rc = sqlite3_prepare_v2(db,
+ "INSERT INTO wordcount(word,cnt) VALUES(?1,1) "
+ "ON CONFLICT(word) DO UPDATE SET cnt=cnt+1",
+ -1, &pInsert, 0);
+ if( rc ) fatal_error("Could not prepare the UPSERT statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+ if( iMode2==MODE_DELETE ){
+ rc = sqlite3_prepare_v2(db,
+ "DELETE FROM wordcount WHERE word=?1",
+ -1, &pDelete, 0);
+ if( rc ) fatal_error("Could not prepare the DELETE statement: %s\n",
+ sqlite3_errmsg(db));
+ }
+
+ /* Process the input file */
+ while( fgets(zInput, sizeof(zInput), in) ){
+ for(i=0; zInput[i]; i++){
+ if( !ISALPHA(zInput[i]) ) continue;
+ for(j=i+1; ISALPHA(zInput[j]); j++){}
+
+ /* Found a new word at zInput[i] that is j-i bytes long.
+ ** Process it into the wordcount table. */
+ if( iMode2==MODE_DELETE ){
+ sqlite3_bind_text(pDelete, 1, zInput+i, j-i, SQLITE_STATIC);
+ if( sqlite3_step(pDelete)!=SQLITE_DONE ){
+ fatal_error("DELETE failed: %s\n", sqlite3_errmsg(db));
+ }
+ sqlite3_reset(pDelete);
+ }else if( iMode2==MODE_SELECT ){
+ sqlite3_bind_text(pSelect, 1, zInput+i, j-i, SQLITE_STATIC);
+ rc = sqlite3_step(pSelect);
+ sqlite3_reset(pSelect);
+ if( rc==SQLITE_ROW ){
+ sqlite3_bind_text(pUpdate, 1, zInput+i, j-i, SQLITE_STATIC);
+ if( sqlite3_step(pUpdate)!=SQLITE_DONE ){
+ fatal_error("UPDATE failed: %s\n", sqlite3_errmsg(db));
+ }
+ sqlite3_reset(pUpdate);
+ }else if( rc==SQLITE_DONE ){
+ sqlite3_bind_text(pInsert, 1, zInput+i, j-i, SQLITE_STATIC);
+ if( sqlite3_step(pInsert)!=SQLITE_DONE ){
+ fatal_error("Insert failed: %s\n", sqlite3_errmsg(db));
+ }
+ sqlite3_reset(pInsert);
+ }else{
+ fatal_error("SELECT failed: %s\n", sqlite3_errmsg(db));
+ }
+ }else if( iMode2==MODE_QUERY ){
+ sqlite3_bind_text(pSelect, 1, zInput+i, j-i, SQLITE_STATIC);
+ if( sqlite3_step(pSelect)==SQLITE_ROW ){
+ sumCnt += sqlite3_column_int64(pSelect, 0);
+ }
+ sqlite3_reset(pSelect);
+ }else{
+ sqlite3_bind_text(pInsert, 1, zInput+i, j-i, SQLITE_STATIC);
+ if( sqlite3_step(pInsert)!=SQLITE_DONE ){
+ fatal_error("INSERT failed: %s\n", sqlite3_errmsg(db));
+ }
+ sqlite3_reset(pInsert);
+ if( iMode2==MODE_UPDATE
+ || (iMode2==MODE_INSERT && sqlite3_changes(db)==0)
+ ){
+ sqlite3_bind_text(pUpdate, 1, zInput+i, j-i, SQLITE_STATIC);
+ if( sqlite3_step(pUpdate)!=SQLITE_DONE ){
+ fatal_error("UPDATE failed: %s\n", sqlite3_errmsg(db));
+ }
+ sqlite3_reset(pUpdate);
+ }
+ }
+ i = j-1;
+
+ /* Increment the operation counter. Do a COMMIT if it is time. */
+ nOp++;
+ if( commitInterval>0 && (nOp%commitInterval)==0 ){
+ sqlite3_exec(db, "COMMIT; BEGIN IMMEDIATE", 0, 0, 0);
+ }
+ }
+ }
+ sqlite3_exec(db, "COMMIT", 0, 0, 0);
+ sqlite3_finalize(pInsert); pInsert = 0;
+ sqlite3_finalize(pUpdate); pUpdate = 0;
+ sqlite3_finalize(pSelect); pSelect = 0;
+ sqlite3_finalize(pDelete); pDelete = 0;
+
+ if( iMode2==MODE_QUERY && iMode!=MODE_ALL ){
+ printf("%s sum of cnt: %lld\n", zTag, sumCnt);
+ rc = sqlite3_prepare_v2(db,"SELECT sum(cnt*cnt) FROM wordcount", -1,
+ &pSelect, 0);
+ if( rc==SQLITE_OK && sqlite3_step(pSelect)==SQLITE_ROW ){
+ printf("%s double-check: %lld\n", zTag,sqlite3_column_int64(pSelect,0));
+ }
+ sqlite3_finalize(pSelect);
+ }
+
+
+ if( showTimer ){
+ sqlite3_int64 elapseTime = realTime() - startTime;
+ totalTime += elapseTime;
+ fprintf(pTimer, "%3d.%03d wordcount", (int)(elapseTime/1000),
+ (int)(elapseTime%1000));
+ if( iMode==MODE_ALL ){
+ fprintf(pTimer, " %s%s\n", azMode[iMode2],
+ useWithoutRowid? " --without-rowid" : "");
+ }else{
+ for(i=1; i<argc; i++) if( i!=showTimer ) fprintf(pTimer," %s",argv[i]);
+ fprintf(pTimer, "\n");
+ }
+ }
+
+ if( showSummary ){
+ sqlite3_create_function(db, "checksum", -1, SQLITE_UTF8, 0,
+ 0, checksumStep, checksumFinalize);
+ sqlite3_exec(db,
+ "SELECT 'count(*): ', count(*) FROM wordcount;\n"
+ "SELECT 'sum(cnt): ', sum(cnt) FROM wordcount;\n"
+ "SELECT 'max(cnt): ', max(cnt) FROM wordcount;\n"
+ "SELECT 'avg(cnt): ', avg(cnt) FROM wordcount;\n"
+ "SELECT 'sum(cnt=1):', sum(cnt=1) FROM wordcount;\n"
+ "SELECT 'top 10: ', group_concat(word, ', ') FROM "
+ "(SELECT word FROM wordcount ORDER BY cnt DESC, word LIMIT 10);\n"
+ "SELECT 'checksum: ', checksum(word, cnt) FROM "
+ "(SELECT word, cnt FROM wordcount ORDER BY word);\n"
+ "PRAGMA integrity_check;\n",
+ printResult, 0, 0);
+ }
+ } /* End the --all loop */
+
+ /* Close the input file after the last read */
+ if( zFileToRead ) fclose(in);
+
+ /* In --all mode, so the total time */
+ if( iMode==MODE_ALL && showTimer ){
+ fprintf(pTimer, "%3d.%03d wordcount --all\n", (int)(totalTime/1000),
+ (int)(totalTime%1000));
+ }
+
+ /* Database connection statistics printed after both prepared statements
+ ** have been finalized */
+ if( showStats ){
+ sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHiwtr, 0);
+ printf("%s Lookaside Slots Used: %d (max %d)\n", zTag, iCur,iHiwtr);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, &iCur, &iHiwtr, 0);
+ printf("%s Successful lookasides: %d\n", zTag, iHiwtr);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, &iCur,&iHiwtr,0);
+ printf("%s Lookaside size faults: %d\n", zTag, iHiwtr);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, &iCur,&iHiwtr,0);
+ printf("%s Lookaside OOM faults: %d\n", zTag, iHiwtr);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, 0);
+ printf("%s Pager Heap Usage: %d bytes\n", zTag, iCur);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
+ printf("%s Page cache hits: %d\n", zTag, iCur);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
+ printf("%s Page cache misses: %d\n", zTag, iCur);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
+ printf("%s Page cache writes: %d\n", zTag, iCur);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, 0);
+ printf("%s Schema Heap Usage: %d bytes\n", zTag, iCur);
+ sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, 0);
+ printf("%s Statement Heap Usage: %d bytes\n", zTag, iCur);
+ }
+
+ sqlite3_close(db);
+
+ /* Global memory usage statistics printed after the database connection
+ ** has closed. Memory usage should be zero at this point. */
+ if( showStats ){
+ sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, 0);
+ printf("%s Memory Used (bytes): %d (max %d)\n", zTag,iCur,iHiwtr);
+ sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, 0);
+ printf("%s Outstanding Allocations: %d (max %d)\n",zTag,iCur,iHiwtr);
+ sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, 0);
+ printf("%s Pcache Overflow Bytes: %d (max %d)\n",zTag,iCur,iHiwtr);
+ sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, 0);
+ printf("%s Largest Allocation: %d bytes\n",zTag,iHiwtr);
+ sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, 0);
+ printf("%s Largest Pcache Allocation: %d bytes\n",zTag,iHiwtr);
+ }
+ return 0;
+}