diff options
Diffstat (limited to 'test/wordcount.c')
| -rw-r--r-- | test/wordcount.c | 659 |
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; +} |