2 ** This file is automatically generated by the script in the canonical
3 ** SQLite source tree at tool/mkshellc.tcl. That script combines source
4 ** code from various constituent source files of SQLite into this single
5 ** "shell.c" file used to implement the SQLite command-line shell.
7 ** Most of the code found below comes from the "src/shell.c.in" file in
8 ** the canonical SQLite source tree. That main file contains "INCLUDE"
9 ** lines that specify other files in the canonical source tree that are
10 ** inserted to getnerate this complete program source file.
12 ** The code from multiple files is combined into this single "shell.c"
13 ** source file to help make the command-line program easier to compile.
15 ** To modify this program, get a copy of the canonical SQLite source tree,
16 ** edit the src/shell.c.in" and/or some of the other files that are included
17 ** by "src/shell.c.in", then rerun the tool/mkshellc.tcl script.
22 ** The author disclaims copyright to this source code. In place of
23 ** a legal notice, here is a blessing:
25 ** May you do good and not evil.
26 ** May you find forgiveness for yourself and forgive others.
27 ** May you share freely, never taking more than you give.
29 *************************************************************************
30 ** This file contains code to implement the "sqlite" command line
31 ** utility for accessing SQLite databases.
33 #if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
34 /* This needs to come before any includes for MSVC compiler */
35 #define _CRT_SECURE_NO_WARNINGS
39 ** Warning pragmas copied from msvc.h in the core.
42 #pragma warning(disable : 4054)
43 #pragma warning(disable : 4055)
44 #pragma warning(disable : 4100)
45 #pragma warning(disable : 4127)
46 #pragma warning(disable : 4130)
47 #pragma warning(disable : 4152)
48 #pragma warning(disable : 4189)
49 #pragma warning(disable : 4206)
50 #pragma warning(disable : 4210)
51 #pragma warning(disable : 4232)
52 #pragma warning(disable : 4244)
53 #pragma warning(disable : 4305)
54 #pragma warning(disable : 4306)
55 #pragma warning(disable : 4702)
56 #pragma warning(disable : 4706)
57 #endif /* defined(_MSC_VER) */
60 ** No support for loadable extensions in VxWorks.
62 #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
63 # define SQLITE_OMIT_LOAD_EXTENSION 1
67 ** Enable large-file support for fopen() and friends on unix.
69 #ifndef SQLITE_DISABLE_LFS
70 # define _LARGE_FILE 1
71 # ifndef _FILE_OFFSET_BITS
72 # define _FILE_OFFSET_BITS 64
74 # define _LARGEFILE_SOURCE 1
82 typedef sqlite3_int64 i64;
83 typedef sqlite3_uint64 u64;
84 typedef unsigned char u8;
85 #if SQLITE_USER_AUTHENTICATION
86 # include "sqlite3userauth.h"
91 #if !defined(_WIN32) && !defined(WIN32)
93 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
97 #if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__)
100 # define GETPID getpid
101 # if defined(__MINGW32__)
102 # define DIRENT dirent
104 # define S_ISLNK(mode) (0)
108 # define GETPID (int)GetCurrentProcessId
110 #include <sys/types.h>
111 #include <sys/stat.h>
114 # include <readline/readline.h>
115 # include <readline/history.h>
119 # include <editline/readline.h>
122 #if HAVE_EDITLINE || HAVE_READLINE
124 # define shell_add_history(X) add_history(X)
125 # define shell_read_history(X) read_history(X)
126 # define shell_write_history(X) write_history(X)
127 # define shell_stifle_history(X) stifle_history(X)
128 # define shell_readline(X) readline(X)
132 # include "linenoise.h"
133 # define shell_add_history(X) linenoiseHistoryAdd(X)
134 # define shell_read_history(X) linenoiseHistoryLoad(X)
135 # define shell_write_history(X) linenoiseHistorySave(X)
136 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
137 # define shell_readline(X) linenoise(X)
141 # define shell_read_history(X)
142 # define shell_write_history(X)
143 # define shell_stifle_history(X)
145 # define SHELL_USE_LOCAL_GETLINE 1
149 #if defined(_WIN32) || defined(WIN32)
152 # define isatty(h) _isatty(h)
154 # define access(f,m) _access((f),(m))
157 # define unlink _unlink
160 # define strdup _strdup
163 # define popen _popen
165 # define pclose _pclose
167 /* Make sure isatty() has a prototype. */
168 extern int isatty(int);
170 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
171 /* popen and pclose are not C89 functions and so are
172 ** sometimes omitted from the <stdio.h> header */
173 extern FILE *popen(const char*,const char*);
174 extern int pclose(FILE*);
176 # define SQLITE_OMIT_POPEN 1
180 #if defined(_WIN32_WCE)
181 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
182 * thus we always assume that we have a console. That can be
183 * overridden with the -batch command line option.
188 /* ctype macros that work with signed characters */
189 #define IsSpace(X) isspace((unsigned char)X)
190 #define IsDigit(X) isdigit((unsigned char)X)
191 #define ToLower(X) (char)tolower((unsigned char)X)
193 #if defined(_WIN32) || defined(WIN32)
196 /* string conversion routines only needed on Win32 */
197 extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
198 extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int);
199 extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int);
200 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);
203 /* On Windows, we normally run with output mode of TEXT so that \n characters
204 ** are automatically translated into \r\n. However, this behavior needs
205 ** to be disabled in some cases (ex: when generating CSV output and when
206 ** rendering quoted strings that contain \n characters). The following
207 ** routines take care of that.
209 #if defined(_WIN32) || defined(WIN32)
210 static void setBinaryMode(FILE *file, int isOutput){
211 if( isOutput ) fflush(file);
212 _setmode(_fileno(file), _O_BINARY);
214 static void setTextMode(FILE *file, int isOutput){
215 if( isOutput ) fflush(file);
216 _setmode(_fileno(file), _O_TEXT);
219 # define setBinaryMode(X,Y)
220 # define setTextMode(X,Y)
224 /* True if the timer is enabled */
225 static int enableTimer = 0;
227 /* Return the current wall-clock time */
228 static sqlite3_int64 timeOfDay(void){
229 static sqlite3_vfs *clockVfs = 0;
231 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
232 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
233 clockVfs->xCurrentTimeInt64(clockVfs, &t);
236 clockVfs->xCurrentTime(clockVfs, &r);
237 t = (sqlite3_int64)(r*86400000.0);
242 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
243 #include <sys/time.h>
244 #include <sys/resource.h>
246 /* VxWorks does not support getrusage() as far as we can determine */
247 #if defined(_WRS_KERNEL) || defined(__RTP__)
249 struct timeval ru_utime; /* user CPU time used */
250 struct timeval ru_stime; /* system CPU time used */
252 #define getrusage(A,B) memset(B,0,sizeof(*B))
255 /* Saved resource information for the beginning of an operation */
256 static struct rusage sBegin; /* CPU time at start */
257 static sqlite3_int64 iBegin; /* Wall-clock time at start */
260 ** Begin timing an operation
262 static void beginTimer(void){
264 getrusage(RUSAGE_SELF, &sBegin);
265 iBegin = timeOfDay();
269 /* Return the difference of two time_structs in seconds */
270 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
271 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
272 (double)(pEnd->tv_sec - pStart->tv_sec);
276 ** Print the timing results.
278 static void endTimer(void){
280 sqlite3_int64 iEnd = timeOfDay();
282 getrusage(RUSAGE_SELF, &sEnd);
283 printf("Run Time: real %.3f user %f sys %f\n",
284 (iEnd - iBegin)*0.001,
285 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
286 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
290 #define BEGIN_TIMER beginTimer()
291 #define END_TIMER endTimer()
294 #elif (defined(_WIN32) || defined(WIN32))
296 /* Saved resource information for the beginning of an operation */
297 static HANDLE hProcess;
298 static FILETIME ftKernelBegin;
299 static FILETIME ftUserBegin;
300 static sqlite3_int64 ftWallBegin;
301 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
302 LPFILETIME, LPFILETIME);
303 static GETPROCTIMES getProcessTimesAddr = NULL;
306 ** Check to see if we have timer support. Return 1 if necessary
307 ** support found (or found previously).
309 static int hasTimer(void){
310 if( getProcessTimesAddr ){
313 /* GetProcessTimes() isn't supported in WIN95 and some other Windows
314 ** versions. See if the version we are running on has it, and if it
315 ** does, save off a pointer to it and the current process handle.
317 hProcess = GetCurrentProcess();
319 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
320 if( NULL != hinstLib ){
321 getProcessTimesAddr =
322 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
323 if( NULL != getProcessTimesAddr ){
326 FreeLibrary(hinstLib);
334 ** Begin timing an operation
336 static void beginTimer(void){
337 if( enableTimer && getProcessTimesAddr ){
338 FILETIME ftCreation, ftExit;
339 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
340 &ftKernelBegin,&ftUserBegin);
341 ftWallBegin = timeOfDay();
345 /* Return the difference of two FILETIME structs in seconds */
346 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
347 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
348 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
349 return (double) ((i64End - i64Start) / 10000000.0);
353 ** Print the timing results.
355 static void endTimer(void){
356 if( enableTimer && getProcessTimesAddr){
357 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
358 sqlite3_int64 ftWallEnd = timeOfDay();
359 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
360 printf("Run Time: real %.3f user %f sys %f\n",
361 (ftWallEnd - ftWallBegin)*0.001,
362 timeDiff(&ftUserBegin, &ftUserEnd),
363 timeDiff(&ftKernelBegin, &ftKernelEnd));
367 #define BEGIN_TIMER beginTimer()
368 #define END_TIMER endTimer()
369 #define HAS_TIMER hasTimer()
378 ** Used to prevent warnings about unused parameters
380 #define UNUSED_PARAMETER(x) (void)(x)
383 ** Number of elements in an array
385 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
388 ** If the following flag is set, then command execution stops
389 ** at an error if we are not interactive.
391 static int bail_on_error = 0;
394 ** Threat stdin as an interactive input if the following variable
395 ** is true. Otherwise, assume stdin is connected to a file or pipe.
397 static int stdin_is_interactive = 1;
400 ** On Windows systems we have to know if standard output is a console
401 ** in order to translate UTF-8 into MBCS. The following variable is
402 ** true if translation is required.
404 static int stdout_is_console = 1;
407 ** The following is the open SQLite database. We make a pointer
408 ** to this database a static variable so that it can be accessed
409 ** by the SIGINT handler to interrupt database processing.
411 static sqlite3 *globalDb = 0;
414 ** True if an interrupt (Control-C) has been received.
416 static volatile int seenInterrupt = 0;
419 ** This is the name of our program. It is set in main(), used
420 ** in a number of other places, mostly for error messages.
425 ** Prompt strings. Initialized in main. Settable with
426 ** .prompt main continue
428 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
429 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
432 ** Render output like fprintf(). Except, if the output is going to the
433 ** console and if this is running on a Windows machine, translate the
434 ** output from UTF-8 into MBCS.
436 #if defined(_WIN32) || defined(WIN32)
437 void utf8_printf(FILE *out, const char *zFormat, ...){
439 va_start(ap, zFormat);
440 if( stdout_is_console && (out==stdout || out==stderr) ){
441 char *z1 = sqlite3_vmprintf(zFormat, ap);
442 char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0);
447 vfprintf(out, zFormat, ap);
451 #elif !defined(utf8_printf)
452 # define utf8_printf fprintf
456 ** Render output like fprintf(). This should not be used on anything that
457 ** includes string formatting (e.g. "%s").
459 #if !defined(raw_printf)
460 # define raw_printf fprintf
463 /* Indicate out-of-memory and exit. */
464 static void shell_out_of_memory(void){
465 raw_printf(stderr,"Error: out of memory\n");
470 ** Write I/O traces to the following stream.
472 #ifdef SQLITE_ENABLE_IOTRACE
473 static FILE *iotrace = 0;
477 ** This routine works like printf in that its first argument is a
478 ** format string and subsequent arguments are values to be substituted
479 ** in place of % fields. The result of formatting this string
480 ** is written to iotrace.
482 #ifdef SQLITE_ENABLE_IOTRACE
483 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
486 if( iotrace==0 ) return;
487 va_start(ap, zFormat);
488 z = sqlite3_vmprintf(zFormat, ap);
490 utf8_printf(iotrace, "%s", z);
496 ** Output string zUtf to stream pOut as w characters. If w is negative,
497 ** then right-justify the text. W is the width in UTF-8 characters, not
498 ** in bytes. This is different from the %*.*s specification in printf
499 ** since with %*.*s the width is measured in bytes, not characters.
501 static void utf8_width_print(FILE *pOut, int w, const char *zUtf){
504 int aw = w<0 ? -w : w;
506 if( aw>(int)sizeof(zBuf)/3 ) aw = (int)sizeof(zBuf)/3;
507 for(i=n=0; zUtf[i]; i++){
508 if( (zUtf[i]&0xc0)!=0x80 ){
511 do{ i++; }while( (zUtf[i]&0xc0)==0x80 );
517 utf8_printf(pOut, "%.*s", i, zUtf);
519 utf8_printf(pOut, "%*s%s", aw-n, "", zUtf);
521 utf8_printf(pOut, "%s%*s", zUtf, aw-n, "");
527 ** Determines if a string is a number of not.
529 static int isNumber(const char *z, int *realnum){
530 if( *z=='-' || *z=='+' ) z++;
535 if( realnum ) *realnum = 0;
536 while( IsDigit(*z) ){ z++; }
539 if( !IsDigit(*z) ) return 0;
540 while( IsDigit(*z) ){ z++; }
541 if( realnum ) *realnum = 1;
543 if( *z=='e' || *z=='E' ){
545 if( *z=='+' || *z=='-' ) z++;
546 if( !IsDigit(*z) ) return 0;
547 while( IsDigit(*z) ){ z++; }
548 if( realnum ) *realnum = 1;
554 ** Compute a string length that is limited to what can be stored in
555 ** lower 30 bits of a 32-bit signed integer.
557 static int strlen30(const char *z){
559 while( *z2 ){ z2++; }
560 return 0x3fffffff & (int)(z2 - z);
564 ** Return the length of a string in characters. Multibyte UTF8 characters
565 ** count as a single character.
567 static int strlenChar(const char *z){
570 if( (0xc0&*(z++))!=0x80 ) n++;
576 ** This routine reads a line of text from FILE in, stores
577 ** the text in memory obtained from malloc() and returns a pointer
578 ** to the text. NULL is returned at end of file, or if malloc()
581 ** If zLine is not NULL then it is a malloced buffer returned from
582 ** a previous call to this routine that may be reused.
584 static char *local_getline(char *zLine, FILE *in){
585 int nLine = zLine==0 ? 0 : 100;
590 nLine = nLine*2 + 100;
591 zLine = realloc(zLine, nLine);
592 if( zLine==0 ) shell_out_of_memory();
594 if( fgets(&zLine[n], nLine - n, in)==0 ){
602 while( zLine[n] ) n++;
603 if( n>0 && zLine[n-1]=='\n' ){
605 if( n>0 && zLine[n-1]=='\r' ) n--;
610 #if defined(_WIN32) || defined(WIN32)
611 /* For interactive input on Windows systems, translate the
612 ** multi-byte characterset characters into UTF-8. */
613 if( stdin_is_interactive && in==stdin ){
614 char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0);
616 int nTrans = strlen30(zTrans)+1;
618 zLine = realloc(zLine, nTrans);
619 if( zLine==0 ) shell_out_of_memory();
621 memcpy(zLine, zTrans, nTrans);
622 sqlite3_free(zTrans);
625 #endif /* defined(_WIN32) || defined(WIN32) */
630 ** Retrieve a single line of input text.
632 ** If in==0 then read from standard input and prompt before each line.
633 ** If isContinuation is true, then a continuation prompt is appropriate.
634 ** If isContinuation is zero, then the main prompt should be used.
636 ** If zPrior is not NULL then it is a buffer from a prior call to this
637 ** routine that can be reused.
639 ** The result is stored in space obtained from malloc() and must either
640 ** be freed by the caller or else passed back into this routine via the
641 ** zPrior argument for reuse.
643 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
647 zResult = local_getline(zPrior, in);
649 zPrompt = isContinuation ? continuePrompt : mainPrompt;
650 #if SHELL_USE_LOCAL_GETLINE
651 printf("%s", zPrompt);
653 zResult = local_getline(zPrior, stdin);
656 zResult = shell_readline(zPrompt);
657 if( zResult && *zResult ) shell_add_history(zResult);
665 ** Return the value of a hexadecimal digit. Return -1 if the input
666 ** is not a hex digit.
668 static int hexDigitValue(char c){
669 if( c>='0' && c<='9' ) return c - '0';
670 if( c>='a' && c<='f' ) return c - 'a' + 10;
671 if( c>='A' && c<='F' ) return c - 'A' + 10;
676 ** Interpret zArg as an integer value, possibly with suffixes.
678 static sqlite3_int64 integerValue(const char *zArg){
680 static const struct { char *zSuffix; int iMult; } aMult[] = {
682 { "MiB", 1024*1024 },
683 { "GiB", 1024*1024*1024 },
686 { "GB", 1000000000 },
696 }else if( zArg[0]=='+' ){
699 if( zArg[0]=='0' && zArg[1]=='x' ){
702 while( (x = hexDigitValue(zArg[0]))>=0 ){
707 while( IsDigit(zArg[0]) ){
708 v = v*10 + zArg[0] - '0';
712 for(i=0; i<ArraySize(aMult); i++){
713 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
718 return isNeg? -v : v;
722 ** A variable length string to which one can append text.
724 typedef struct ShellText ShellText;
732 ** Initialize and destroy a ShellText object
734 static void initText(ShellText *p){
735 memset(p, 0, sizeof(*p));
737 static void freeText(ShellText *p){
742 /* zIn is either a pointer to a NULL-terminated string in memory obtained
743 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
744 ** added to zIn, and the result returned in memory obtained from malloc().
745 ** zIn, if it was not NULL, is freed.
747 ** If the third argument, quote, is not '\0', then it is used as a
748 ** quote character for zAppend.
750 static void appendText(ShellText *p, char const *zAppend, char quote){
753 int nAppend = strlen30(zAppend);
755 len = nAppend+p->n+1;
758 for(i=0; i<nAppend; i++){
759 if( zAppend[i]==quote ) len++;
763 if( p->n+len>=p->nAlloc ){
764 p->nAlloc = p->nAlloc*2 + len + 20;
765 p->z = realloc(p->z, p->nAlloc);
766 if( p->z==0 ) shell_out_of_memory();
770 char *zCsr = p->z+p->n;
772 for(i=0; i<nAppend; i++){
773 *zCsr++ = zAppend[i];
774 if( zAppend[i]==quote ) *zCsr++ = quote;
777 p->n = (int)(zCsr - p->z);
780 memcpy(p->z+p->n, zAppend, nAppend);
787 ** Attempt to determine if identifier zName needs to be quoted, either
788 ** because it contains non-alphanumeric characters, or because it is an
789 ** SQLite keyword. Be conservative in this estimate: When in doubt assume
790 ** that quoting is required.
792 ** Return '"' if quoting is required. Return 0 if no quoting is required.
794 static char quoteChar(const char *zName){
796 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
797 for(i=0; zName[i]; i++){
798 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
800 return sqlite3_keyword_check(zName, i) ? '"' : 0;
804 ** Construct a fake object name and column list to describe the structure
805 ** of the view, virtual table, or table valued function zSchema.zName.
807 static char *shellFakeSchema(
808 sqlite3 *db, /* The database connection containing the vtab */
809 const char *zSchema, /* Schema of the database holding the vtab */
810 const char *zName /* The name of the virtual table */
812 sqlite3_stmt *pStmt = 0;
819 zSql = sqlite3_mprintf("PRAGMA \"%w\".table_info=%Q;",
820 zSchema ? zSchema : "main", zName);
821 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
825 cQuote = quoteChar(zSchema);
826 if( cQuote && sqlite3_stricmp(zSchema,"temp")==0 ) cQuote = 0;
827 appendText(&s, zSchema, cQuote);
828 appendText(&s, ".", 0);
830 cQuote = quoteChar(zName);
831 appendText(&s, zName, cQuote);
832 while( sqlite3_step(pStmt)==SQLITE_ROW ){
833 const char *zCol = (const char*)sqlite3_column_text(pStmt, 1);
835 appendText(&s, zDiv, 0);
837 cQuote = quoteChar(zCol);
838 appendText(&s, zCol, cQuote);
840 appendText(&s, ")", 0);
841 sqlite3_finalize(pStmt);
850 ** SQL function: shell_module_schema(X)
852 ** Return a fake schema for the table-valued function or eponymous virtual
855 static void shellModuleSchema(
856 sqlite3_context *pCtx,
858 sqlite3_value **apVal
860 const char *zName = (const char*)sqlite3_value_text(apVal[0]);
861 char *zFake = shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName);
862 UNUSED_PARAMETER(nVal);
864 sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake),
871 ** SQL function: shell_add_schema(S,X)
873 ** Add the schema name X to the CREATE statement in S and return the result.
876 ** CREATE TABLE t1(x) -> CREATE TABLE xyz.t1(x);
881 ** CREATE UNIQUE INDEX
884 ** CREATE VIRTUAL TABLE
886 ** This UDF is used by the .schema command to insert the schema name of
887 ** attached databases into the middle of the sqlite_master.sql field.
889 static void shellAddSchemaName(
890 sqlite3_context *pCtx,
892 sqlite3_value **apVal
894 static const char *aPrefix[] = {
903 const char *zIn = (const char*)sqlite3_value_text(apVal[0]);
904 const char *zSchema = (const char*)sqlite3_value_text(apVal[1]);
905 const char *zName = (const char*)sqlite3_value_text(apVal[2]);
906 sqlite3 *db = sqlite3_context_db_handle(pCtx);
907 UNUSED_PARAMETER(nVal);
908 if( zIn!=0 && strncmp(zIn, "CREATE ", 7)==0 ){
909 for(i=0; i<(int)(sizeof(aPrefix)/sizeof(aPrefix[0])); i++){
910 int n = strlen30(aPrefix[i]);
911 if( strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){
915 char cQuote = quoteChar(zSchema);
916 if( cQuote && sqlite3_stricmp(zSchema,"temp")!=0 ){
917 z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8);
919 z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8);
923 && aPrefix[i][0]=='V'
924 && (zFake = shellFakeSchema(db, zSchema, zName))!=0
927 z = sqlite3_mprintf("%s\n/* %s */", zIn, zFake);
929 z = sqlite3_mprintf("%z\n/* %s */", z, zFake);
934 sqlite3_result_text(pCtx, z, -1, sqlite3_free);
940 sqlite3_result_value(pCtx, apVal[0]);
944 ** The source code for several run-time loadable extensions is inserted
945 ** below by the ../tool/mkshellc.tcl script. Before processing that included
946 ** code, we need to override some macros to make the included program code
947 ** work here in the middle of this regular program.
949 #define SQLITE_EXTENSION_INIT1
950 #define SQLITE_EXTENSION_INIT2(X) (void)(X)
952 #if defined(_WIN32) && defined(_MSC_VER)
953 /************************* Begin test_windirent.h ******************/
957 ** The author disclaims copyright to this source code. In place of
958 ** a legal notice, here is a blessing:
960 ** May you do good and not evil.
961 ** May you find forgiveness for yourself and forgive others.
962 ** May you share freely, never taking more than you give.
964 *************************************************************************
965 ** This file contains declarations for most of the opendir() family of
966 ** POSIX functions on Win32 using the MSVCRT.
969 #if defined(_WIN32) && defined(_MSC_VER) && !defined(SQLITE_WINDIRENT_H)
970 #define SQLITE_WINDIRENT_H
973 ** We need several data types from the Windows SDK header.
976 #ifndef WIN32_LEAN_AND_MEAN
977 #define WIN32_LEAN_AND_MEAN
983 ** We need several support functions from the SQLite core.
986 /* #include "sqlite3.h" */
989 ** We need several things from the ANSI and MSVCRT headers.
997 #include <sys/types.h>
998 #include <sys/stat.h>
1001 ** We may need several defines that should have been in "sys/stat.h".
1005 #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
1009 #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
1013 #define S_ISLNK(mode) (0)
1017 ** We may need to provide the "mode_t" type.
1020 #ifndef MODE_T_DEFINED
1021 #define MODE_T_DEFINED
1022 typedef unsigned short mode_t;
1026 ** We may need to provide the "ino_t" type.
1029 #ifndef INO_T_DEFINED
1030 #define INO_T_DEFINED
1031 typedef unsigned short ino_t;
1035 ** We need to define "NAME_MAX" if it was not present in "limits.h".
1039 # ifdef FILENAME_MAX
1040 # define NAME_MAX (FILENAME_MAX)
1042 # define NAME_MAX (260)
1047 ** We need to define "NULL_INTPTR_T" and "BAD_INTPTR_T".
1050 #ifndef NULL_INTPTR_T
1051 # define NULL_INTPTR_T ((intptr_t)(0))
1054 #ifndef BAD_INTPTR_T
1055 # define BAD_INTPTR_T ((intptr_t)(-1))
1059 ** We need to provide the necessary structures and related types.
1062 #ifndef DIRENT_DEFINED
1063 #define DIRENT_DEFINED
1064 typedef struct DIRENT DIRENT;
1065 typedef DIRENT *LPDIRENT;
1067 ino_t d_ino; /* Sequence number, do not use. */
1068 unsigned d_attributes; /* Win32 file attributes. */
1069 char d_name[NAME_MAX + 1]; /* Name within the directory. */
1075 typedef struct DIR DIR;
1078 intptr_t d_handle; /* Value returned by "_findfirst". */
1079 DIRENT d_first; /* DIRENT constructed based on "_findfirst". */
1080 DIRENT d_next; /* DIRENT constructed based on "_findnext". */
1085 ** Provide a macro, for use by the implementation, to determine if a
1086 ** particular directory entry should be skipped over when searching for
1087 ** the next directory entry that should be returned by the readdir() or
1088 ** readdir_r() functions.
1092 # define is_filtered(a) ((((a).attrib)&_A_HIDDEN) || (((a).attrib)&_A_SYSTEM))
1096 ** Provide the function prototype for the POSIX compatiable getenv()
1097 ** function. This function is not thread-safe.
1100 extern const char *windirent_getenv(const char *name);
1103 ** Finally, we can provide the function prototypes for the opendir(),
1104 ** readdir(), readdir_r(), and closedir() POSIX functions.
1107 extern LPDIR opendir(const char *dirname);
1108 extern LPDIRENT readdir(LPDIR dirp);
1109 extern INT readdir_r(LPDIR dirp, LPDIRENT entry, LPDIRENT *result);
1110 extern INT closedir(LPDIR dirp);
1112 #endif /* defined(WIN32) && defined(_MSC_VER) */
1114 /************************* End test_windirent.h ********************/
1115 /************************* Begin test_windirent.c ******************/
1119 ** The author disclaims copyright to this source code. In place of
1120 ** a legal notice, here is a blessing:
1122 ** May you do good and not evil.
1123 ** May you find forgiveness for yourself and forgive others.
1124 ** May you share freely, never taking more than you give.
1126 *************************************************************************
1127 ** This file contains code to implement most of the opendir() family of
1128 ** POSIX functions on Win32 using the MSVCRT.
1131 #if defined(_WIN32) && defined(_MSC_VER)
1132 /* #include "test_windirent.h" */
1135 ** Implementation of the POSIX getenv() function using the Win32 API.
1136 ** This function is not thread-safe.
1138 const char *windirent_getenv(
1141 static char value[32768]; /* Maximum length, per MSDN */
1142 DWORD dwSize = sizeof(value) / sizeof(char); /* Size in chars */
1143 DWORD dwRet; /* Value returned by GetEnvironmentVariableA() */
1145 memset(value, 0, sizeof(value));
1146 dwRet = GetEnvironmentVariableA(name, value, dwSize);
1147 if( dwRet==0 || dwRet>dwSize ){
1149 ** The function call to GetEnvironmentVariableA() failed -OR-
1150 ** the buffer is not large enough. Either way, return NULL.
1155 ** The function call to GetEnvironmentVariableA() succeeded
1156 ** -AND- the buffer contains the entire value.
1163 ** Implementation of the POSIX opendir() function using the MSVCRT.
1168 struct _finddata_t data;
1169 LPDIR dirp = (LPDIR)sqlite3_malloc(sizeof(DIR));
1170 SIZE_T namesize = sizeof(data.name) / sizeof(data.name[0]);
1172 if( dirp==NULL ) return NULL;
1173 memset(dirp, 0, sizeof(DIR));
1175 /* TODO: Remove this if Unix-style root paths are not used. */
1176 if( sqlite3_stricmp(dirname, "/")==0 ){
1177 dirname = windirent_getenv("SystemDrive");
1180 memset(&data, 0, sizeof(struct _finddata_t));
1181 _snprintf(data.name, namesize, "%s\\*", dirname);
1182 dirp->d_handle = _findfirst(data.name, &data);
1184 if( dirp->d_handle==BAD_INTPTR_T ){
1189 /* TODO: Remove this block to allow hidden and/or system files. */
1190 if( is_filtered(data) ){
1193 memset(&data, 0, sizeof(struct _finddata_t));
1194 if( _findnext(dirp->d_handle, &data)==-1 ){
1199 /* TODO: Remove this block to allow hidden and/or system files. */
1200 if( is_filtered(data) ) goto next;
1203 dirp->d_first.d_attributes = data.attrib;
1204 strncpy(dirp->d_first.d_name, data.name, NAME_MAX);
1205 dirp->d_first.d_name[NAME_MAX] = '\0';
1211 ** Implementation of the POSIX readdir() function using the MSVCRT.
1216 struct _finddata_t data;
1218 if( dirp==NULL ) return NULL;
1220 if( dirp->d_first.d_ino==0 ){
1221 dirp->d_first.d_ino++;
1222 dirp->d_next.d_ino++;
1224 return &dirp->d_first;
1229 memset(&data, 0, sizeof(struct _finddata_t));
1230 if( _findnext(dirp->d_handle, &data)==-1 ) return NULL;
1232 /* TODO: Remove this block to allow hidden and/or system files. */
1233 if( is_filtered(data) ) goto next;
1235 dirp->d_next.d_ino++;
1236 dirp->d_next.d_attributes = data.attrib;
1237 strncpy(dirp->d_next.d_name, data.name, NAME_MAX);
1238 dirp->d_next.d_name[NAME_MAX] = '\0';
1240 return &dirp->d_next;
1244 ** Implementation of the POSIX readdir_r() function using the MSVCRT.
1251 struct _finddata_t data;
1253 if( dirp==NULL ) return EBADF;
1255 if( dirp->d_first.d_ino==0 ){
1256 dirp->d_first.d_ino++;
1257 dirp->d_next.d_ino++;
1259 entry->d_ino = dirp->d_first.d_ino;
1260 entry->d_attributes = dirp->d_first.d_attributes;
1261 strncpy(entry->d_name, dirp->d_first.d_name, NAME_MAX);
1262 entry->d_name[NAME_MAX] = '\0';
1270 memset(&data, 0, sizeof(struct _finddata_t));
1271 if( _findnext(dirp->d_handle, &data)==-1 ){
1276 /* TODO: Remove this block to allow hidden and/or system files. */
1277 if( is_filtered(data) ) goto next;
1279 entry->d_ino = (ino_t)-1; /* not available */
1280 entry->d_attributes = data.attrib;
1281 strncpy(entry->d_name, data.name, NAME_MAX);
1282 entry->d_name[NAME_MAX] = '\0';
1289 ** Implementation of the POSIX closedir() function using the MSVCRT.
1296 if( dirp==NULL ) return EINVAL;
1298 if( dirp->d_handle!=NULL_INTPTR_T && dirp->d_handle!=BAD_INTPTR_T ){
1299 result = _findclose(dirp->d_handle);
1306 #endif /* defined(WIN32) && defined(_MSC_VER) */
1308 /************************* End test_windirent.c ********************/
1309 #define dirent DIRENT
1311 /************************* Begin ../ext/misc/shathree.c ******************/
1315 ** The author disclaims copyright to this source code. In place of
1316 ** a legal notice, here is a blessing:
1318 ** May you do good and not evil.
1319 ** May you find forgiveness for yourself and forgive others.
1320 ** May you share freely, never taking more than you give.
1322 ******************************************************************************
1324 ** This SQLite extension implements functions that compute SHA3 hashes.
1325 ** Two SQL functions are implemented:
1328 ** sha3_query(Y,SIZE)
1330 ** The sha3(X) function computes the SHA3 hash of the input X, or NULL if
1333 ** The sha3_query(Y) function evalutes all queries in the SQL statements of Y
1334 ** and returns a hash of their results.
1336 ** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm
1337 ** is used. If SIZE is included it must be one of the integers 224, 256,
1338 ** 384, or 512, to determine SHA3 hash variant that is computed.
1340 /* #include "sqlite3ext.h" */
1341 SQLITE_EXTENSION_INIT1
1345 /* typedef sqlite3_uint64 u64; */
1347 /******************************************************************************
1351 ** Macros to determine whether the machine is big or little endian,
1352 ** and whether or not that determination is run-time or compile-time.
1354 ** For best performance, an attempt is made to guess at the byte-order
1355 ** using C-preprocessor macros. If that is unsuccessful, or if
1356 ** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
1359 #ifndef SHA3_BYTEORDER
1360 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
1361 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
1362 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
1364 # define SHA3_BYTEORDER 1234
1365 # elif defined(sparc) || defined(__ppc__)
1366 # define SHA3_BYTEORDER 4321
1368 # define SHA3_BYTEORDER 0
1374 ** State structure for a SHA3 hash in progress
1376 typedef struct SHA3Context SHA3Context;
1377 struct SHA3Context {
1379 u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
1380 unsigned char x[1600]; /* ... or 1600 bytes */
1382 unsigned nRate; /* Bytes of input accepted per Keccak iteration */
1383 unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
1384 unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
1388 ** A single step of the Keccak mixing function for a 1600-bit state
1390 static void KeccakF1600Step(SHA3Context *p){
1392 u64 b0, b1, b2, b3, b4;
1393 u64 c0, c1, c2, c3, c4;
1394 u64 d0, d1, d2, d3, d4;
1395 static const u64 RC[] = {
1396 0x0000000000000001ULL, 0x0000000000008082ULL,
1397 0x800000000000808aULL, 0x8000000080008000ULL,
1398 0x000000000000808bULL, 0x0000000080000001ULL,
1399 0x8000000080008081ULL, 0x8000000000008009ULL,
1400 0x000000000000008aULL, 0x0000000000000088ULL,
1401 0x0000000080008009ULL, 0x000000008000000aULL,
1402 0x000000008000808bULL, 0x800000000000008bULL,
1403 0x8000000000008089ULL, 0x8000000000008003ULL,
1404 0x8000000000008002ULL, 0x8000000000000080ULL,
1405 0x000000000000800aULL, 0x800000008000000aULL,
1406 0x8000000080008081ULL, 0x8000000000008080ULL,
1407 0x0000000080000001ULL, 0x8000000080008008ULL
1409 # define a00 (p->u.s[0])
1410 # define a01 (p->u.s[1])
1411 # define a02 (p->u.s[2])
1412 # define a03 (p->u.s[3])
1413 # define a04 (p->u.s[4])
1414 # define a10 (p->u.s[5])
1415 # define a11 (p->u.s[6])
1416 # define a12 (p->u.s[7])
1417 # define a13 (p->u.s[8])
1418 # define a14 (p->u.s[9])
1419 # define a20 (p->u.s[10])
1420 # define a21 (p->u.s[11])
1421 # define a22 (p->u.s[12])
1422 # define a23 (p->u.s[13])
1423 # define a24 (p->u.s[14])
1424 # define a30 (p->u.s[15])
1425 # define a31 (p->u.s[16])
1426 # define a32 (p->u.s[17])
1427 # define a33 (p->u.s[18])
1428 # define a34 (p->u.s[19])
1429 # define a40 (p->u.s[20])
1430 # define a41 (p->u.s[21])
1431 # define a42 (p->u.s[22])
1432 # define a43 (p->u.s[23])
1433 # define a44 (p->u.s[24])
1434 # define ROL64(a,x) ((a<<x)|(a>>(64-x)))
1436 for(i=0; i<24; i+=4){
1437 c0 = a00^a10^a20^a30^a40;
1438 c1 = a01^a11^a21^a31^a41;
1439 c2 = a02^a12^a22^a32^a42;
1440 c3 = a03^a13^a23^a33^a43;
1441 c4 = a04^a14^a24^a34^a44;
1442 d0 = c4^ROL64(c1, 1);
1443 d1 = c0^ROL64(c2, 1);
1444 d2 = c1^ROL64(c3, 1);
1445 d3 = c2^ROL64(c4, 1);
1446 d4 = c3^ROL64(c0, 1);
1449 b1 = ROL64((a11^d1), 44);
1450 b2 = ROL64((a22^d2), 43);
1451 b3 = ROL64((a33^d3), 21);
1452 b4 = ROL64((a44^d4), 14);
1453 a00 = b0 ^((~b1)& b2 );
1455 a11 = b1 ^((~b2)& b3 );
1456 a22 = b2 ^((~b3)& b4 );
1457 a33 = b3 ^((~b4)& b0 );
1458 a44 = b4 ^((~b0)& b1 );
1460 b2 = ROL64((a20^d0), 3);
1461 b3 = ROL64((a31^d1), 45);
1462 b4 = ROL64((a42^d2), 61);
1463 b0 = ROL64((a03^d3), 28);
1464 b1 = ROL64((a14^d4), 20);
1465 a20 = b0 ^((~b1)& b2 );
1466 a31 = b1 ^((~b2)& b3 );
1467 a42 = b2 ^((~b3)& b4 );
1468 a03 = b3 ^((~b4)& b0 );
1469 a14 = b4 ^((~b0)& b1 );
1471 b4 = ROL64((a40^d0), 18);
1472 b0 = ROL64((a01^d1), 1);
1473 b1 = ROL64((a12^d2), 6);
1474 b2 = ROL64((a23^d3), 25);
1475 b3 = ROL64((a34^d4), 8);
1476 a40 = b0 ^((~b1)& b2 );
1477 a01 = b1 ^((~b2)& b3 );
1478 a12 = b2 ^((~b3)& b4 );
1479 a23 = b3 ^((~b4)& b0 );
1480 a34 = b4 ^((~b0)& b1 );
1482 b1 = ROL64((a10^d0), 36);
1483 b2 = ROL64((a21^d1), 10);
1484 b3 = ROL64((a32^d2), 15);
1485 b4 = ROL64((a43^d3), 56);
1486 b0 = ROL64((a04^d4), 27);
1487 a10 = b0 ^((~b1)& b2 );
1488 a21 = b1 ^((~b2)& b3 );
1489 a32 = b2 ^((~b3)& b4 );
1490 a43 = b3 ^((~b4)& b0 );
1491 a04 = b4 ^((~b0)& b1 );
1493 b3 = ROL64((a30^d0), 41);
1494 b4 = ROL64((a41^d1), 2);
1495 b0 = ROL64((a02^d2), 62);
1496 b1 = ROL64((a13^d3), 55);
1497 b2 = ROL64((a24^d4), 39);
1498 a30 = b0 ^((~b1)& b2 );
1499 a41 = b1 ^((~b2)& b3 );
1500 a02 = b2 ^((~b3)& b4 );
1501 a13 = b3 ^((~b4)& b0 );
1502 a24 = b4 ^((~b0)& b1 );
1504 c0 = a00^a20^a40^a10^a30;
1505 c1 = a11^a31^a01^a21^a41;
1506 c2 = a22^a42^a12^a32^a02;
1507 c3 = a33^a03^a23^a43^a13;
1508 c4 = a44^a14^a34^a04^a24;
1509 d0 = c4^ROL64(c1, 1);
1510 d1 = c0^ROL64(c2, 1);
1511 d2 = c1^ROL64(c3, 1);
1512 d3 = c2^ROL64(c4, 1);
1513 d4 = c3^ROL64(c0, 1);
1516 b1 = ROL64((a31^d1), 44);
1517 b2 = ROL64((a12^d2), 43);
1518 b3 = ROL64((a43^d3), 21);
1519 b4 = ROL64((a24^d4), 14);
1520 a00 = b0 ^((~b1)& b2 );
1522 a31 = b1 ^((~b2)& b3 );
1523 a12 = b2 ^((~b3)& b4 );
1524 a43 = b3 ^((~b4)& b0 );
1525 a24 = b4 ^((~b0)& b1 );
1527 b2 = ROL64((a40^d0), 3);
1528 b3 = ROL64((a21^d1), 45);
1529 b4 = ROL64((a02^d2), 61);
1530 b0 = ROL64((a33^d3), 28);
1531 b1 = ROL64((a14^d4), 20);
1532 a40 = b0 ^((~b1)& b2 );
1533 a21 = b1 ^((~b2)& b3 );
1534 a02 = b2 ^((~b3)& b4 );
1535 a33 = b3 ^((~b4)& b0 );
1536 a14 = b4 ^((~b0)& b1 );
1538 b4 = ROL64((a30^d0), 18);
1539 b0 = ROL64((a11^d1), 1);
1540 b1 = ROL64((a42^d2), 6);
1541 b2 = ROL64((a23^d3), 25);
1542 b3 = ROL64((a04^d4), 8);
1543 a30 = b0 ^((~b1)& b2 );
1544 a11 = b1 ^((~b2)& b3 );
1545 a42 = b2 ^((~b3)& b4 );
1546 a23 = b3 ^((~b4)& b0 );
1547 a04 = b4 ^((~b0)& b1 );
1549 b1 = ROL64((a20^d0), 36);
1550 b2 = ROL64((a01^d1), 10);
1551 b3 = ROL64((a32^d2), 15);
1552 b4 = ROL64((a13^d3), 56);
1553 b0 = ROL64((a44^d4), 27);
1554 a20 = b0 ^((~b1)& b2 );
1555 a01 = b1 ^((~b2)& b3 );
1556 a32 = b2 ^((~b3)& b4 );
1557 a13 = b3 ^((~b4)& b0 );
1558 a44 = b4 ^((~b0)& b1 );
1560 b3 = ROL64((a10^d0), 41);
1561 b4 = ROL64((a41^d1), 2);
1562 b0 = ROL64((a22^d2), 62);
1563 b1 = ROL64((a03^d3), 55);
1564 b2 = ROL64((a34^d4), 39);
1565 a10 = b0 ^((~b1)& b2 );
1566 a41 = b1 ^((~b2)& b3 );
1567 a22 = b2 ^((~b3)& b4 );
1568 a03 = b3 ^((~b4)& b0 );
1569 a34 = b4 ^((~b0)& b1 );
1571 c0 = a00^a40^a30^a20^a10;
1572 c1 = a31^a21^a11^a01^a41;
1573 c2 = a12^a02^a42^a32^a22;
1574 c3 = a43^a33^a23^a13^a03;
1575 c4 = a24^a14^a04^a44^a34;
1576 d0 = c4^ROL64(c1, 1);
1577 d1 = c0^ROL64(c2, 1);
1578 d2 = c1^ROL64(c3, 1);
1579 d3 = c2^ROL64(c4, 1);
1580 d4 = c3^ROL64(c0, 1);
1583 b1 = ROL64((a21^d1), 44);
1584 b2 = ROL64((a42^d2), 43);
1585 b3 = ROL64((a13^d3), 21);
1586 b4 = ROL64((a34^d4), 14);
1587 a00 = b0 ^((~b1)& b2 );
1589 a21 = b1 ^((~b2)& b3 );
1590 a42 = b2 ^((~b3)& b4 );
1591 a13 = b3 ^((~b4)& b0 );
1592 a34 = b4 ^((~b0)& b1 );
1594 b2 = ROL64((a30^d0), 3);
1595 b3 = ROL64((a01^d1), 45);
1596 b4 = ROL64((a22^d2), 61);
1597 b0 = ROL64((a43^d3), 28);
1598 b1 = ROL64((a14^d4), 20);
1599 a30 = b0 ^((~b1)& b2 );
1600 a01 = b1 ^((~b2)& b3 );
1601 a22 = b2 ^((~b3)& b4 );
1602 a43 = b3 ^((~b4)& b0 );
1603 a14 = b4 ^((~b0)& b1 );
1605 b4 = ROL64((a10^d0), 18);
1606 b0 = ROL64((a31^d1), 1);
1607 b1 = ROL64((a02^d2), 6);
1608 b2 = ROL64((a23^d3), 25);
1609 b3 = ROL64((a44^d4), 8);
1610 a10 = b0 ^((~b1)& b2 );
1611 a31 = b1 ^((~b2)& b3 );
1612 a02 = b2 ^((~b3)& b4 );
1613 a23 = b3 ^((~b4)& b0 );
1614 a44 = b4 ^((~b0)& b1 );
1616 b1 = ROL64((a40^d0), 36);
1617 b2 = ROL64((a11^d1), 10);
1618 b3 = ROL64((a32^d2), 15);
1619 b4 = ROL64((a03^d3), 56);
1620 b0 = ROL64((a24^d4), 27);
1621 a40 = b0 ^((~b1)& b2 );
1622 a11 = b1 ^((~b2)& b3 );
1623 a32 = b2 ^((~b3)& b4 );
1624 a03 = b3 ^((~b4)& b0 );
1625 a24 = b4 ^((~b0)& b1 );
1627 b3 = ROL64((a20^d0), 41);
1628 b4 = ROL64((a41^d1), 2);
1629 b0 = ROL64((a12^d2), 62);
1630 b1 = ROL64((a33^d3), 55);
1631 b2 = ROL64((a04^d4), 39);
1632 a20 = b0 ^((~b1)& b2 );
1633 a41 = b1 ^((~b2)& b3 );
1634 a12 = b2 ^((~b3)& b4 );
1635 a33 = b3 ^((~b4)& b0 );
1636 a04 = b4 ^((~b0)& b1 );
1638 c0 = a00^a30^a10^a40^a20;
1639 c1 = a21^a01^a31^a11^a41;
1640 c2 = a42^a22^a02^a32^a12;
1641 c3 = a13^a43^a23^a03^a33;
1642 c4 = a34^a14^a44^a24^a04;
1643 d0 = c4^ROL64(c1, 1);
1644 d1 = c0^ROL64(c2, 1);
1645 d2 = c1^ROL64(c3, 1);
1646 d3 = c2^ROL64(c4, 1);
1647 d4 = c3^ROL64(c0, 1);
1650 b1 = ROL64((a01^d1), 44);
1651 b2 = ROL64((a02^d2), 43);
1652 b3 = ROL64((a03^d3), 21);
1653 b4 = ROL64((a04^d4), 14);
1654 a00 = b0 ^((~b1)& b2 );
1656 a01 = b1 ^((~b2)& b3 );
1657 a02 = b2 ^((~b3)& b4 );
1658 a03 = b3 ^((~b4)& b0 );
1659 a04 = b4 ^((~b0)& b1 );
1661 b2 = ROL64((a10^d0), 3);
1662 b3 = ROL64((a11^d1), 45);
1663 b4 = ROL64((a12^d2), 61);
1664 b0 = ROL64((a13^d3), 28);
1665 b1 = ROL64((a14^d4), 20);
1666 a10 = b0 ^((~b1)& b2 );
1667 a11 = b1 ^((~b2)& b3 );
1668 a12 = b2 ^((~b3)& b4 );
1669 a13 = b3 ^((~b4)& b0 );
1670 a14 = b4 ^((~b0)& b1 );
1672 b4 = ROL64((a20^d0), 18);
1673 b0 = ROL64((a21^d1), 1);
1674 b1 = ROL64((a22^d2), 6);
1675 b2 = ROL64((a23^d3), 25);
1676 b3 = ROL64((a24^d4), 8);
1677 a20 = b0 ^((~b1)& b2 );
1678 a21 = b1 ^((~b2)& b3 );
1679 a22 = b2 ^((~b3)& b4 );
1680 a23 = b3 ^((~b4)& b0 );
1681 a24 = b4 ^((~b0)& b1 );
1683 b1 = ROL64((a30^d0), 36);
1684 b2 = ROL64((a31^d1), 10);
1685 b3 = ROL64((a32^d2), 15);
1686 b4 = ROL64((a33^d3), 56);
1687 b0 = ROL64((a34^d4), 27);
1688 a30 = b0 ^((~b1)& b2 );
1689 a31 = b1 ^((~b2)& b3 );
1690 a32 = b2 ^((~b3)& b4 );
1691 a33 = b3 ^((~b4)& b0 );
1692 a34 = b4 ^((~b0)& b1 );
1694 b3 = ROL64((a40^d0), 41);
1695 b4 = ROL64((a41^d1), 2);
1696 b0 = ROL64((a42^d2), 62);
1697 b1 = ROL64((a43^d3), 55);
1698 b2 = ROL64((a44^d4), 39);
1699 a40 = b0 ^((~b1)& b2 );
1700 a41 = b1 ^((~b2)& b3 );
1701 a42 = b2 ^((~b3)& b4 );
1702 a43 = b3 ^((~b4)& b0 );
1703 a44 = b4 ^((~b0)& b1 );
1708 ** Initialize a new hash. iSize determines the size of the hash
1709 ** in bits and should be one of 224, 256, 384, or 512. Or iSize
1710 ** can be zero to use the default hash size of 256 bits.
1712 static void SHA3Init(SHA3Context *p, int iSize){
1713 memset(p, 0, sizeof(*p));
1714 if( iSize>=128 && iSize<=512 ){
1715 p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1717 p->nRate = (1600 - 2*256)/8;
1719 #if SHA3_BYTEORDER==1234
1720 /* Known to be little-endian at compile-time. No-op */
1721 #elif SHA3_BYTEORDER==4321
1722 p->ixMask = 7; /* Big-endian */
1725 static unsigned int one = 1;
1726 if( 1==*(unsigned char*)&one ){
1727 /* Little endian. No byte swapping. */
1730 /* Big endian. Byte swap. */
1738 ** Make consecutive calls to the SHA3Update function to add new content
1741 static void SHA3Update(
1743 const unsigned char *aData,
1747 #if SHA3_BYTEORDER==1234
1748 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1749 for(; i+7<nData; i+=8){
1750 p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
1752 if( p->nLoaded>=p->nRate ){
1759 for(; i<nData; i++){
1760 #if SHA3_BYTEORDER==1234
1761 p->u.x[p->nLoaded] ^= aData[i];
1762 #elif SHA3_BYTEORDER==4321
1763 p->u.x[p->nLoaded^0x07] ^= aData[i];
1765 p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1768 if( p->nLoaded==p->nRate ){
1776 ** After all content has been added, invoke SHA3Final() to compute
1777 ** the final hash. The function returns a pointer to the binary
1780 static unsigned char *SHA3Final(SHA3Context *p){
1782 if( p->nLoaded==p->nRate-1 ){
1783 const unsigned char c1 = 0x86;
1784 SHA3Update(p, &c1, 1);
1786 const unsigned char c2 = 0x06;
1787 const unsigned char c3 = 0x80;
1788 SHA3Update(p, &c2, 1);
1789 p->nLoaded = p->nRate - 1;
1790 SHA3Update(p, &c3, 1);
1792 for(i=0; i<p->nRate; i++){
1793 p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1795 return &p->u.x[p->nRate];
1797 /* End of the hashing logic
1798 *****************************************************************************/
1801 ** Implementation of the sha3(X,SIZE) function.
1803 ** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1804 ** size is 256. If X is a BLOB, it is hashed as is.
1805 ** For all other non-NULL types of input, X is converted into a UTF-8 string
1806 ** and the string is hashed without the trailing 0x00 terminator. The hash
1807 ** of a NULL value is NULL.
1809 static void sha3Func(
1810 sqlite3_context *context,
1812 sqlite3_value **argv
1815 int eType = sqlite3_value_type(argv[0]);
1816 int nByte = sqlite3_value_bytes(argv[0]);
1821 iSize = sqlite3_value_int(argv[1]);
1822 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1823 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1828 if( eType==SQLITE_NULL ) return;
1829 SHA3Init(&cx, iSize);
1830 if( eType==SQLITE_BLOB ){
1831 SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1833 SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1835 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1838 /* Compute a string using sqlite3_vsnprintf() with a maximum length
1839 ** of 50 bytes and add it to the hash.
1841 static void hash_step_vformat(
1842 SHA3Context *p, /* Add content to this context */
1843 const char *zFormat,
1849 va_start(ap, zFormat);
1850 sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1852 n = (int)strlen(zBuf);
1853 SHA3Update(p, (unsigned char*)zBuf, n);
1857 ** Implementation of the sha3_query(SQL,SIZE) function.
1859 ** This function compiles and runs the SQL statement(s) given in the
1860 ** argument. The results are hashed using a SIZE-bit SHA3. The default
1863 ** The format of the byte stream that is hashed is summarized as follows:
1873 ** <sql> is the original SQL text for each statement run and <n> is
1874 ** the size of that text. The SQL text is UTF-8. A single R character
1875 ** occurs before the start of each row. N means a NULL value.
1876 ** I mean an 8-byte little-endian integer <int>. F is a floating point
1877 ** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1878 ** B means blobs of <size> bytes. T means text rendered as <size>
1879 ** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1882 ** For each SQL statement in the X input, there is one S segment. Each
1883 ** S segment is followed by zero or more R segments, one for each row in the
1884 ** result set. After each R, there are one or more N, I, F, B, or T segments,
1885 ** one for each column in the result set. Segments are concatentated directly
1886 ** with no delimiters of any kind.
1888 static void sha3QueryFunc(
1889 sqlite3_context *context,
1891 sqlite3_value **argv
1893 sqlite3 *db = sqlite3_context_db_handle(context);
1894 const char *zSql = (const char*)sqlite3_value_text(argv[0]);
1895 sqlite3_stmt *pStmt = 0;
1896 int nCol; /* Number of columns in the result set */
1897 int i; /* Loop counter */
1907 iSize = sqlite3_value_int(argv[1]);
1908 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1909 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1914 if( zSql==0 ) return;
1915 SHA3Init(&cx, iSize);
1917 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1919 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1920 zSql, sqlite3_errmsg(db));
1921 sqlite3_finalize(pStmt);
1922 sqlite3_result_error(context, zMsg, -1);
1926 if( !sqlite3_stmt_readonly(pStmt) ){
1927 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1928 sqlite3_finalize(pStmt);
1929 sqlite3_result_error(context, zMsg, -1);
1933 nCol = sqlite3_column_count(pStmt);
1934 z = sqlite3_sql(pStmt);
1936 hash_step_vformat(&cx,"S%d:",n);
1937 SHA3Update(&cx,(unsigned char*)z,n);
1939 /* Compute a hash over the result of the query */
1940 while( SQLITE_ROW==sqlite3_step(pStmt) ){
1941 SHA3Update(&cx,(const unsigned char*)"R",1);
1942 for(i=0; i<nCol; i++){
1943 switch( sqlite3_column_type(pStmt,i) ){
1945 SHA3Update(&cx, (const unsigned char*)"N",1);
1948 case SQLITE_INTEGER: {
1952 sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1954 for(j=8; j>=1; j--){
1959 SHA3Update(&cx, x, 9);
1962 case SQLITE_FLOAT: {
1966 double r = sqlite3_column_double(pStmt,i);
1968 for(j=8; j>=1; j--){
1973 SHA3Update(&cx,x,9);
1977 int n2 = sqlite3_column_bytes(pStmt, i);
1978 const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1979 hash_step_vformat(&cx,"T%d:",n2);
1980 SHA3Update(&cx, z2, n2);
1984 int n2 = sqlite3_column_bytes(pStmt, i);
1985 const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1986 hash_step_vformat(&cx,"B%d:",n2);
1987 SHA3Update(&cx, z2, n2);
1993 sqlite3_finalize(pStmt);
1995 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
2002 int sqlite3_shathree_init(
2005 const sqlite3_api_routines *pApi
2008 SQLITE_EXTENSION_INIT2(pApi);
2009 (void)pzErrMsg; /* Unused parameter */
2010 rc = sqlite3_create_function(db, "sha3", 1, SQLITE_UTF8, 0,
2012 if( rc==SQLITE_OK ){
2013 rc = sqlite3_create_function(db, "sha3", 2, SQLITE_UTF8, 0,
2016 if( rc==SQLITE_OK ){
2017 rc = sqlite3_create_function(db, "sha3_query", 1, SQLITE_UTF8, 0,
2018 sha3QueryFunc, 0, 0);
2020 if( rc==SQLITE_OK ){
2021 rc = sqlite3_create_function(db, "sha3_query", 2, SQLITE_UTF8, 0,
2022 sha3QueryFunc, 0, 0);
2027 /************************* End ../ext/misc/shathree.c ********************/
2028 /************************* Begin ../ext/misc/fileio.c ******************/
2032 ** The author disclaims copyright to this source code. In place of
2033 ** a legal notice, here is a blessing:
2035 ** May you do good and not evil.
2036 ** May you find forgiveness for yourself and forgive others.
2037 ** May you share freely, never taking more than you give.
2039 ******************************************************************************
2041 ** This SQLite extension implements SQL functions readfile() and
2042 ** writefile(), and eponymous virtual type "fsdir".
2044 ** WRITEFILE(FILE, DATA [, MODE [, MTIME]]):
2046 ** If neither of the optional arguments is present, then this UDF
2047 ** function writes blob DATA to file FILE. If successful, the number
2048 ** of bytes written is returned. If an error occurs, NULL is returned.
2050 ** If the first option argument - MODE - is present, then it must
2051 ** be passed an integer value that corresponds to a POSIX mode
2052 ** value (file type + permissions, as returned in the stat.st_mode
2053 ** field by the stat() system call). Three types of files may
2054 ** be written/created:
2056 ** regular files: (mode & 0170000)==0100000
2057 ** symbolic links: (mode & 0170000)==0120000
2058 ** directories: (mode & 0170000)==0040000
2060 ** For a directory, the DATA is ignored. For a symbolic link, it is
2061 ** interpreted as text and used as the target of the link. For a
2062 ** regular file, it is interpreted as a blob and written into the
2063 ** named file. Regardless of the type of file, its permissions are
2064 ** set to (mode & 0777) before returning.
2066 ** If the optional MTIME argument is present, then it is interpreted
2067 ** as an integer - the number of seconds since the unix epoch. The
2068 ** modification-time of the target file is set to this value before
2071 ** If three or more arguments are passed to this function and an
2072 ** error is encountered, an exception is raised.
2076 ** Read and return the contents of file FILE (type blob) from disk.
2082 ** SELECT * FROM fsdir($path [, $dir]);
2084 ** Parameter $path is an absolute or relative pathname. If the file that it
2085 ** refers to does not exist, it is an error. If the path refers to a regular
2086 ** file or symbolic link, it returns a single row. Or, if the path refers
2087 ** to a directory, it returns one row for the directory, and one row for each
2088 ** file within the hierarchy rooted at $path.
2090 ** Each row has the following columns:
2092 ** name: Path to file or directory (text value).
2093 ** mode: Value of stat.st_mode for directory entry (an integer).
2094 ** mtime: Value of stat.st_mtime for directory entry (an integer).
2095 ** data: For a regular file, a blob containing the file data. For a
2096 ** symlink, a text value containing the text of the link. For a
2099 ** If a non-NULL value is specified for the optional $dir parameter and
2100 ** $path is a relative path, then $path is interpreted relative to $dir.
2101 ** And the paths returned in the "name" column of the table are also
2102 ** relative to directory $dir.
2104 /* #include "sqlite3ext.h" */
2105 SQLITE_EXTENSION_INIT1
2110 #include <sys/types.h>
2111 #include <sys/stat.h>
2113 #if !defined(_WIN32) && !defined(WIN32)
2114 # include <unistd.h>
2115 # include <dirent.h>
2117 # include <sys/time.h>
2119 # include "windows.h"
2121 # include <direct.h>
2122 /* # include "test_windirent.h" */
2123 # define dirent DIRENT
2125 # define chmod _chmod
2130 # define mkdir(path,mode) _mkdir(path)
2131 # define lstat(path,buf) stat(path,buf)
2138 ** Structure of the fsdir() table-valued function
2141 #define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"
2142 #define FSDIR_COLUMN_NAME 0 /* Name of the file */
2143 #define FSDIR_COLUMN_MODE 1 /* Access mode */
2144 #define FSDIR_COLUMN_MTIME 2 /* Last modification time */
2145 #define FSDIR_COLUMN_DATA 3 /* File content */
2146 #define FSDIR_COLUMN_PATH 4 /* Path to top of search */
2147 #define FSDIR_COLUMN_DIR 5 /* Path is relative to this directory */
2151 ** Set the result stored by context ctx to a blob containing the
2152 ** contents of file zName. Or, leave the result unchanged (NULL)
2153 ** if the file does not exist or is unreadable.
2155 ** If the file exceeds the SQLite blob size limit, through an
2156 ** SQLITE_TOOBIG error.
2158 ** Throw an SQLITE_IOERR if there are difficulties pulling the file
2161 static void readFileContents(sqlite3_context *ctx, const char *zName){
2168 in = fopen(zName, "rb");
2170 /* File does not exist or is unreadable. Leave the result set to NULL. */
2173 fseek(in, 0, SEEK_END);
2176 db = sqlite3_context_db_handle(ctx);
2177 mxBlob = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1);
2179 sqlite3_result_error_code(ctx, SQLITE_TOOBIG);
2183 pBuf = sqlite3_malloc64( nIn ? nIn : 1 );
2185 sqlite3_result_error_nomem(ctx);
2189 if( nIn==(sqlite3_int64)fread(pBuf, 1, (size_t)nIn, in) ){
2190 sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free);
2192 sqlite3_result_error_code(ctx, SQLITE_IOERR);
2199 ** Implementation of the "readfile(X)" SQL function. The entire content
2200 ** of the file named X is read and returned as a BLOB. NULL is returned
2201 ** if the file does not exist or is unreadable.
2203 static void readfileFunc(
2204 sqlite3_context *context,
2206 sqlite3_value **argv
2209 (void)(argc); /* Unused parameter */
2210 zName = (const char*)sqlite3_value_text(argv[0]);
2211 if( zName==0 ) return;
2212 readFileContents(context, zName);
2216 ** Set the error message contained in context ctx to the results of
2217 ** vprintf(zFmt, ...).
2219 static void ctxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){
2223 zMsg = sqlite3_vmprintf(zFmt, ap);
2224 sqlite3_result_error(ctx, zMsg, -1);
2231 ** This function is designed to convert a Win32 FILETIME structure into the
2232 ** number of seconds since the Unix Epoch (1970-01-01 00:00:00 UTC).
2234 static sqlite3_uint64 fileTimeToUnixTime(
2235 LPFILETIME pFileTime
2237 SYSTEMTIME epochSystemTime;
2238 ULARGE_INTEGER epochIntervals;
2239 FILETIME epochFileTime;
2240 ULARGE_INTEGER fileIntervals;
2242 memset(&epochSystemTime, 0, sizeof(SYSTEMTIME));
2243 epochSystemTime.wYear = 1970;
2244 epochSystemTime.wMonth = 1;
2245 epochSystemTime.wDay = 1;
2246 SystemTimeToFileTime(&epochSystemTime, &epochFileTime);
2247 epochIntervals.LowPart = epochFileTime.dwLowDateTime;
2248 epochIntervals.HighPart = epochFileTime.dwHighDateTime;
2250 fileIntervals.LowPart = pFileTime->dwLowDateTime;
2251 fileIntervals.HighPart = pFileTime->dwHighDateTime;
2253 return (fileIntervals.QuadPart - epochIntervals.QuadPart) / 10000000;
2257 ** This function attempts to normalize the time values found in the stat()
2258 ** buffer to UTC. This is necessary on Win32, where the runtime library
2259 ** appears to return these values as local times.
2261 static void statTimesToUtc(
2263 struct stat *pStatBuf
2266 WIN32_FIND_DATAW fd;
2267 LPWSTR zUnicodeName;
2268 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
2269 zUnicodeName = sqlite3_win32_utf8_to_unicode(zPath);
2271 memset(&fd, 0, sizeof(WIN32_FIND_DATAW));
2272 hFindFile = FindFirstFileW(zUnicodeName, &fd);
2273 if( hFindFile!=NULL ){
2274 pStatBuf->st_ctime = (time_t)fileTimeToUnixTime(&fd.ftCreationTime);
2275 pStatBuf->st_atime = (time_t)fileTimeToUnixTime(&fd.ftLastAccessTime);
2276 pStatBuf->st_mtime = (time_t)fileTimeToUnixTime(&fd.ftLastWriteTime);
2277 FindClose(hFindFile);
2279 sqlite3_free(zUnicodeName);
2285 ** This function is used in place of stat(). On Windows, special handling
2286 ** is required in order for the included time to be returned as UTC. On all
2287 ** other systems, this function simply calls stat().
2289 static int fileStat(
2291 struct stat *pStatBuf
2294 int rc = stat(zPath, pStatBuf);
2295 if( rc==0 ) statTimesToUtc(zPath, pStatBuf);
2298 return stat(zPath, pStatBuf);
2303 ** This function is used in place of lstat(). On Windows, special handling
2304 ** is required in order for the included time to be returned as UTC. On all
2305 ** other systems, this function simply calls lstat().
2307 static int fileLinkStat(
2309 struct stat *pStatBuf
2312 int rc = lstat(zPath, pStatBuf);
2313 if( rc==0 ) statTimesToUtc(zPath, pStatBuf);
2316 return lstat(zPath, pStatBuf);
2321 ** Argument zFile is the name of a file that will be created and/or written
2322 ** by SQL function writefile(). This function ensures that the directory
2323 ** zFile will be written to exists, creating it if required. The permissions
2324 ** for any path components created by this function are set in accordance
2325 ** with the current umask.
2327 ** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise,
2328 ** SQLITE_OK is returned if the directory is successfully created, or
2329 ** SQLITE_ERROR otherwise.
2331 static int makeDirectory(
2334 char *zCopy = sqlite3_mprintf("%s", zFile);
2340 int nCopy = (int)strlen(zCopy);
2343 while( rc==SQLITE_OK ){
2347 for(; zCopy[i]!='/' && i<nCopy; i++);
2348 if( i==nCopy ) break;
2351 rc2 = fileStat(zCopy, &sStat);
2353 if( mkdir(zCopy, 0777) ) rc = SQLITE_ERROR;
2355 if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR;
2361 sqlite3_free(zCopy);
2368 ** This function does the work for the writefile() UDF. Refer to
2369 ** header comments at the top of this file for details.
2371 static int writeFile(
2372 sqlite3_context *pCtx, /* Context to return bytes written in */
2373 const char *zFile, /* File to write */
2374 sqlite3_value *pData, /* Data to write */
2375 mode_t mode, /* MODE parameter passed to writefile() */
2376 sqlite3_int64 mtime /* MTIME parameter (or -1 to not set time) */
2378 #if !defined(_WIN32) && !defined(WIN32)
2379 if( S_ISLNK(mode) ){
2380 const char *zTo = (const char*)sqlite3_value_text(pData);
2381 if( symlink(zTo, zFile)<0 ) return 1;
2385 if( S_ISDIR(mode) ){
2386 if( mkdir(zFile, mode) ){
2387 /* The mkdir() call to create the directory failed. This might not
2388 ** be an error though - if there is already a directory at the same
2389 ** path and either the permissions already match or can be changed
2390 ** to do so using chmod(), it is not an error. */
2393 || 0!=fileStat(zFile, &sStat)
2394 || !S_ISDIR(sStat.st_mode)
2395 || ((sStat.st_mode&0777)!=(mode&0777) && 0!=chmod(zFile, mode&0777))
2401 sqlite3_int64 nWrite = 0;
2404 FILE *out = fopen(zFile, "wb");
2405 if( out==0 ) return 1;
2406 z = (const char*)sqlite3_value_blob(pData);
2408 sqlite3_int64 n = fwrite(z, 1, sqlite3_value_bytes(pData), out);
2409 nWrite = sqlite3_value_bytes(pData);
2415 if( rc==0 && mode && chmod(zFile, mode & 0777) ){
2419 sqlite3_result_int64(pCtx, nWrite);
2426 FILETIME lastAccess;
2428 SYSTEMTIME currentTime;
2431 LPWSTR zUnicodeName;
2432 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
2434 GetSystemTime(¤tTime);
2435 SystemTimeToFileTime(¤tTime, &lastAccess);
2436 intervals = Int32x32To64(mtime, 10000000) + 116444736000000000;
2437 lastWrite.dwLowDateTime = (DWORD)intervals;
2438 lastWrite.dwHighDateTime = intervals >> 32;
2439 zUnicodeName = sqlite3_win32_utf8_to_unicode(zFile);
2440 if( zUnicodeName==0 ){
2443 hFile = CreateFileW(
2444 zUnicodeName, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING,
2445 FILE_FLAG_BACKUP_SEMANTICS, NULL
2447 sqlite3_free(zUnicodeName);
2448 if( hFile!=INVALID_HANDLE_VALUE ){
2449 BOOL bResult = SetFileTime(hFile, NULL, &lastAccess, &lastWrite);
2455 #elif defined(AT_FDCWD) && 0 /* utimensat() is not universally available */
2457 struct timespec times[2];
2458 times[0].tv_nsec = times[1].tv_nsec = 0;
2459 times[0].tv_sec = time(0);
2460 times[1].tv_sec = mtime;
2461 if( utimensat(AT_FDCWD, zFile, times, AT_SYMLINK_NOFOLLOW) ){
2466 struct timeval times[2];
2467 times[0].tv_usec = times[1].tv_usec = 0;
2468 times[0].tv_sec = time(0);
2469 times[1].tv_sec = mtime;
2470 if( utimes(zFile, times) ){
2480 ** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function.
2481 ** Refer to header comments at the top of this file for details.
2483 static void writefileFunc(
2484 sqlite3_context *context,
2486 sqlite3_value **argv
2491 sqlite3_int64 mtime = -1;
2493 if( argc<2 || argc>4 ){
2494 sqlite3_result_error(context,
2495 "wrong number of arguments to function writefile()", -1
2500 zFile = (const char*)sqlite3_value_text(argv[0]);
2501 if( zFile==0 ) return;
2503 mode = (mode_t)sqlite3_value_int(argv[2]);
2506 mtime = sqlite3_value_int64(argv[3]);
2509 res = writeFile(context, zFile, argv[1], mode, mtime);
2510 if( res==1 && errno==ENOENT ){
2511 if( makeDirectory(zFile)==SQLITE_OK ){
2512 res = writeFile(context, zFile, argv[1], mode, mtime);
2516 if( argc>2 && res!=0 ){
2517 if( S_ISLNK(mode) ){
2518 ctxErrorMsg(context, "failed to create symlink: %s", zFile);
2519 }else if( S_ISDIR(mode) ){
2520 ctxErrorMsg(context, "failed to create directory: %s", zFile);
2522 ctxErrorMsg(context, "failed to write file: %s", zFile);
2528 ** SQL function: lsmode(MODE)
2530 ** Given a numberic st_mode from stat(), convert it into a human-readable
2531 ** text string in the style of "ls -l".
2533 static void lsModeFunc(
2534 sqlite3_context *context,
2536 sqlite3_value **argv
2539 int iMode = sqlite3_value_int(argv[0]);
2542 if( S_ISLNK(iMode) ){
2544 }else if( S_ISREG(iMode) ){
2546 }else if( S_ISDIR(iMode) ){
2552 int m = (iMode >> ((2-i)*3));
2553 char *a = &z[1 + i*3];
2554 a[0] = (m & 0x4) ? 'r' : '-';
2555 a[1] = (m & 0x2) ? 'w' : '-';
2556 a[2] = (m & 0x1) ? 'x' : '-';
2559 sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT);
2562 #ifndef SQLITE_OMIT_VIRTUALTABLE
2565 ** Cursor type for recursively iterating through a directory structure.
2567 typedef struct fsdir_cursor fsdir_cursor;
2568 typedef struct FsdirLevel FsdirLevel;
2571 DIR *pDir; /* From opendir() */
2572 char *zDir; /* Name of directory (nul-terminated) */
2575 struct fsdir_cursor {
2576 sqlite3_vtab_cursor base; /* Base class - must be first */
2578 int nLvl; /* Number of entries in aLvl[] array */
2579 int iLvl; /* Index of current entry */
2580 FsdirLevel *aLvl; /* Hierarchy of directories being traversed */
2585 struct stat sStat; /* Current lstat() results */
2586 char *zPath; /* Path to current entry */
2587 sqlite3_int64 iRowid; /* Current rowid */
2590 typedef struct fsdir_tab fsdir_tab;
2592 sqlite3_vtab base; /* Base class - must be first */
2596 ** Construct a new fsdir virtual table object.
2598 static int fsdirConnect(
2601 int argc, const char *const*argv,
2602 sqlite3_vtab **ppVtab,
2605 fsdir_tab *pNew = 0;
2611 rc = sqlite3_declare_vtab(db, "CREATE TABLE x" FSDIR_SCHEMA);
2612 if( rc==SQLITE_OK ){
2613 pNew = (fsdir_tab*)sqlite3_malloc( sizeof(*pNew) );
2614 if( pNew==0 ) return SQLITE_NOMEM;
2615 memset(pNew, 0, sizeof(*pNew));
2617 *ppVtab = (sqlite3_vtab*)pNew;
2622 ** This method is the destructor for fsdir vtab objects.
2624 static int fsdirDisconnect(sqlite3_vtab *pVtab){
2625 sqlite3_free(pVtab);
2630 ** Constructor for a new fsdir_cursor object.
2632 static int fsdirOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
2635 pCur = sqlite3_malloc( sizeof(*pCur) );
2636 if( pCur==0 ) return SQLITE_NOMEM;
2637 memset(pCur, 0, sizeof(*pCur));
2639 *ppCursor = &pCur->base;
2644 ** Reset a cursor back to the state it was in when first returned
2647 static void fsdirResetCursor(fsdir_cursor *pCur){
2649 for(i=0; i<=pCur->iLvl; i++){
2650 FsdirLevel *pLvl = &pCur->aLvl[i];
2651 if( pLvl->pDir ) closedir(pLvl->pDir);
2652 sqlite3_free(pLvl->zDir);
2654 sqlite3_free(pCur->zPath);
2655 sqlite3_free(pCur->aLvl);
2666 ** Destructor for an fsdir_cursor.
2668 static int fsdirClose(sqlite3_vtab_cursor *cur){
2669 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2671 fsdirResetCursor(pCur);
2677 ** Set the error message for the virtual table associated with cursor
2678 ** pCur to the results of vprintf(zFmt, ...).
2680 static void fsdirSetErrmsg(fsdir_cursor *pCur, const char *zFmt, ...){
2683 pCur->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap);
2689 ** Advance an fsdir_cursor to its next row of output.
2691 static int fsdirNext(sqlite3_vtab_cursor *cur){
2692 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2693 mode_t m = pCur->sStat.st_mode;
2697 /* Descend into this directory */
2698 int iNew = pCur->iLvl + 1;
2700 if( iNew>=pCur->nLvl ){
2702 sqlite3_int64 nByte = nNew*sizeof(FsdirLevel);
2703 FsdirLevel *aNew = (FsdirLevel*)sqlite3_realloc64(pCur->aLvl, nByte);
2704 if( aNew==0 ) return SQLITE_NOMEM;
2705 memset(&aNew[pCur->nLvl], 0, sizeof(FsdirLevel)*(nNew-pCur->nLvl));
2710 pLvl = &pCur->aLvl[iNew];
2712 pLvl->zDir = pCur->zPath;
2714 pLvl->pDir = opendir(pLvl->zDir);
2715 if( pLvl->pDir==0 ){
2716 fsdirSetErrmsg(pCur, "cannot read directory: %s", pCur->zPath);
2717 return SQLITE_ERROR;
2721 while( pCur->iLvl>=0 ){
2722 FsdirLevel *pLvl = &pCur->aLvl[pCur->iLvl];
2723 struct dirent *pEntry = readdir(pLvl->pDir);
2725 if( pEntry->d_name[0]=='.' ){
2726 if( pEntry->d_name[1]=='.' && pEntry->d_name[2]=='\0' ) continue;
2727 if( pEntry->d_name[1]=='\0' ) continue;
2729 sqlite3_free(pCur->zPath);
2730 pCur->zPath = sqlite3_mprintf("%s/%s", pLvl->zDir, pEntry->d_name);
2731 if( pCur->zPath==0 ) return SQLITE_NOMEM;
2732 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){
2733 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath);
2734 return SQLITE_ERROR;
2738 closedir(pLvl->pDir);
2739 sqlite3_free(pLvl->zDir);
2746 sqlite3_free(pCur->zPath);
2752 ** Return values of columns for the row at which the series_cursor
2753 ** is currently pointing.
2755 static int fsdirColumn(
2756 sqlite3_vtab_cursor *cur, /* The cursor */
2757 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
2758 int i /* Which column to return */
2760 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2762 case FSDIR_COLUMN_NAME: {
2763 sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT);
2767 case FSDIR_COLUMN_MODE:
2768 sqlite3_result_int64(ctx, pCur->sStat.st_mode);
2771 case FSDIR_COLUMN_MTIME:
2772 sqlite3_result_int64(ctx, pCur->sStat.st_mtime);
2775 case FSDIR_COLUMN_DATA: {
2776 mode_t m = pCur->sStat.st_mode;
2778 sqlite3_result_null(ctx);
2779 #if !defined(_WIN32) && !defined(WIN32)
2780 }else if( S_ISLNK(m) ){
2782 char *aBuf = aStatic;
2783 sqlite3_int64 nBuf = 64;
2787 n = readlink(pCur->zPath, aBuf, nBuf);
2789 if( aBuf!=aStatic ) sqlite3_free(aBuf);
2791 aBuf = sqlite3_malloc64(nBuf);
2793 sqlite3_result_error_nomem(ctx);
2794 return SQLITE_NOMEM;
2798 sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT);
2799 if( aBuf!=aStatic ) sqlite3_free(aBuf);
2802 readFileContents(ctx, pCur->zPath);
2805 case FSDIR_COLUMN_PATH:
2807 /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters.
2808 ** always return their values as NULL */
2816 ** Return the rowid for the current row. In this implementation, the
2817 ** first row returned is assigned rowid value 1, and each subsequent
2818 ** row a value 1 more than that of the previous.
2820 static int fsdirRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
2821 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2822 *pRowid = pCur->iRowid;
2827 ** Return TRUE if the cursor has been moved off of the last
2830 static int fsdirEof(sqlite3_vtab_cursor *cur){
2831 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2832 return (pCur->zPath==0);
2836 ** xFilter callback.
2838 ** idxNum==1 PATH parameter only
2839 ** idxNum==2 Both PATH and DIR supplied
2841 static int fsdirFilter(
2842 sqlite3_vtab_cursor *cur,
2843 int idxNum, const char *idxStr,
2844 int argc, sqlite3_value **argv
2846 const char *zDir = 0;
2847 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2849 fsdirResetCursor(pCur);
2852 fsdirSetErrmsg(pCur, "table function fsdir requires an argument");
2853 return SQLITE_ERROR;
2856 assert( argc==idxNum && (argc==1 || argc==2) );
2857 zDir = (const char*)sqlite3_value_text(argv[0]);
2859 fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument");
2860 return SQLITE_ERROR;
2863 pCur->zBase = (const char*)sqlite3_value_text(argv[1]);
2866 pCur->nBase = (int)strlen(pCur->zBase)+1;
2867 pCur->zPath = sqlite3_mprintf("%s/%s", pCur->zBase, zDir);
2869 pCur->zPath = sqlite3_mprintf("%s", zDir);
2872 if( pCur->zPath==0 ){
2873 return SQLITE_NOMEM;
2875 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){
2876 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath);
2877 return SQLITE_ERROR;
2884 ** SQLite will invoke this method one or more times while planning a query
2885 ** that uses the generate_series virtual table. This routine needs to create
2886 ** a query plan for each invocation and compute an estimated cost for that
2889 ** In this implementation idxNum is used to represent the
2890 ** query plan. idxStr is unused.
2892 ** The query plan is represented by values of idxNum:
2894 ** (1) The path value is supplied by argv[0]
2895 ** (2) Path is in argv[0] and dir is in argv[1]
2897 static int fsdirBestIndex(
2899 sqlite3_index_info *pIdxInfo
2901 int i; /* Loop over constraints */
2902 int idxPath = -1; /* Index in pIdxInfo->aConstraint of PATH= */
2903 int idxDir = -1; /* Index in pIdxInfo->aConstraint of DIR= */
2904 int seenPath = 0; /* True if an unusable PATH= constraint is seen */
2905 int seenDir = 0; /* True if an unusable DIR= constraint is seen */
2906 const struct sqlite3_index_constraint *pConstraint;
2909 pConstraint = pIdxInfo->aConstraint;
2910 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
2911 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
2912 switch( pConstraint->iColumn ){
2913 case FSDIR_COLUMN_PATH: {
2914 if( pConstraint->usable ){
2917 }else if( idxPath<0 ){
2922 case FSDIR_COLUMN_DIR: {
2923 if( pConstraint->usable ){
2926 }else if( idxDir<0 ){
2933 if( seenPath || seenDir ){
2934 /* If input parameters are unusable, disallow this plan */
2935 return SQLITE_CONSTRAINT;
2939 pIdxInfo->idxNum = 0;
2940 /* The pIdxInfo->estimatedCost should have been initialized to a huge
2941 ** number. Leave it unchanged. */
2942 pIdxInfo->estimatedRows = 0x7fffffff;
2944 pIdxInfo->aConstraintUsage[idxPath].omit = 1;
2945 pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1;
2947 pIdxInfo->aConstraintUsage[idxDir].omit = 1;
2948 pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2;
2949 pIdxInfo->idxNum = 2;
2950 pIdxInfo->estimatedCost = 10.0;
2952 pIdxInfo->idxNum = 1;
2953 pIdxInfo->estimatedCost = 100.0;
2961 ** Register the "fsdir" virtual table.
2963 static int fsdirRegister(sqlite3 *db){
2964 static sqlite3_module fsdirModule = {
2967 fsdirConnect, /* xConnect */
2968 fsdirBestIndex, /* xBestIndex */
2969 fsdirDisconnect, /* xDisconnect */
2971 fsdirOpen, /* xOpen - open a cursor */
2972 fsdirClose, /* xClose - close a cursor */
2973 fsdirFilter, /* xFilter - configure scan constraints */
2974 fsdirNext, /* xNext - advance a cursor */
2975 fsdirEof, /* xEof - check for end of scan */
2976 fsdirColumn, /* xColumn - read data */
2977 fsdirRowid, /* xRowid - read data */
2983 0, /* xFindMethod */
2987 0, /* xRollbackTo */
2988 0, /* xShadowName */
2991 int rc = sqlite3_create_module(db, "fsdir", &fsdirModule, 0);
2994 #else /* SQLITE_OMIT_VIRTUALTABLE */
2995 # define fsdirRegister(x) SQLITE_OK
3001 int sqlite3_fileio_init(
3004 const sqlite3_api_routines *pApi
3007 SQLITE_EXTENSION_INIT2(pApi);
3008 (void)pzErrMsg; /* Unused parameter */
3009 rc = sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
3010 readfileFunc, 0, 0);
3011 if( rc==SQLITE_OK ){
3012 rc = sqlite3_create_function(db, "writefile", -1, SQLITE_UTF8, 0,
3013 writefileFunc, 0, 0);
3015 if( rc==SQLITE_OK ){
3016 rc = sqlite3_create_function(db, "lsmode", 1, SQLITE_UTF8, 0,
3019 if( rc==SQLITE_OK ){
3020 rc = fsdirRegister(db);
3025 /************************* End ../ext/misc/fileio.c ********************/
3026 /************************* Begin ../ext/misc/completion.c ******************/
3030 ** The author disclaims copyright to this source code. In place of
3031 ** a legal notice, here is a blessing:
3033 ** May you do good and not evil.
3034 ** May you find forgiveness for yourself and forgive others.
3035 ** May you share freely, never taking more than you give.
3037 *************************************************************************
3039 ** This file implements an eponymous virtual table that returns suggested
3040 ** completions for a partial SQL input.
3044 ** SELECT DISTINCT candidate COLLATE nocase
3045 ** FROM completion($prefix,$wholeline)
3048 ** The two query parameters are optional. $prefix is the text of the
3049 ** current word being typed and that is to be completed. $wholeline is
3050 ** the complete input line, used for context.
3052 ** The raw completion() table might return the same candidate multiple
3053 ** times, for example if the same column name is used to two or more
3054 ** tables. And the candidates are returned in an arbitrary order. Hence,
3055 ** the DISTINCT and ORDER BY are recommended.
3057 ** This virtual table operates at the speed of human typing, and so there
3058 ** is no attempt to make it fast. Even a slow implementation will be much
3059 ** faster than any human can type.
3062 /* #include "sqlite3ext.h" */
3063 SQLITE_EXTENSION_INIT1
3068 #ifndef SQLITE_OMIT_VIRTUALTABLE
3070 /* completion_vtab is a subclass of sqlite3_vtab which will
3071 ** serve as the underlying representation of a completion virtual table
3073 typedef struct completion_vtab completion_vtab;
3074 struct completion_vtab {
3075 sqlite3_vtab base; /* Base class - must be first */
3076 sqlite3 *db; /* Database connection for this completion vtab */
3079 /* completion_cursor is a subclass of sqlite3_vtab_cursor which will
3080 ** serve as the underlying representation of a cursor that scans
3081 ** over rows of the result
3083 typedef struct completion_cursor completion_cursor;
3084 struct completion_cursor {
3085 sqlite3_vtab_cursor base; /* Base class - must be first */
3086 sqlite3 *db; /* Database connection for this cursor */
3087 int nPrefix, nLine; /* Number of bytes in zPrefix and zLine */
3088 char *zPrefix; /* The prefix for the word we want to complete */
3089 char *zLine; /* The whole that we want to complete */
3090 const char *zCurrentRow; /* Current output row */
3091 int szRow; /* Length of the zCurrentRow string */
3092 sqlite3_stmt *pStmt; /* Current statement */
3093 sqlite3_int64 iRowid; /* The rowid */
3094 int ePhase; /* Current phase */
3095 int j; /* inter-phase counter */
3098 /* Values for ePhase:
3100 #define COMPLETION_FIRST_PHASE 1
3101 #define COMPLETION_KEYWORDS 1
3102 #define COMPLETION_PRAGMAS 2
3103 #define COMPLETION_FUNCTIONS 3
3104 #define COMPLETION_COLLATIONS 4
3105 #define COMPLETION_INDEXES 5
3106 #define COMPLETION_TRIGGERS 6
3107 #define COMPLETION_DATABASES 7
3108 #define COMPLETION_TABLES 8 /* Also VIEWs and TRIGGERs */
3109 #define COMPLETION_COLUMNS 9
3110 #define COMPLETION_MODULES 10
3111 #define COMPLETION_EOF 11
3114 ** The completionConnect() method is invoked to create a new
3115 ** completion_vtab that describes the completion virtual table.
3117 ** Think of this routine as the constructor for completion_vtab objects.
3119 ** All this routine needs to do is:
3121 ** (1) Allocate the completion_vtab object and initialize all fields.
3123 ** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
3124 ** result set of queries against completion will look like.
3126 static int completionConnect(
3129 int argc, const char *const*argv,
3130 sqlite3_vtab **ppVtab,
3133 completion_vtab *pNew;
3136 (void)(pAux); /* Unused parameter */
3137 (void)(argc); /* Unused parameter */
3138 (void)(argv); /* Unused parameter */
3139 (void)(pzErr); /* Unused parameter */
3141 /* Column numbers */
3142 #define COMPLETION_COLUMN_CANDIDATE 0 /* Suggested completion of the input */
3143 #define COMPLETION_COLUMN_PREFIX 1 /* Prefix of the word to be completed */
3144 #define COMPLETION_COLUMN_WHOLELINE 2 /* Entire line seen so far */
3145 #define COMPLETION_COLUMN_PHASE 3 /* ePhase - used for debugging only */
3147 rc = sqlite3_declare_vtab(db,
3150 " prefix TEXT HIDDEN,"
3151 " wholeline TEXT HIDDEN,"
3152 " phase INT HIDDEN" /* Used for debugging only */
3154 if( rc==SQLITE_OK ){
3155 pNew = sqlite3_malloc( sizeof(*pNew) );
3156 *ppVtab = (sqlite3_vtab*)pNew;
3157 if( pNew==0 ) return SQLITE_NOMEM;
3158 memset(pNew, 0, sizeof(*pNew));
3165 ** This method is the destructor for completion_cursor objects.
3167 static int completionDisconnect(sqlite3_vtab *pVtab){
3168 sqlite3_free(pVtab);
3173 ** Constructor for a new completion_cursor object.
3175 static int completionOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
3176 completion_cursor *pCur;
3177 pCur = sqlite3_malloc( sizeof(*pCur) );
3178 if( pCur==0 ) return SQLITE_NOMEM;
3179 memset(pCur, 0, sizeof(*pCur));
3180 pCur->db = ((completion_vtab*)p)->db;
3181 *ppCursor = &pCur->base;
3186 ** Reset the completion_cursor.
3188 static void completionCursorReset(completion_cursor *pCur){
3189 sqlite3_free(pCur->zPrefix); pCur->zPrefix = 0; pCur->nPrefix = 0;
3190 sqlite3_free(pCur->zLine); pCur->zLine = 0; pCur->nLine = 0;
3191 sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0;
3196 ** Destructor for a completion_cursor.
3198 static int completionClose(sqlite3_vtab_cursor *cur){
3199 completionCursorReset((completion_cursor*)cur);
3205 ** Advance a completion_cursor to its next row of output.
3207 ** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object
3208 ** record the current state of the scan. This routine sets ->zCurrentRow
3209 ** to the current row of output and then returns. If no more rows remain,
3210 ** then ->ePhase is set to COMPLETION_EOF which will signal the virtual
3211 ** table that has reached the end of its scan.
3213 ** The current implementation just lists potential identifiers and
3214 ** keywords and filters them by zPrefix. Future enhancements should
3215 ** take zLine into account to try to restrict the set of identifiers and
3216 ** keywords based on what would be legal at the current point of input.
3218 static int completionNext(sqlite3_vtab_cursor *cur){
3219 completion_cursor *pCur = (completion_cursor*)cur;
3220 int eNextPhase = 0; /* Next phase to try if current phase reaches end */
3221 int iCol = -1; /* If >=0, step pCur->pStmt and use the i-th column */
3223 while( pCur->ePhase!=COMPLETION_EOF ){
3224 switch( pCur->ePhase ){
3225 case COMPLETION_KEYWORDS: {
3226 if( pCur->j >= sqlite3_keyword_count() ){
3227 pCur->zCurrentRow = 0;
3228 pCur->ePhase = COMPLETION_DATABASES;
3230 sqlite3_keyword_name(pCur->j++, &pCur->zCurrentRow, &pCur->szRow);
3235 case COMPLETION_DATABASES: {
3236 if( pCur->pStmt==0 ){
3237 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1,
3241 eNextPhase = COMPLETION_TABLES;
3244 case COMPLETION_TABLES: {
3245 if( pCur->pStmt==0 ){
3248 const char *zSep = "";
3249 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
3250 while( sqlite3_step(pS2)==SQLITE_ROW ){
3251 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
3252 zSql = sqlite3_mprintf(
3254 "SELECT name FROM \"%w\".sqlite_master",
3257 if( zSql==0 ) return SQLITE_NOMEM;
3260 sqlite3_finalize(pS2);
3261 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
3265 eNextPhase = COMPLETION_COLUMNS;
3268 case COMPLETION_COLUMNS: {
3269 if( pCur->pStmt==0 ){
3272 const char *zSep = "";
3273 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
3274 while( sqlite3_step(pS2)==SQLITE_ROW ){
3275 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
3276 zSql = sqlite3_mprintf(
3278 "SELECT pti.name FROM \"%w\".sqlite_master AS sm"
3279 " JOIN pragma_table_info(sm.name,%Q) AS pti"
3280 " WHERE sm.type='table'",
3281 zSql, zSep, zDb, zDb
3283 if( zSql==0 ) return SQLITE_NOMEM;
3286 sqlite3_finalize(pS2);
3287 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
3291 eNextPhase = COMPLETION_EOF;
3296 /* This case is when the phase presets zCurrentRow */
3297 if( pCur->zCurrentRow==0 ) continue;
3299 if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){
3300 /* Extract the next row of content */
3301 pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol);
3302 pCur->szRow = sqlite3_column_bytes(pCur->pStmt, iCol);
3304 /* When all rows are finished, advance to the next phase */
3305 sqlite3_finalize(pCur->pStmt);
3307 pCur->ePhase = eNextPhase;
3311 if( pCur->nPrefix==0 ) break;
3312 if( pCur->nPrefix<=pCur->szRow
3313 && sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0
3323 ** Return values of columns for the row at which the completion_cursor
3324 ** is currently pointing.
3326 static int completionColumn(
3327 sqlite3_vtab_cursor *cur, /* The cursor */
3328 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
3329 int i /* Which column to return */
3331 completion_cursor *pCur = (completion_cursor*)cur;
3333 case COMPLETION_COLUMN_CANDIDATE: {
3334 sqlite3_result_text(ctx, pCur->zCurrentRow, pCur->szRow,SQLITE_TRANSIENT);
3337 case COMPLETION_COLUMN_PREFIX: {
3338 sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT);
3341 case COMPLETION_COLUMN_WHOLELINE: {
3342 sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT);
3345 case COMPLETION_COLUMN_PHASE: {
3346 sqlite3_result_int(ctx, pCur->ePhase);
3354 ** Return the rowid for the current row. In this implementation, the
3355 ** rowid is the same as the output value.
3357 static int completionRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
3358 completion_cursor *pCur = (completion_cursor*)cur;
3359 *pRowid = pCur->iRowid;
3364 ** Return TRUE if the cursor has been moved off of the last
3367 static int completionEof(sqlite3_vtab_cursor *cur){
3368 completion_cursor *pCur = (completion_cursor*)cur;
3369 return pCur->ePhase >= COMPLETION_EOF;
3373 ** This method is called to "rewind" the completion_cursor object back
3374 ** to the first row of output. This method is always called at least
3375 ** once prior to any call to completionColumn() or completionRowid() or
3378 static int completionFilter(
3379 sqlite3_vtab_cursor *pVtabCursor,
3380 int idxNum, const char *idxStr,
3381 int argc, sqlite3_value **argv
3383 completion_cursor *pCur = (completion_cursor *)pVtabCursor;
3385 (void)(idxStr); /* Unused parameter */
3386 (void)(argc); /* Unused parameter */
3387 completionCursorReset(pCur);
3389 pCur->nPrefix = sqlite3_value_bytes(argv[iArg]);
3390 if( pCur->nPrefix>0 ){
3391 pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
3392 if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
3397 pCur->nLine = sqlite3_value_bytes(argv[iArg]);
3398 if( pCur->nLine>0 ){
3399 pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
3400 if( pCur->zLine==0 ) return SQLITE_NOMEM;
3403 if( pCur->zLine!=0 && pCur->zPrefix==0 ){
3404 int i = pCur->nLine;
3405 while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){
3408 pCur->nPrefix = pCur->nLine - i;
3409 if( pCur->nPrefix>0 ){
3410 pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i);
3411 if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
3415 pCur->ePhase = COMPLETION_FIRST_PHASE;
3416 return completionNext(pVtabCursor);
3420 ** SQLite will invoke this method one or more times while planning a query
3421 ** that uses the completion virtual table. This routine needs to create
3422 ** a query plan for each invocation and compute an estimated cost for that
3425 ** There are two hidden parameters that act as arguments to the table-valued
3426 ** function: "prefix" and "wholeline". Bit 0 of idxNum is set if "prefix"
3427 ** is available and bit 1 is set if "wholeline" is available.
3429 static int completionBestIndex(
3431 sqlite3_index_info *pIdxInfo
3433 int i; /* Loop over constraints */
3434 int idxNum = 0; /* The query plan bitmask */
3435 int prefixIdx = -1; /* Index of the start= constraint, or -1 if none */
3436 int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */
3437 int nArg = 0; /* Number of arguments that completeFilter() expects */
3438 const struct sqlite3_index_constraint *pConstraint;
3440 (void)(tab); /* Unused parameter */
3441 pConstraint = pIdxInfo->aConstraint;
3442 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
3443 if( pConstraint->usable==0 ) continue;
3444 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
3445 switch( pConstraint->iColumn ){
3446 case COMPLETION_COLUMN_PREFIX:
3450 case COMPLETION_COLUMN_WHOLELINE:
3457 pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg;
3458 pIdxInfo->aConstraintUsage[prefixIdx].omit = 1;
3460 if( wholelineIdx>=0 ){
3461 pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg;
3462 pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1;
3464 pIdxInfo->idxNum = idxNum;
3465 pIdxInfo->estimatedCost = (double)5000 - 1000*nArg;
3466 pIdxInfo->estimatedRows = 500 - 100*nArg;
3471 ** This following structure defines all the methods for the
3472 ** completion virtual table.
3474 static sqlite3_module completionModule = {
3477 completionConnect, /* xConnect */
3478 completionBestIndex, /* xBestIndex */
3479 completionDisconnect, /* xDisconnect */
3481 completionOpen, /* xOpen - open a cursor */
3482 completionClose, /* xClose - close a cursor */
3483 completionFilter, /* xFilter - configure scan constraints */
3484 completionNext, /* xNext - advance a cursor */
3485 completionEof, /* xEof - check for end of scan */
3486 completionColumn, /* xColumn - read data */
3487 completionRowid, /* xRowid - read data */
3493 0, /* xFindMethod */
3497 0, /* xRollbackTo */
3501 #endif /* SQLITE_OMIT_VIRTUALTABLE */
3503 int sqlite3CompletionVtabInit(sqlite3 *db){
3505 #ifndef SQLITE_OMIT_VIRTUALTABLE
3506 rc = sqlite3_create_module(db, "completion", &completionModule, 0);
3514 int sqlite3_completion_init(
3517 const sqlite3_api_routines *pApi
3520 SQLITE_EXTENSION_INIT2(pApi);
3521 (void)(pzErrMsg); /* Unused parameter */
3522 #ifndef SQLITE_OMIT_VIRTUALTABLE
3523 rc = sqlite3CompletionVtabInit(db);
3528 /************************* End ../ext/misc/completion.c ********************/
3529 /************************* Begin ../ext/misc/appendvfs.c ******************/
3533 ** The author disclaims copyright to this source code. In place of
3534 ** a legal notice, here is a blessing:
3536 ** May you do good and not evil.
3537 ** May you find forgiveness for yourself and forgive others.
3538 ** May you share freely, never taking more than you give.
3540 ******************************************************************************
3542 ** This file implements a VFS shim that allows an SQLite database to be
3543 ** appended onto the end of some other file, such as an executable.
3545 ** A special record must appear at the end of the file that identifies the
3546 ** file as an appended database and provides an offset to page 1. For
3547 ** best performance page 1 should be located at a disk page boundary, though
3548 ** that is not required.
3550 ** When opening a database using this VFS, the connection might treat
3551 ** the file as an ordinary SQLite database, or it might treat is as a
3552 ** database appended onto some other file. Here are the rules:
3554 ** (1) When opening a new empty file, that file is treated as an ordinary
3557 ** (2) When opening a file that begins with the standard SQLite prefix
3558 ** string "SQLite format 3", that file is treated as an ordinary
3561 ** (3) When opening a file that ends with the appendvfs trailer string
3562 ** "Start-Of-SQLite3-NNNNNNNN" that file is treated as an appended
3565 ** (4) If none of the above apply and the SQLITE_OPEN_CREATE flag is
3566 ** set, then a new database is appended to the already existing file.
3568 ** (5) Otherwise, SQLITE_CANTOPEN is returned.
3570 ** To avoid unnecessary complications with the PENDING_BYTE, the size of
3571 ** the file containing the database is limited to 1GB. This VFS will refuse
3572 ** to read or write past the 1GB mark. This restriction might be lifted in
3573 ** future versions. For now, if you need a large database, then keep the
3574 ** database in a separate file.
3576 ** If the file being opened is not an appended database, then this shim is
3577 ** a pass-through into the default underlying VFS.
3579 /* #include "sqlite3ext.h" */
3580 SQLITE_EXTENSION_INIT1
3584 /* The append mark at the end of the database is:
3586 ** Start-Of-SQLite3-NNNNNNNN
3587 ** 123456789 123456789 12345
3589 ** The NNNNNNNN represents a 64-bit big-endian unsigned integer which is
3590 ** the offset to page 1.
3592 #define APND_MARK_PREFIX "Start-Of-SQLite3-"
3593 #define APND_MARK_PREFIX_SZ 17
3594 #define APND_MARK_SIZE 25
3597 ** Maximum size of the combined prefix + database + append-mark. This
3598 ** must be less than 0x40000000 to avoid locking issues on Windows.
3600 #define APND_MAX_SIZE (65536*15259)
3603 ** Forward declaration of objects used by this utility
3605 typedef struct sqlite3_vfs ApndVfs;
3606 typedef struct ApndFile ApndFile;
3608 /* Access to a lower-level VFS that (might) implement dynamic loading,
3609 ** access to randomness, etc.
3611 #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData))
3612 #define ORIGFILE(p) ((sqlite3_file*)(((ApndFile*)(p))+1))
3616 sqlite3_file base; /* IO methods */
3617 sqlite3_int64 iPgOne; /* File offset to page 1 */
3618 sqlite3_int64 iMark; /* Start of the append-mark */
3622 ** Methods for ApndFile
3624 static int apndClose(sqlite3_file*);
3625 static int apndRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
3626 static int apndWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
3627 static int apndTruncate(sqlite3_file*, sqlite3_int64 size);
3628 static int apndSync(sqlite3_file*, int flags);
3629 static int apndFileSize(sqlite3_file*, sqlite3_int64 *pSize);
3630 static int apndLock(sqlite3_file*, int);
3631 static int apndUnlock(sqlite3_file*, int);
3632 static int apndCheckReservedLock(sqlite3_file*, int *pResOut);
3633 static int apndFileControl(sqlite3_file*, int op, void *pArg);
3634 static int apndSectorSize(sqlite3_file*);
3635 static int apndDeviceCharacteristics(sqlite3_file*);
3636 static int apndShmMap(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
3637 static int apndShmLock(sqlite3_file*, int offset, int n, int flags);
3638 static void apndShmBarrier(sqlite3_file*);
3639 static int apndShmUnmap(sqlite3_file*, int deleteFlag);
3640 static int apndFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
3641 static int apndUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p);
3644 ** Methods for ApndVfs
3646 static int apndOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
3647 static int apndDelete(sqlite3_vfs*, const char *zName, int syncDir);
3648 static int apndAccess(sqlite3_vfs*, const char *zName, int flags, int *);
3649 static int apndFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
3650 static void *apndDlOpen(sqlite3_vfs*, const char *zFilename);
3651 static void apndDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
3652 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
3653 static void apndDlClose(sqlite3_vfs*, void*);
3654 static int apndRandomness(sqlite3_vfs*, int nByte, char *zOut);
3655 static int apndSleep(sqlite3_vfs*, int microseconds);
3656 static int apndCurrentTime(sqlite3_vfs*, double*);
3657 static int apndGetLastError(sqlite3_vfs*, int, char *);
3658 static int apndCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
3659 static int apndSetSystemCall(sqlite3_vfs*, const char*,sqlite3_syscall_ptr);
3660 static sqlite3_syscall_ptr apndGetSystemCall(sqlite3_vfs*, const char *z);
3661 static const char *apndNextSystemCall(sqlite3_vfs*, const char *zName);
3663 static sqlite3_vfs apnd_vfs = {
3664 3, /* iVersion (set when registered) */
3665 0, /* szOsFile (set when registered) */
3666 1024, /* mxPathname */
3668 "apndvfs", /* zName */
3669 0, /* pAppData (set when registered) */
3670 apndOpen, /* xOpen */
3671 apndDelete, /* xDelete */
3672 apndAccess, /* xAccess */
3673 apndFullPathname, /* xFullPathname */
3674 apndDlOpen, /* xDlOpen */
3675 apndDlError, /* xDlError */
3676 apndDlSym, /* xDlSym */
3677 apndDlClose, /* xDlClose */
3678 apndRandomness, /* xRandomness */
3679 apndSleep, /* xSleep */
3680 apndCurrentTime, /* xCurrentTime */
3681 apndGetLastError, /* xGetLastError */
3682 apndCurrentTimeInt64, /* xCurrentTimeInt64 */
3683 apndSetSystemCall, /* xSetSystemCall */
3684 apndGetSystemCall, /* xGetSystemCall */
3685 apndNextSystemCall /* xNextSystemCall */
3688 static const sqlite3_io_methods apnd_io_methods = {
3690 apndClose, /* xClose */
3691 apndRead, /* xRead */
3692 apndWrite, /* xWrite */
3693 apndTruncate, /* xTruncate */
3694 apndSync, /* xSync */
3695 apndFileSize, /* xFileSize */
3696 apndLock, /* xLock */
3697 apndUnlock, /* xUnlock */
3698 apndCheckReservedLock, /* xCheckReservedLock */
3699 apndFileControl, /* xFileControl */
3700 apndSectorSize, /* xSectorSize */
3701 apndDeviceCharacteristics, /* xDeviceCharacteristics */
3702 apndShmMap, /* xShmMap */
3703 apndShmLock, /* xShmLock */
3704 apndShmBarrier, /* xShmBarrier */
3705 apndShmUnmap, /* xShmUnmap */
3706 apndFetch, /* xFetch */
3707 apndUnfetch /* xUnfetch */
3713 ** Close an apnd-file.
3715 static int apndClose(sqlite3_file *pFile){
3716 pFile = ORIGFILE(pFile);
3717 return pFile->pMethods->xClose(pFile);
3721 ** Read data from an apnd-file.
3723 static int apndRead(
3724 sqlite3_file *pFile,
3729 ApndFile *p = (ApndFile *)pFile;
3730 pFile = ORIGFILE(pFile);
3731 return pFile->pMethods->xRead(pFile, zBuf, iAmt, iOfst+p->iPgOne);
3735 ** Add the append-mark onto the end of the file.
3737 static int apndWriteMark(ApndFile *p, sqlite3_file *pFile){
3739 unsigned char a[APND_MARK_SIZE];
3740 memcpy(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ);
3742 a[APND_MARK_PREFIX_SZ+i] = (p->iPgOne >> (56 - i*8)) & 0xff;
3744 return pFile->pMethods->xWrite(pFile, a, APND_MARK_SIZE, p->iMark);
3748 ** Write data to an apnd-file.
3750 static int apndWrite(
3751 sqlite3_file *pFile,
3757 ApndFile *p = (ApndFile *)pFile;
3758 pFile = ORIGFILE(pFile);
3759 if( iOfst+iAmt>=APND_MAX_SIZE ) return SQLITE_FULL;
3760 rc = pFile->pMethods->xWrite(pFile, zBuf, iAmt, iOfst+p->iPgOne);
3761 if( rc==SQLITE_OK && iOfst + iAmt + p->iPgOne > p->iMark ){
3762 sqlite3_int64 sz = 0;
3763 rc = pFile->pMethods->xFileSize(pFile, &sz);
3764 if( rc==SQLITE_OK ){
3765 p->iMark = sz - APND_MARK_SIZE;
3766 if( iOfst + iAmt + p->iPgOne > p->iMark ){
3767 p->iMark = p->iPgOne + iOfst + iAmt;
3768 rc = apndWriteMark(p, pFile);
3776 ** Truncate an apnd-file.
3778 static int apndTruncate(sqlite3_file *pFile, sqlite_int64 size){
3780 ApndFile *p = (ApndFile *)pFile;
3781 pFile = ORIGFILE(pFile);
3782 rc = pFile->pMethods->xTruncate(pFile, size+p->iPgOne+APND_MARK_SIZE);
3783 if( rc==SQLITE_OK ){
3784 p->iMark = p->iPgOne+size;
3785 rc = apndWriteMark(p, pFile);
3791 ** Sync an apnd-file.
3793 static int apndSync(sqlite3_file *pFile, int flags){
3794 pFile = ORIGFILE(pFile);
3795 return pFile->pMethods->xSync(pFile, flags);
3799 ** Return the current file-size of an apnd-file.
3801 static int apndFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
3802 ApndFile *p = (ApndFile *)pFile;
3804 pFile = ORIGFILE(p);
3805 rc = pFile->pMethods->xFileSize(pFile, pSize);
3806 if( rc==SQLITE_OK && p->iPgOne ){
3807 *pSize -= p->iPgOne + APND_MARK_SIZE;
3813 ** Lock an apnd-file.
3815 static int apndLock(sqlite3_file *pFile, int eLock){
3816 pFile = ORIGFILE(pFile);
3817 return pFile->pMethods->xLock(pFile, eLock);
3821 ** Unlock an apnd-file.
3823 static int apndUnlock(sqlite3_file *pFile, int eLock){
3824 pFile = ORIGFILE(pFile);
3825 return pFile->pMethods->xUnlock(pFile, eLock);
3829 ** Check if another file-handle holds a RESERVED lock on an apnd-file.
3831 static int apndCheckReservedLock(sqlite3_file *pFile, int *pResOut){
3832 pFile = ORIGFILE(pFile);
3833 return pFile->pMethods->xCheckReservedLock(pFile, pResOut);
3837 ** File control method. For custom operations on an apnd-file.
3839 static int apndFileControl(sqlite3_file *pFile, int op, void *pArg){
3840 ApndFile *p = (ApndFile *)pFile;
3842 pFile = ORIGFILE(pFile);
3843 rc = pFile->pMethods->xFileControl(pFile, op, pArg);
3844 if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
3845 *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", p->iPgOne, *(char**)pArg);
3851 ** Return the sector-size in bytes for an apnd-file.
3853 static int apndSectorSize(sqlite3_file *pFile){
3854 pFile = ORIGFILE(pFile);
3855 return pFile->pMethods->xSectorSize(pFile);
3859 ** Return the device characteristic flags supported by an apnd-file.
3861 static int apndDeviceCharacteristics(sqlite3_file *pFile){
3862 pFile = ORIGFILE(pFile);
3863 return pFile->pMethods->xDeviceCharacteristics(pFile);
3866 /* Create a shared memory file mapping */
3867 static int apndShmMap(
3868 sqlite3_file *pFile,
3874 pFile = ORIGFILE(pFile);
3875 return pFile->pMethods->xShmMap(pFile,iPg,pgsz,bExtend,pp);
3878 /* Perform locking on a shared-memory segment */
3879 static int apndShmLock(sqlite3_file *pFile, int offset, int n, int flags){
3880 pFile = ORIGFILE(pFile);
3881 return pFile->pMethods->xShmLock(pFile,offset,n,flags);
3884 /* Memory barrier operation on shared memory */
3885 static void apndShmBarrier(sqlite3_file *pFile){
3886 pFile = ORIGFILE(pFile);
3887 pFile->pMethods->xShmBarrier(pFile);
3890 /* Unmap a shared memory segment */
3891 static int apndShmUnmap(sqlite3_file *pFile, int deleteFlag){
3892 pFile = ORIGFILE(pFile);
3893 return pFile->pMethods->xShmUnmap(pFile,deleteFlag);
3896 /* Fetch a page of a memory-mapped file */
3897 static int apndFetch(
3898 sqlite3_file *pFile,
3899 sqlite3_int64 iOfst,
3903 ApndFile *p = (ApndFile *)pFile;
3904 pFile = ORIGFILE(pFile);
3905 return pFile->pMethods->xFetch(pFile, iOfst+p->iPgOne, iAmt, pp);
3908 /* Release a memory-mapped page */
3909 static int apndUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
3910 ApndFile *p = (ApndFile *)pFile;
3911 pFile = ORIGFILE(pFile);
3912 return pFile->pMethods->xUnfetch(pFile, iOfst+p->iPgOne, pPage);
3916 ** Check to see if the file is an ordinary SQLite database file.
3918 static int apndIsOrdinaryDatabaseFile(sqlite3_int64 sz, sqlite3_file *pFile){
3921 static const char aSqliteHdr[] = "SQLite format 3";
3922 if( sz<512 ) return 0;
3923 rc = pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), 0);
3925 return memcmp(zHdr, aSqliteHdr, sizeof(zHdr))==0;
3929 ** Try to read the append-mark off the end of a file. Return the
3930 ** start of the appended database if the append-mark is present. If
3931 ** there is no append-mark, return -1;
3933 static sqlite3_int64 apndReadMark(sqlite3_int64 sz, sqlite3_file *pFile){
3935 sqlite3_int64 iMark;
3936 unsigned char a[APND_MARK_SIZE];
3938 if( sz<=APND_MARK_SIZE ) return -1;
3939 rc = pFile->pMethods->xRead(pFile, a, APND_MARK_SIZE, sz-APND_MARK_SIZE);
3941 if( memcmp(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ)!=0 ) return -1;
3942 iMark = ((sqlite3_int64)(a[APND_MARK_PREFIX_SZ]&0x7f))<<56;
3944 iMark += (sqlite3_int64)a[APND_MARK_PREFIX_SZ+i]<<(56-8*i);
3950 ** Open an apnd file handle.
3952 static int apndOpen(
3955 sqlite3_file *pFile,
3960 sqlite3_file *pSubFile;
3961 sqlite3_vfs *pSubVfs;
3964 pSubVfs = ORIGVFS(pVfs);
3965 if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){
3966 return pSubVfs->xOpen(pSubVfs, zName, pFile, flags, pOutFlags);
3968 p = (ApndFile*)pFile;
3969 memset(p, 0, sizeof(*p));
3970 pSubFile = ORIGFILE(pFile);
3971 p->base.pMethods = &apnd_io_methods;
3972 rc = pSubVfs->xOpen(pSubVfs, zName, pSubFile, flags, pOutFlags);
3973 if( rc ) goto apnd_open_done;
3974 rc = pSubFile->pMethods->xFileSize(pSubFile, &sz);
3976 pSubFile->pMethods->xClose(pSubFile);
3977 goto apnd_open_done;
3979 if( apndIsOrdinaryDatabaseFile(sz, pSubFile) ){
3980 memmove(pFile, pSubFile, pSubVfs->szOsFile);
3984 p->iPgOne = apndReadMark(sz, pFile);
3988 if( (flags & SQLITE_OPEN_CREATE)==0 ){
3989 pSubFile->pMethods->xClose(pSubFile);
3990 rc = SQLITE_CANTOPEN;
3992 p->iPgOne = (sz+0xfff) & ~(sqlite3_int64)0xfff;
3994 if( rc ) pFile->pMethods = 0;
3999 ** All other VFS methods are pass-thrus.
4001 static int apndDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
4002 return ORIGVFS(pVfs)->xDelete(ORIGVFS(pVfs), zPath, dirSync);
4004 static int apndAccess(
4010 return ORIGVFS(pVfs)->xAccess(ORIGVFS(pVfs), zPath, flags, pResOut);
4012 static int apndFullPathname(
4018 return ORIGVFS(pVfs)->xFullPathname(ORIGVFS(pVfs),zPath,nOut,zOut);
4020 static void *apndDlOpen(sqlite3_vfs *pVfs, const char *zPath){
4021 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
4023 static void apndDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
4024 ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
4026 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
4027 return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym);
4029 static void apndDlClose(sqlite3_vfs *pVfs, void *pHandle){
4030 ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
4032 static int apndRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
4033 return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
4035 static int apndSleep(sqlite3_vfs *pVfs, int nMicro){
4036 return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
4038 static int apndCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
4039 return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
4041 static int apndGetLastError(sqlite3_vfs *pVfs, int a, char *b){
4042 return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
4044 static int apndCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
4045 return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
4047 static int apndSetSystemCall(
4050 sqlite3_syscall_ptr pCall
4052 return ORIGVFS(pVfs)->xSetSystemCall(ORIGVFS(pVfs),zName,pCall);
4054 static sqlite3_syscall_ptr apndGetSystemCall(
4058 return ORIGVFS(pVfs)->xGetSystemCall(ORIGVFS(pVfs),zName);
4060 static const char *apndNextSystemCall(sqlite3_vfs *pVfs, const char *zName){
4061 return ORIGVFS(pVfs)->xNextSystemCall(ORIGVFS(pVfs), zName);
4069 ** This routine is called when the extension is loaded.
4070 ** Register the new VFS.
4072 int sqlite3_appendvfs_init(
4075 const sqlite3_api_routines *pApi
4079 SQLITE_EXTENSION_INIT2(pApi);
4082 pOrig = sqlite3_vfs_find(0);
4083 apnd_vfs.iVersion = pOrig->iVersion;
4084 apnd_vfs.pAppData = pOrig;
4085 apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile);
4086 rc = sqlite3_vfs_register(&apnd_vfs, 0);
4087 #ifdef APPENDVFS_TEST
4088 if( rc==SQLITE_OK ){
4089 rc = sqlite3_auto_extension((void(*)(void))apndvfsRegister);
4092 if( rc==SQLITE_OK ) rc = SQLITE_OK_LOAD_PERMANENTLY;
4096 /************************* End ../ext/misc/appendvfs.c ********************/
4097 /************************* Begin ../ext/misc/memtrace.c ******************/
4101 ** The author disclaims copyright to this source code. In place of
4102 ** a legal notice, here is a blessing:
4104 ** May you do good and not evil.
4105 ** May you find forgiveness for yourself and forgive others.
4106 ** May you share freely, never taking more than you give.
4108 *************************************************************************
4110 ** This file implements an extension that uses the SQLITE_CONFIG_MALLOC
4111 ** mechanism to add a tracing layer on top of SQLite. If this extension
4112 ** is registered prior to sqlite3_initialize(), it will cause all memory
4113 ** allocation activities to be logged on standard output, or to some other
4114 ** FILE specified by the initializer.
4116 ** This file needs to be compiled into the application that uses it.
4118 ** This extension is used to implement the --memtrace option of the
4119 ** command-line shell.
4125 /* The original memory allocation routines */
4126 static sqlite3_mem_methods memtraceBase;
4127 static FILE *memtraceOut;
4129 /* Methods that trace memory allocations */
4130 static void *memtraceMalloc(int n){
4132 fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n",
4133 memtraceBase.xRoundup(n));
4135 return memtraceBase.xMalloc(n);
4137 static void memtraceFree(void *p){
4140 fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p));
4142 memtraceBase.xFree(p);
4144 static void *memtraceRealloc(void *p, int n){
4145 if( p==0 ) return memtraceMalloc(n);
4151 fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n",
4152 memtraceBase.xSize(p), memtraceBase.xRoundup(n));
4154 return memtraceBase.xRealloc(p, n);
4156 static int memtraceSize(void *p){
4157 return memtraceBase.xSize(p);
4159 static int memtraceRoundup(int n){
4160 return memtraceBase.xRoundup(n);
4162 static int memtraceInit(void *p){
4163 return memtraceBase.xInit(p);
4165 static void memtraceShutdown(void *p){
4166 memtraceBase.xShutdown(p);
4169 /* The substitute memory allocator */
4170 static sqlite3_mem_methods ersaztMethods = {
4181 /* Begin tracing memory allocations to out. */
4182 int sqlite3MemTraceActivate(FILE *out){
4184 if( memtraceBase.xMalloc==0 ){
4185 rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase);
4186 if( rc==SQLITE_OK ){
4187 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods);
4194 /* Deactivate memory tracing */
4195 int sqlite3MemTraceDeactivate(void){
4197 if( memtraceBase.xMalloc!=0 ){
4198 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase);
4199 if( rc==SQLITE_OK ){
4200 memset(&memtraceBase, 0, sizeof(memtraceBase));
4207 /************************* End ../ext/misc/memtrace.c ********************/
4208 #ifdef SQLITE_HAVE_ZLIB
4209 /************************* Begin ../ext/misc/zipfile.c ******************/
4213 ** The author disclaims copyright to this source code. In place of
4214 ** a legal notice, here is a blessing:
4216 ** May you do good and not evil.
4217 ** May you find forgiveness for yourself and forgive others.
4218 ** May you share freely, never taking more than you give.
4220 ******************************************************************************
4222 ** This file implements a virtual table for reading and writing ZIP archive
4227 ** SELECT name, sz, datetime(mtime,'unixepoch') FROM zipfile($filename);
4229 ** Current limitations:
4231 ** * No support for encryption
4232 ** * No support for ZIP archives spanning multiple files
4233 ** * No support for zip64 extensions
4234 ** * Only the "inflate/deflate" (zlib) compression method is supported
4236 /* #include "sqlite3ext.h" */
4237 SQLITE_EXTENSION_INIT1
4244 #ifndef SQLITE_OMIT_VIRTUALTABLE
4246 #ifndef SQLITE_AMALGAMATION
4248 /* typedef sqlite3_int64 i64; */
4249 /* typedef unsigned char u8; */
4250 typedef unsigned short u16;
4251 typedef unsigned long u32;
4252 #define MIN(a,b) ((a)<(b) ? (a) : (b))
4254 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
4255 # define ALWAYS(X) (1)
4256 # define NEVER(X) (0)
4257 #elif !defined(NDEBUG)
4258 # define ALWAYS(X) ((X)?1:(assert(0),0))
4259 # define NEVER(X) ((X)?(assert(0),1):0)
4261 # define ALWAYS(X) (X)
4262 # define NEVER(X) (X)
4265 #endif /* SQLITE_AMALGAMATION */
4268 ** Definitions for mode bitmasks S_IFDIR, S_IFREG and S_IFLNK.
4270 ** In some ways it would be better to obtain these values from system
4271 ** header files. But, the dependency is undesirable and (a) these
4272 ** have been stable for decades, (b) the values are part of POSIX and
4273 ** are also made explicit in [man stat], and (c) are part of the
4274 ** file format for zip archives.
4277 # define S_IFDIR 0040000
4280 # define S_IFREG 0100000
4283 # define S_IFLNK 0120000
4286 static const char ZIPFILE_SCHEMA[] =
4288 "name PRIMARY KEY," /* 0: Name of file in zip archive */
4289 "mode," /* 1: POSIX mode for file */
4290 "mtime," /* 2: Last modification time (secs since 1970)*/
4291 "sz," /* 3: Size of object */
4292 "rawdata," /* 4: Raw data */
4293 "data," /* 5: Uncompressed data */
4294 "method," /* 6: Compression method (integer) */
4295 "z HIDDEN" /* 7: Name of zip file */
4298 #define ZIPFILE_F_COLUMN_IDX 7 /* Index of column "file" in the above */
4299 #define ZIPFILE_BUFFER_SIZE (64*1024)
4303 ** Magic numbers used to read and write zip files.
4305 ** ZIPFILE_NEWENTRY_MADEBY:
4306 ** Use this value for the "version-made-by" field in new zip file
4307 ** entries. The upper byte indicates "unix", and the lower byte
4308 ** indicates that the zip file matches pkzip specification 3.0.
4309 ** This is what info-zip seems to do.
4311 ** ZIPFILE_NEWENTRY_REQUIRED:
4312 ** Value for "version-required-to-extract" field of new entries.
4313 ** Version 2.0 is required to support folders and deflate compression.
4315 ** ZIPFILE_NEWENTRY_FLAGS:
4316 ** Value for "general-purpose-bit-flags" field of new entries. Bit
4317 ** 11 means "utf-8 filename and comment".
4319 ** ZIPFILE_SIGNATURE_CDS:
4320 ** First 4 bytes of a valid CDS record.
4322 ** ZIPFILE_SIGNATURE_LFH:
4323 ** First 4 bytes of a valid LFH record.
4325 ** ZIPFILE_SIGNATURE_EOCD
4326 ** First 4 bytes of a valid EOCD record.
4328 #define ZIPFILE_EXTRA_TIMESTAMP 0x5455
4329 #define ZIPFILE_NEWENTRY_MADEBY ((3<<8) + 30)
4330 #define ZIPFILE_NEWENTRY_REQUIRED 20
4331 #define ZIPFILE_NEWENTRY_FLAGS 0x800
4332 #define ZIPFILE_SIGNATURE_CDS 0x02014b50
4333 #define ZIPFILE_SIGNATURE_LFH 0x04034b50
4334 #define ZIPFILE_SIGNATURE_EOCD 0x06054b50
4337 ** The sizes of the fixed-size part of each of the three main data
4338 ** structures in a zip archive.
4340 #define ZIPFILE_LFH_FIXED_SZ 30
4341 #define ZIPFILE_EOCD_FIXED_SZ 22
4342 #define ZIPFILE_CDS_FIXED_SZ 46
4345 *** 4.3.16 End of central directory record:
4347 *** end of central dir signature 4 bytes (0x06054b50)
4348 *** number of this disk 2 bytes
4349 *** number of the disk with the
4350 *** start of the central directory 2 bytes
4351 *** total number of entries in the
4352 *** central directory on this disk 2 bytes
4353 *** total number of entries in
4354 *** the central directory 2 bytes
4355 *** size of the central directory 4 bytes
4356 *** offset of start of central
4357 *** directory with respect to
4358 *** the starting disk number 4 bytes
4359 *** .ZIP file comment length 2 bytes
4360 *** .ZIP file comment (variable size)
4362 typedef struct ZipfileEOCD ZipfileEOCD;
4363 struct ZipfileEOCD {
4373 *** 4.3.12 Central directory structure:
4377 *** central file header signature 4 bytes (0x02014b50)
4378 *** version made by 2 bytes
4379 *** version needed to extract 2 bytes
4380 *** general purpose bit flag 2 bytes
4381 *** compression method 2 bytes
4382 *** last mod file time 2 bytes
4383 *** last mod file date 2 bytes
4385 *** compressed size 4 bytes
4386 *** uncompressed size 4 bytes
4387 *** file name length 2 bytes
4388 *** extra field length 2 bytes
4389 *** file comment length 2 bytes
4390 *** disk number start 2 bytes
4391 *** internal file attributes 2 bytes
4392 *** external file attributes 4 bytes
4393 *** relative offset of local header 4 bytes
4395 typedef struct ZipfileCDS ZipfileCDS;
4398 u16 iVersionExtract;
4413 char *zFile; /* Filename (sqlite3_malloc()) */
4417 *** 4.3.7 Local file header:
4419 *** local file header signature 4 bytes (0x04034b50)
4420 *** version needed to extract 2 bytes
4421 *** general purpose bit flag 2 bytes
4422 *** compression method 2 bytes
4423 *** last mod file time 2 bytes
4424 *** last mod file date 2 bytes
4426 *** compressed size 4 bytes
4427 *** uncompressed size 4 bytes
4428 *** file name length 2 bytes
4429 *** extra field length 2 bytes
4432 typedef struct ZipfileLFH ZipfileLFH;
4434 u16 iVersionExtract;
4446 typedef struct ZipfileEntry ZipfileEntry;
4447 struct ZipfileEntry {
4448 ZipfileCDS cds; /* Parsed CDS record */
4449 u32 mUnixTime; /* Modification time, in UNIX format */
4450 u8 *aExtra; /* cds.nExtra+cds.nComment bytes of extra data */
4451 i64 iDataOff; /* Offset to data in file (if aData==0) */
4452 u8 *aData; /* cds.szCompressed bytes of compressed data */
4453 ZipfileEntry *pNext; /* Next element in in-memory CDS */
4457 ** Cursor type for zipfile tables.
4459 typedef struct ZipfileCsr ZipfileCsr;
4461 sqlite3_vtab_cursor base; /* Base class - must be first */
4462 i64 iId; /* Cursor ID */
4463 u8 bEof; /* True when at EOF */
4464 u8 bNoop; /* If next xNext() call is no-op */
4466 /* Used outside of write transactions */
4467 FILE *pFile; /* Zip file */
4468 i64 iNextOff; /* Offset of next record in central directory */
4469 ZipfileEOCD eocd; /* Parse of central directory record */
4471 ZipfileEntry *pFreeEntry; /* Free this list when cursor is closed or reset */
4472 ZipfileEntry *pCurrent; /* Current entry */
4473 ZipfileCsr *pCsrNext; /* Next cursor on same virtual table */
4476 typedef struct ZipfileTab ZipfileTab;
4478 sqlite3_vtab base; /* Base class - must be first */
4479 char *zFile; /* Zip file this table accesses (may be NULL) */
4480 sqlite3 *db; /* Host database connection */
4481 u8 *aBuffer; /* Temporary buffer used for various tasks */
4483 ZipfileCsr *pCsrList; /* List of cursors */
4486 /* The following are used by write transactions only */
4487 ZipfileEntry *pFirstEntry; /* Linked list of all files (if pWriteFd!=0) */
4488 ZipfileEntry *pLastEntry; /* Last element in pFirstEntry list */
4489 FILE *pWriteFd; /* File handle open on zip archive */
4490 i64 szCurrent; /* Current size of zip archive */
4491 i64 szOrig; /* Size of archive at start of transaction */
4495 ** Set the error message contained in context ctx to the results of
4496 ** vprintf(zFmt, ...).
4498 static void zipfileCtxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){
4502 zMsg = sqlite3_vmprintf(zFmt, ap);
4503 sqlite3_result_error(ctx, zMsg, -1);
4509 ** If string zIn is quoted, dequote it in place. Otherwise, if the string
4510 ** is not quoted, do nothing.
4512 static void zipfileDequote(char *zIn){
4514 if( q=='"' || q=='\'' || q=='`' || q=='[' ){
4517 if( q=='[' ) q = ']';
4518 while( ALWAYS(zIn[iIn]) ){
4519 char c = zIn[iIn++];
4520 if( c==q && zIn[iIn++]!=q ) break;
4528 ** Construct a new ZipfileTab virtual table object.
4530 ** argv[0] -> module name ("zipfile")
4531 ** argv[1] -> database name
4532 ** argv[2] -> table name
4533 ** argv[...] -> "column name" and other module argument fields.
4535 static int zipfileConnect(
4538 int argc, const char *const*argv,
4539 sqlite3_vtab **ppVtab,
4542 int nByte = sizeof(ZipfileTab) + ZIPFILE_BUFFER_SIZE;
4544 const char *zFile = 0;
4545 ZipfileTab *pNew = 0;
4548 /* If the table name is not "zipfile", require that the argument be
4549 ** specified. This stops zipfile tables from being created as:
4551 ** CREATE VIRTUAL TABLE zzz USING zipfile();
4553 ** It does not prevent:
4555 ** CREATE VIRTUAL TABLE zipfile USING zipfile();
4557 assert( 0==sqlite3_stricmp(argv[0], "zipfile") );
4558 if( (0!=sqlite3_stricmp(argv[2], "zipfile") && argc<4) || argc>4 ){
4559 *pzErr = sqlite3_mprintf("zipfile constructor requires one argument");
4560 return SQLITE_ERROR;
4565 nFile = (int)strlen(zFile)+1;
4568 rc = sqlite3_declare_vtab(db, ZIPFILE_SCHEMA);
4569 if( rc==SQLITE_OK ){
4570 pNew = (ZipfileTab*)sqlite3_malloc64((sqlite3_int64)nByte+nFile);
4571 if( pNew==0 ) return SQLITE_NOMEM;
4572 memset(pNew, 0, nByte+nFile);
4574 pNew->aBuffer = (u8*)&pNew[1];
4576 pNew->zFile = (char*)&pNew->aBuffer[ZIPFILE_BUFFER_SIZE];
4577 memcpy(pNew->zFile, zFile, nFile);
4578 zipfileDequote(pNew->zFile);
4581 *ppVtab = (sqlite3_vtab*)pNew;
4586 ** Free the ZipfileEntry structure indicated by the only argument.
4588 static void zipfileEntryFree(ZipfileEntry *p){
4590 sqlite3_free(p->cds.zFile);
4596 ** Release resources that should be freed at the end of a write
4599 static void zipfileCleanupTransaction(ZipfileTab *pTab){
4600 ZipfileEntry *pEntry;
4601 ZipfileEntry *pNext;
4603 if( pTab->pWriteFd ){
4604 fclose(pTab->pWriteFd);
4607 for(pEntry=pTab->pFirstEntry; pEntry; pEntry=pNext){
4608 pNext = pEntry->pNext;
4609 zipfileEntryFree(pEntry);
4611 pTab->pFirstEntry = 0;
4612 pTab->pLastEntry = 0;
4613 pTab->szCurrent = 0;
4618 ** This method is the destructor for zipfile vtab objects.
4620 static int zipfileDisconnect(sqlite3_vtab *pVtab){
4621 zipfileCleanupTransaction((ZipfileTab*)pVtab);
4622 sqlite3_free(pVtab);
4627 ** Constructor for a new ZipfileCsr object.
4629 static int zipfileOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCsr){
4630 ZipfileTab *pTab = (ZipfileTab*)p;
4632 pCsr = sqlite3_malloc(sizeof(*pCsr));
4633 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
4635 return SQLITE_NOMEM;
4637 memset(pCsr, 0, sizeof(*pCsr));
4638 pCsr->iId = ++pTab->iNextCsrid;
4639 pCsr->pCsrNext = pTab->pCsrList;
4640 pTab->pCsrList = pCsr;
4645 ** Reset a cursor back to the state it was in when first returned
4646 ** by zipfileOpen().
4648 static void zipfileResetCursor(ZipfileCsr *pCsr){
4650 ZipfileEntry *pNext;
4654 fclose(pCsr->pFile);
4656 zipfileEntryFree(pCsr->pCurrent);
4660 for(p=pCsr->pFreeEntry; p; p=pNext){
4662 zipfileEntryFree(p);
4667 ** Destructor for an ZipfileCsr.
4669 static int zipfileClose(sqlite3_vtab_cursor *cur){
4670 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
4671 ZipfileTab *pTab = (ZipfileTab*)(pCsr->base.pVtab);
4673 zipfileResetCursor(pCsr);
4675 /* Remove this cursor from the ZipfileTab.pCsrList list. */
4676 for(pp=&pTab->pCsrList; *pp!=pCsr; pp=&((*pp)->pCsrNext));
4677 *pp = pCsr->pCsrNext;
4684 ** Set the error message for the virtual table associated with cursor
4685 ** pCsr to the results of vprintf(zFmt, ...).
4687 static void zipfileTableErr(ZipfileTab *pTab, const char *zFmt, ...){
4690 sqlite3_free(pTab->base.zErrMsg);
4691 pTab->base.zErrMsg = sqlite3_vmprintf(zFmt, ap);
4694 static void zipfileCursorErr(ZipfileCsr *pCsr, const char *zFmt, ...){
4697 sqlite3_free(pCsr->base.pVtab->zErrMsg);
4698 pCsr->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap);
4703 ** Read nRead bytes of data from offset iOff of file pFile into buffer
4704 ** aRead[]. Return SQLITE_OK if successful, or an SQLite error code
4707 ** If an error does occur, output variable (*pzErrmsg) may be set to point
4708 ** to an English language error message. It is the responsibility of the
4709 ** caller to eventually free this buffer using
4712 static int zipfileReadData(
4713 FILE *pFile, /* Read from this file */
4714 u8 *aRead, /* Read into this buffer */
4715 int nRead, /* Number of bytes to read */
4716 i64 iOff, /* Offset to read from */
4717 char **pzErrmsg /* OUT: Error message (from sqlite3_malloc) */
4720 fseek(pFile, (long)iOff, SEEK_SET);
4721 n = fread(aRead, 1, nRead, pFile);
4722 if( (int)n!=nRead ){
4723 *pzErrmsg = sqlite3_mprintf("error in fread()");
4724 return SQLITE_ERROR;
4729 static int zipfileAppendData(
4735 fseek(pTab->pWriteFd, (long)pTab->szCurrent, SEEK_SET);
4736 n = fwrite(aWrite, 1, nWrite, pTab->pWriteFd);
4737 if( (int)n!=nWrite ){
4738 pTab->base.zErrMsg = sqlite3_mprintf("error in fwrite()");
4739 return SQLITE_ERROR;
4741 pTab->szCurrent += nWrite;
4746 ** Read and return a 16-bit little-endian unsigned integer from buffer aBuf.
4748 static u16 zipfileGetU16(const u8 *aBuf){
4749 return (aBuf[1] << 8) + aBuf[0];
4753 ** Read and return a 32-bit little-endian unsigned integer from buffer aBuf.
4755 static u32 zipfileGetU32(const u8 *aBuf){
4756 return ((u32)(aBuf[3]) << 24)
4757 + ((u32)(aBuf[2]) << 16)
4758 + ((u32)(aBuf[1]) << 8)
4759 + ((u32)(aBuf[0]) << 0);
4763 ** Write a 16-bit little endiate integer into buffer aBuf.
4765 static void zipfilePutU16(u8 *aBuf, u16 val){
4766 aBuf[0] = val & 0xFF;
4767 aBuf[1] = (val>>8) & 0xFF;
4771 ** Write a 32-bit little endiate integer into buffer aBuf.
4773 static void zipfilePutU32(u8 *aBuf, u32 val){
4774 aBuf[0] = val & 0xFF;
4775 aBuf[1] = (val>>8) & 0xFF;
4776 aBuf[2] = (val>>16) & 0xFF;
4777 aBuf[3] = (val>>24) & 0xFF;
4780 #define zipfileRead32(aBuf) ( aBuf+=4, zipfileGetU32(aBuf-4) )
4781 #define zipfileRead16(aBuf) ( aBuf+=2, zipfileGetU16(aBuf-2) )
4783 #define zipfileWrite32(aBuf,val) { zipfilePutU32(aBuf,val); aBuf+=4; }
4784 #define zipfileWrite16(aBuf,val) { zipfilePutU16(aBuf,val); aBuf+=2; }
4787 ** Magic numbers used to read CDS records.
4789 #define ZIPFILE_CDS_NFILE_OFF 28
4790 #define ZIPFILE_CDS_SZCOMPRESSED_OFF 20
4793 ** Decode the CDS record in buffer aBuf into (*pCDS). Return SQLITE_ERROR
4794 ** if the record is not well-formed, or SQLITE_OK otherwise.
4796 static int zipfileReadCDS(u8 *aBuf, ZipfileCDS *pCDS){
4798 u32 sig = zipfileRead32(aRead);
4800 if( sig!=ZIPFILE_SIGNATURE_CDS ){
4803 pCDS->iVersionMadeBy = zipfileRead16(aRead);
4804 pCDS->iVersionExtract = zipfileRead16(aRead);
4805 pCDS->flags = zipfileRead16(aRead);
4806 pCDS->iCompression = zipfileRead16(aRead);
4807 pCDS->mTime = zipfileRead16(aRead);
4808 pCDS->mDate = zipfileRead16(aRead);
4809 pCDS->crc32 = zipfileRead32(aRead);
4810 pCDS->szCompressed = zipfileRead32(aRead);
4811 pCDS->szUncompressed = zipfileRead32(aRead);
4812 assert( aRead==&aBuf[ZIPFILE_CDS_NFILE_OFF] );
4813 pCDS->nFile = zipfileRead16(aRead);
4814 pCDS->nExtra = zipfileRead16(aRead);
4815 pCDS->nComment = zipfileRead16(aRead);
4816 pCDS->iDiskStart = zipfileRead16(aRead);
4817 pCDS->iInternalAttr = zipfileRead16(aRead);
4818 pCDS->iExternalAttr = zipfileRead32(aRead);
4819 pCDS->iOffset = zipfileRead32(aRead);
4820 assert( aRead==&aBuf[ZIPFILE_CDS_FIXED_SZ] );
4827 ** Decode the LFH record in buffer aBuf into (*pLFH). Return SQLITE_ERROR
4828 ** if the record is not well-formed, or SQLITE_OK otherwise.
4830 static int zipfileReadLFH(
4834 u8 *aRead = aBuffer;
4837 u32 sig = zipfileRead32(aRead);
4838 if( sig!=ZIPFILE_SIGNATURE_LFH ){
4841 pLFH->iVersionExtract = zipfileRead16(aRead);
4842 pLFH->flags = zipfileRead16(aRead);
4843 pLFH->iCompression = zipfileRead16(aRead);
4844 pLFH->mTime = zipfileRead16(aRead);
4845 pLFH->mDate = zipfileRead16(aRead);
4846 pLFH->crc32 = zipfileRead32(aRead);
4847 pLFH->szCompressed = zipfileRead32(aRead);
4848 pLFH->szUncompressed = zipfileRead32(aRead);
4849 pLFH->nFile = zipfileRead16(aRead);
4850 pLFH->nExtra = zipfileRead16(aRead);
4857 ** Buffer aExtra (size nExtra bytes) contains zip archive "extra" fields.
4858 ** Scan through this buffer to find an "extra-timestamp" field. If one
4859 ** exists, extract the 32-bit modification-timestamp from it and store
4860 ** the value in output parameter *pmTime.
4862 ** Zero is returned if no extra-timestamp record could be found (and so
4863 ** *pmTime is left unchanged), or non-zero otherwise.
4865 ** The general format of an extra field is:
4867 ** Header ID 2 bytes
4868 ** Data Size 2 bytes
4871 static int zipfileScanExtra(u8 *aExtra, int nExtra, u32 *pmTime){
4874 u8 *pEnd = &aExtra[nExtra];
4877 u16 id = zipfileRead16(p);
4878 u16 nByte = zipfileRead16(p);
4881 case ZIPFILE_EXTRA_TIMESTAMP: {
4883 if( b & 0x01 ){ /* 0x01 -> modtime is present */
4884 *pmTime = zipfileGetU32(&p[1]);
4897 ** Convert the standard MS-DOS timestamp stored in the mTime and mDate
4898 ** fields of the CDS structure passed as the only argument to a 32-bit
4899 ** UNIX seconds-since-the-epoch timestamp. Return the result.
4901 ** "Standard" MS-DOS time format:
4903 ** File modification time:
4904 ** Bits 00-04: seconds divided by 2
4905 ** Bits 05-10: minute
4907 ** File modification date:
4909 ** Bits 05-08: month (1-12)
4910 ** Bits 09-15: years from 1980
4912 ** https://msdn.microsoft.com/en-us/library/9kkf9tah.aspx
4914 static u32 zipfileMtime(ZipfileCDS *pCDS){
4915 int Y = (1980 + ((pCDS->mDate >> 9) & 0x7F));
4916 int M = ((pCDS->mDate >> 5) & 0x0F);
4917 int D = (pCDS->mDate & 0x1F);
4920 int sec = (pCDS->mTime & 0x1F)*2;
4921 int min = (pCDS->mTime >> 5) & 0x3F;
4922 int hr = (pCDS->mTime >> 11) & 0x1F;
4925 /* JD = INT(365.25 * (Y+4716)) + INT(30.6001 * (M+1)) + D + B - 1524.5 */
4927 /* Calculate the JD in seconds for noon on the day in question */
4932 JD = (i64)(24*60*60) * (
4933 (int)(365.25 * (Y + 4716))
4934 + (int)(30.6001 * (M + 1))
4938 /* Correct the JD for the time within the day */
4939 JD += (hr-12) * 3600 + min * 60 + sec;
4941 /* Convert JD to unix timestamp (the JD epoch is 2440587.5) */
4942 return (u32)(JD - (i64)(24405875) * 24*60*6);
4946 ** The opposite of zipfileMtime(). This function populates the mTime and
4947 ** mDate fields of the CDS structure passed as the first argument according
4948 ** to the UNIX timestamp value passed as the second.
4950 static void zipfileMtimeToDos(ZipfileCDS *pCds, u32 mUnixTime){
4951 /* Convert unix timestamp to JD (2440588 is noon on 1/1/1970) */
4952 i64 JD = (i64)2440588 + mUnixTime / (24*60*60);
4958 A = (int)((JD - 1867216.25)/36524.25);
4959 A = (int)(JD + 1 + A - (A/4));
4961 C = (int)((B - 122.1)/365.25);
4962 D = (36525*(C&32767))/100;
4963 E = (int)((B-D)/30.6001);
4965 day = B - D - (int)(30.6001*E);
4966 mon = (E<14 ? E-1 : E-13);
4967 yr = mon>2 ? C-4716 : C-4715;
4969 hr = (mUnixTime % (24*60*60)) / (60*60);
4970 min = (mUnixTime % (60*60)) / 60;
4971 sec = (mUnixTime % 60);
4974 pCds->mDate = (u16)(day + (mon << 5) + ((yr-1980) << 9));
4975 pCds->mTime = (u16)(sec/2 + (min<<5) + (hr<<11));
4977 pCds->mDate = pCds->mTime = 0;
4980 assert( mUnixTime<315507600
4981 || mUnixTime==zipfileMtime(pCds)
4982 || ((mUnixTime % 2) && mUnixTime-1==zipfileMtime(pCds))
4983 /* || (mUnixTime % 2) */
4988 ** If aBlob is not NULL, then it is a pointer to a buffer (nBlob bytes in
4989 ** size) containing an entire zip archive image. Or, if aBlob is NULL,
4990 ** then pFile is a file-handle open on a zip file. In either case, this
4991 ** function creates a ZipfileEntry object based on the zip archive entry
4992 ** for which the CDS record is at offset iOff.
4994 ** If successful, SQLITE_OK is returned and (*ppEntry) set to point to
4995 ** the new object. Otherwise, an SQLite error code is returned and the
4996 ** final value of (*ppEntry) undefined.
4998 static int zipfileGetEntry(
4999 ZipfileTab *pTab, /* Store any error message here */
5000 const u8 *aBlob, /* Pointer to in-memory file image */
5001 int nBlob, /* Size of aBlob[] in bytes */
5002 FILE *pFile, /* If aBlob==0, read from this file */
5003 i64 iOff, /* Offset of CDS record */
5004 ZipfileEntry **ppEntry /* OUT: Pointer to new object */
5007 char **pzErr = &pTab->base.zErrMsg;
5011 aRead = pTab->aBuffer;
5012 rc = zipfileReadData(pFile, aRead, ZIPFILE_CDS_FIXED_SZ, iOff, pzErr);
5014 aRead = (u8*)&aBlob[iOff];
5017 if( rc==SQLITE_OK ){
5018 sqlite3_int64 nAlloc;
5021 int nFile = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF]);
5022 int nExtra = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+2]);
5023 nExtra += zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+4]);
5025 nAlloc = sizeof(ZipfileEntry) + nExtra;
5027 nAlloc += zipfileGetU32(&aRead[ZIPFILE_CDS_SZCOMPRESSED_OFF]);
5030 pNew = (ZipfileEntry*)sqlite3_malloc64(nAlloc);
5034 memset(pNew, 0, sizeof(ZipfileEntry));
5035 rc = zipfileReadCDS(aRead, &pNew->cds);
5036 if( rc!=SQLITE_OK ){
5037 *pzErr = sqlite3_mprintf("failed to read CDS at offset %lld", iOff);
5038 }else if( aBlob==0 ){
5039 rc = zipfileReadData(
5040 pFile, aRead, nExtra+nFile, iOff+ZIPFILE_CDS_FIXED_SZ, pzErr
5043 aRead = (u8*)&aBlob[iOff + ZIPFILE_CDS_FIXED_SZ];
5047 if( rc==SQLITE_OK ){
5048 u32 *pt = &pNew->mUnixTime;
5049 pNew->cds.zFile = sqlite3_mprintf("%.*s", nFile, aRead);
5050 pNew->aExtra = (u8*)&pNew[1];
5051 memcpy(pNew->aExtra, &aRead[nFile], nExtra);
5052 if( pNew->cds.zFile==0 ){
5054 }else if( 0==zipfileScanExtra(&aRead[nFile], pNew->cds.nExtra, pt) ){
5055 pNew->mUnixTime = zipfileMtime(&pNew->cds);
5059 if( rc==SQLITE_OK ){
5060 static const int szFix = ZIPFILE_LFH_FIXED_SZ;
5063 rc = zipfileReadData(pFile, aRead, szFix, pNew->cds.iOffset, pzErr);
5065 aRead = (u8*)&aBlob[pNew->cds.iOffset];
5068 rc = zipfileReadLFH(aRead, &lfh);
5069 if( rc==SQLITE_OK ){
5070 pNew->iDataOff = pNew->cds.iOffset + ZIPFILE_LFH_FIXED_SZ;
5071 pNew->iDataOff += lfh.nFile + lfh.nExtra;
5072 if( aBlob && pNew->cds.szCompressed ){
5073 pNew->aData = &pNew->aExtra[nExtra];
5074 memcpy(pNew->aData, &aBlob[pNew->iDataOff], pNew->cds.szCompressed);
5077 *pzErr = sqlite3_mprintf("failed to read LFH at offset %d",
5078 (int)pNew->cds.iOffset
5083 if( rc!=SQLITE_OK ){
5084 zipfileEntryFree(pNew);
5094 ** Advance an ZipfileCsr to its next row of output.
5096 static int zipfileNext(sqlite3_vtab_cursor *cur){
5097 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5101 i64 iEof = pCsr->eocd.iOffset + pCsr->eocd.nSize;
5102 zipfileEntryFree(pCsr->pCurrent);
5104 if( pCsr->iNextOff>=iEof ){
5107 ZipfileEntry *p = 0;
5108 ZipfileTab *pTab = (ZipfileTab*)(cur->pVtab);
5109 rc = zipfileGetEntry(pTab, 0, 0, pCsr->pFile, pCsr->iNextOff, &p);
5110 if( rc==SQLITE_OK ){
5111 pCsr->iNextOff += ZIPFILE_CDS_FIXED_SZ;
5112 pCsr->iNextOff += (int)p->cds.nExtra + p->cds.nFile + p->cds.nComment;
5118 pCsr->pCurrent = pCsr->pCurrent->pNext;
5120 if( pCsr->pCurrent==0 ){
5129 static void zipfileFree(void *p) {
5134 ** Buffer aIn (size nIn bytes) contains compressed data. Uncompressed, the
5135 ** size is nOut bytes. This function uncompresses the data and sets the
5136 ** return value in context pCtx to the result (a blob).
5138 ** If an error occurs, an error code is left in pCtx instead.
5140 static void zipfileInflate(
5141 sqlite3_context *pCtx, /* Store result here */
5142 const u8 *aIn, /* Compressed data */
5143 int nIn, /* Size of buffer aIn[] in bytes */
5144 int nOut /* Expected output size */
5146 u8 *aRes = sqlite3_malloc(nOut);
5148 sqlite3_result_error_nomem(pCtx);
5152 memset(&str, 0, sizeof(str));
5154 str.next_in = (Byte*)aIn;
5156 str.next_out = (Byte*)aRes;
5157 str.avail_out = nOut;
5159 err = inflateInit2(&str, -15);
5161 zipfileCtxErrorMsg(pCtx, "inflateInit2() failed (%d)", err);
5163 err = inflate(&str, Z_NO_FLUSH);
5164 if( err!=Z_STREAM_END ){
5165 zipfileCtxErrorMsg(pCtx, "inflate() failed (%d)", err);
5167 sqlite3_result_blob(pCtx, aRes, nOut, zipfileFree);
5177 ** Buffer aIn (size nIn bytes) contains uncompressed data. This function
5178 ** compresses it and sets (*ppOut) to point to a buffer containing the
5179 ** compressed data. The caller is responsible for eventually calling
5180 ** sqlite3_free() to release buffer (*ppOut). Before returning, (*pnOut)
5181 ** is set to the size of buffer (*ppOut) in bytes.
5183 ** If no error occurs, SQLITE_OK is returned. Otherwise, an SQLite error
5184 ** code is returned and an error message left in virtual-table handle
5185 ** pTab. The values of (*ppOut) and (*pnOut) are left unchanged in this
5188 static int zipfileDeflate(
5189 const u8 *aIn, int nIn, /* Input */
5190 u8 **ppOut, int *pnOut, /* Output */
5191 char **pzErr /* OUT: Error message */
5193 sqlite3_int64 nAlloc = compressBound(nIn);
5197 aOut = (u8*)sqlite3_malloc64(nAlloc);
5203 memset(&str, 0, sizeof(str));
5204 str.next_in = (Bytef*)aIn;
5206 str.next_out = aOut;
5207 str.avail_out = nAlloc;
5209 deflateInit2(&str, 9, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
5210 res = deflate(&str, Z_FINISH);
5212 if( res==Z_STREAM_END ){
5214 *pnOut = (int)str.total_out;
5217 *pzErr = sqlite3_mprintf("zipfile: deflate() error");
5228 ** Return values of columns for the row at which the series_cursor
5229 ** is currently pointing.
5231 static int zipfileColumn(
5232 sqlite3_vtab_cursor *cur, /* The cursor */
5233 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
5234 int i /* Which column to return */
5236 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5237 ZipfileCDS *pCDS = &pCsr->pCurrent->cds;
5241 sqlite3_result_text(ctx, pCDS->zFile, -1, SQLITE_TRANSIENT);
5244 /* TODO: Whether or not the following is correct surely depends on
5245 ** the platform on which the archive was created. */
5246 sqlite3_result_int(ctx, pCDS->iExternalAttr >> 16);
5248 case 2: { /* mtime */
5249 sqlite3_result_int64(ctx, pCsr->pCurrent->mUnixTime);
5253 if( sqlite3_vtab_nochange(ctx)==0 ){
5254 sqlite3_result_int64(ctx, pCDS->szUncompressed);
5258 case 4: /* rawdata */
5259 if( sqlite3_vtab_nochange(ctx) ) break;
5260 case 5: { /* data */
5261 if( i==4 || pCDS->iCompression==0 || pCDS->iCompression==8 ){
5262 int sz = pCDS->szCompressed;
5263 int szFinal = pCDS->szUncompressed;
5267 if( pCsr->pCurrent->aData ){
5268 aBuf = pCsr->pCurrent->aData;
5270 aBuf = aFree = sqlite3_malloc64(sz);
5274 FILE *pFile = pCsr->pFile;
5276 pFile = ((ZipfileTab*)(pCsr->base.pVtab))->pWriteFd;
5278 rc = zipfileReadData(pFile, aBuf, sz, pCsr->pCurrent->iDataOff,
5279 &pCsr->base.pVtab->zErrMsg
5283 if( rc==SQLITE_OK ){
5284 if( i==5 && pCDS->iCompression ){
5285 zipfileInflate(ctx, aBuf, sz, szFinal);
5287 sqlite3_result_blob(ctx, aBuf, sz, SQLITE_TRANSIENT);
5290 sqlite3_free(aFree);
5292 /* Figure out if this is a directory or a zero-sized file. Consider
5293 ** it to be a directory either if the mode suggests so, or if
5294 ** the final character in the name is '/'. */
5295 u32 mode = pCDS->iExternalAttr >> 16;
5296 if( !(mode & S_IFDIR) && pCDS->zFile[pCDS->nFile-1]!='/' ){
5297 sqlite3_result_blob(ctx, "", 0, SQLITE_STATIC);
5303 case 6: /* method */
5304 sqlite3_result_int(ctx, pCDS->iCompression);
5308 sqlite3_result_int64(ctx, pCsr->iId);
5316 ** Return TRUE if the cursor is at EOF.
5318 static int zipfileEof(sqlite3_vtab_cursor *cur){
5319 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5324 ** If aBlob is not NULL, then it points to a buffer nBlob bytes in size
5325 ** containing an entire zip archive image. Or, if aBlob is NULL, then pFile
5326 ** is guaranteed to be a file-handle open on a zip file.
5328 ** This function attempts to locate the EOCD record within the zip archive
5329 ** and populate *pEOCD with the results of decoding it. SQLITE_OK is
5330 ** returned if successful. Otherwise, an SQLite error code is returned and
5331 ** an English language error message may be left in virtual-table pTab.
5333 static int zipfileReadEOCD(
5334 ZipfileTab *pTab, /* Return errors here */
5335 const u8 *aBlob, /* Pointer to in-memory file image */
5336 int nBlob, /* Size of aBlob[] in bytes */
5337 FILE *pFile, /* Read from this file if aBlob==0 */
5338 ZipfileEOCD *pEOCD /* Object to populate */
5340 u8 *aRead = pTab->aBuffer; /* Temporary buffer */
5341 int nRead; /* Bytes to read from file */
5345 i64 iOff; /* Offset to read from */
5346 i64 szFile; /* Total size of file in bytes */
5347 fseek(pFile, 0, SEEK_END);
5348 szFile = (i64)ftell(pFile);
5350 memset(pEOCD, 0, sizeof(ZipfileEOCD));
5353 nRead = (int)(MIN(szFile, ZIPFILE_BUFFER_SIZE));
5354 iOff = szFile - nRead;
5355 rc = zipfileReadData(pFile, aRead, nRead, iOff, &pTab->base.zErrMsg);
5357 nRead = (int)(MIN(nBlob, ZIPFILE_BUFFER_SIZE));
5358 aRead = (u8*)&aBlob[nBlob-nRead];
5361 if( rc==SQLITE_OK ){
5364 /* Scan backwards looking for the signature bytes */
5365 for(i=nRead-20; i>=0; i--){
5366 if( aRead[i]==0x50 && aRead[i+1]==0x4b
5367 && aRead[i+2]==0x05 && aRead[i+3]==0x06
5373 pTab->base.zErrMsg = sqlite3_mprintf(
5374 "cannot find end of central directory record"
5376 return SQLITE_ERROR;
5380 pEOCD->iDisk = zipfileRead16(aRead);
5381 pEOCD->iFirstDisk = zipfileRead16(aRead);
5382 pEOCD->nEntry = zipfileRead16(aRead);
5383 pEOCD->nEntryTotal = zipfileRead16(aRead);
5384 pEOCD->nSize = zipfileRead32(aRead);
5385 pEOCD->iOffset = zipfileRead32(aRead);
5392 ** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry
5393 ** and ends with pLastEntry. If argument pBefore is NULL, then pNew is added
5394 ** to the end of the list. Otherwise, it is added to the list immediately
5395 ** before pBefore (which is guaranteed to be a part of said list).
5397 static void zipfileAddEntry(
5399 ZipfileEntry *pBefore,
5402 assert( (pTab->pFirstEntry==0)==(pTab->pLastEntry==0) );
5403 assert( pNew->pNext==0 );
5405 if( pTab->pFirstEntry==0 ){
5406 pTab->pFirstEntry = pTab->pLastEntry = pNew;
5408 assert( pTab->pLastEntry->pNext==0 );
5409 pTab->pLastEntry->pNext = pNew;
5410 pTab->pLastEntry = pNew;
5414 for(pp=&pTab->pFirstEntry; *pp!=pBefore; pp=&((*pp)->pNext));
5415 pNew->pNext = pBefore;
5420 static int zipfileLoadDirectory(ZipfileTab *pTab, const u8 *aBlob, int nBlob){
5426 rc = zipfileReadEOCD(pTab, aBlob, nBlob, pTab->pWriteFd, &eocd);
5427 iOff = eocd.iOffset;
5428 for(i=0; rc==SQLITE_OK && i<eocd.nEntry; i++){
5429 ZipfileEntry *pNew = 0;
5430 rc = zipfileGetEntry(pTab, aBlob, nBlob, pTab->pWriteFd, iOff, &pNew);
5432 if( rc==SQLITE_OK ){
5433 zipfileAddEntry(pTab, 0, pNew);
5434 iOff += ZIPFILE_CDS_FIXED_SZ;
5435 iOff += (int)pNew->cds.nExtra + pNew->cds.nFile + pNew->cds.nComment;
5442 ** xFilter callback.
5444 static int zipfileFilter(
5445 sqlite3_vtab_cursor *cur,
5446 int idxNum, const char *idxStr,
5447 int argc, sqlite3_value **argv
5449 ZipfileTab *pTab = (ZipfileTab*)cur->pVtab;
5450 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5451 const char *zFile = 0; /* Zip file to scan */
5452 int rc = SQLITE_OK; /* Return Code */
5453 int bInMemory = 0; /* True for an in-memory zipfile */
5455 zipfileResetCursor(pCsr);
5458 zFile = pTab->zFile;
5459 }else if( idxNum==0 ){
5460 zipfileCursorErr(pCsr, "zipfile() function requires an argument");
5461 return SQLITE_ERROR;
5462 }else if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){
5463 const u8 *aBlob = (const u8*)sqlite3_value_blob(argv[0]);
5464 int nBlob = sqlite3_value_bytes(argv[0]);
5465 assert( pTab->pFirstEntry==0 );
5466 rc = zipfileLoadDirectory(pTab, aBlob, nBlob);
5467 pCsr->pFreeEntry = pTab->pFirstEntry;
5468 pTab->pFirstEntry = pTab->pLastEntry = 0;
5469 if( rc!=SQLITE_OK ) return rc;
5472 zFile = (const char*)sqlite3_value_text(argv[0]);
5475 if( 0==pTab->pWriteFd && 0==bInMemory ){
5476 pCsr->pFile = fopen(zFile, "rb");
5477 if( pCsr->pFile==0 ){
5478 zipfileCursorErr(pCsr, "cannot open file: %s", zFile);
5481 rc = zipfileReadEOCD(pTab, 0, 0, pCsr->pFile, &pCsr->eocd);
5482 if( rc==SQLITE_OK ){
5483 if( pCsr->eocd.nEntry==0 ){
5486 pCsr->iNextOff = pCsr->eocd.iOffset;
5487 rc = zipfileNext(cur);
5493 pCsr->pCurrent = pCsr->pFreeEntry ? pCsr->pFreeEntry : pTab->pFirstEntry;
5494 rc = zipfileNext(cur);
5501 ** xBestIndex callback.
5503 static int zipfileBestIndex(
5505 sqlite3_index_info *pIdxInfo
5511 for(i=0; i<pIdxInfo->nConstraint; i++){
5512 const struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i];
5513 if( pCons->iColumn!=ZIPFILE_F_COLUMN_IDX ) continue;
5514 if( pCons->usable==0 ){
5516 }else if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){
5521 pIdxInfo->aConstraintUsage[idx].argvIndex = 1;
5522 pIdxInfo->aConstraintUsage[idx].omit = 1;
5523 pIdxInfo->estimatedCost = 1000.0;
5524 pIdxInfo->idxNum = 1;
5525 }else if( unusable ){
5526 return SQLITE_CONSTRAINT;
5531 static ZipfileEntry *zipfileNewEntry(const char *zPath){
5533 pNew = sqlite3_malloc(sizeof(ZipfileEntry));
5535 memset(pNew, 0, sizeof(ZipfileEntry));
5536 pNew->cds.zFile = sqlite3_mprintf("%s", zPath);
5537 if( pNew->cds.zFile==0 ){
5545 static int zipfileSerializeLFH(ZipfileEntry *pEntry, u8 *aBuf){
5546 ZipfileCDS *pCds = &pEntry->cds;
5551 /* Write the LFH itself */
5552 zipfileWrite32(a, ZIPFILE_SIGNATURE_LFH);
5553 zipfileWrite16(a, pCds->iVersionExtract);
5554 zipfileWrite16(a, pCds->flags);
5555 zipfileWrite16(a, pCds->iCompression);
5556 zipfileWrite16(a, pCds->mTime);
5557 zipfileWrite16(a, pCds->mDate);
5558 zipfileWrite32(a, pCds->crc32);
5559 zipfileWrite32(a, pCds->szCompressed);
5560 zipfileWrite32(a, pCds->szUncompressed);
5561 zipfileWrite16(a, (u16)pCds->nFile);
5562 zipfileWrite16(a, pCds->nExtra);
5563 assert( a==&aBuf[ZIPFILE_LFH_FIXED_SZ] );
5565 /* Add the file name */
5566 memcpy(a, pCds->zFile, (int)pCds->nFile);
5567 a += (int)pCds->nFile;
5569 /* The "extra" data */
5570 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP);
5571 zipfileWrite16(a, 5);
5573 zipfileWrite32(a, pEntry->mUnixTime);
5578 static int zipfileAppendEntry(
5580 ZipfileEntry *pEntry,
5584 u8 *aBuf = pTab->aBuffer;
5588 nBuf = zipfileSerializeLFH(pEntry, aBuf);
5589 rc = zipfileAppendData(pTab, aBuf, nBuf);
5590 if( rc==SQLITE_OK ){
5591 pEntry->iDataOff = pTab->szCurrent;
5592 rc = zipfileAppendData(pTab, pData, nData);
5598 static int zipfileGetMode(
5599 sqlite3_value *pVal,
5600 int bIsDir, /* If true, default to directory */
5601 u32 *pMode, /* OUT: Mode value */
5602 char **pzErr /* OUT: Error message */
5604 const char *z = (const char*)sqlite3_value_text(pVal);
5607 mode = (bIsDir ? (S_IFDIR + 0755) : (S_IFREG + 0644));
5608 }else if( z[0]>='0' && z[0]<='9' ){
5609 mode = (unsigned int)sqlite3_value_int(pVal);
5611 const char zTemplate[11] = "-rwxrwxrwx";
5613 if( strlen(z)!=10 ) goto parse_error;
5615 case '-': mode |= S_IFREG; break;
5616 case 'd': mode |= S_IFDIR; break;
5617 case 'l': mode |= S_IFLNK; break;
5618 default: goto parse_error;
5620 for(i=1; i<10; i++){
5621 if( z[i]==zTemplate[i] ) mode |= 1 << (9-i);
5622 else if( z[i]!='-' ) goto parse_error;
5625 if( ((mode & S_IFDIR)==0)==bIsDir ){
5626 /* The "mode" attribute is a directory, but data has been specified.
5627 ** Or vice-versa - no data but "mode" is a file or symlink. */
5628 *pzErr = sqlite3_mprintf("zipfile: mode does not match data");
5629 return SQLITE_CONSTRAINT;
5635 *pzErr = sqlite3_mprintf("zipfile: parse error in mode: %s", z);
5636 return SQLITE_ERROR;
5640 ** Both (const char*) arguments point to nul-terminated strings. Argument
5641 ** nB is the value of strlen(zB). This function returns 0 if the strings are
5642 ** identical, ignoring any trailing '/' character in either path. */
5643 static int zipfileComparePath(const char *zA, const char *zB, int nB){
5644 int nA = (int)strlen(zA);
5645 if( zA[nA-1]=='/' ) nA--;
5646 if( zB[nB-1]=='/' ) nB--;
5647 if( nA==nB && memcmp(zA, zB, nA)==0 ) return 0;
5651 static int zipfileBegin(sqlite3_vtab *pVtab){
5652 ZipfileTab *pTab = (ZipfileTab*)pVtab;
5655 assert( pTab->pWriteFd==0 );
5657 /* Open a write fd on the file. Also load the entire central directory
5658 ** structure into memory. During the transaction any new file data is
5659 ** appended to the archive file, but the central directory is accumulated
5660 ** in main-memory until the transaction is committed. */
5661 pTab->pWriteFd = fopen(pTab->zFile, "ab+");
5662 if( pTab->pWriteFd==0 ){
5663 pTab->base.zErrMsg = sqlite3_mprintf(
5664 "zipfile: failed to open file %s for writing", pTab->zFile
5668 fseek(pTab->pWriteFd, 0, SEEK_END);
5669 pTab->szCurrent = pTab->szOrig = (i64)ftell(pTab->pWriteFd);
5670 rc = zipfileLoadDirectory(pTab, 0, 0);
5673 if( rc!=SQLITE_OK ){
5674 zipfileCleanupTransaction(pTab);
5681 ** Return the current time as a 32-bit timestamp in UNIX epoch format (like
5684 static u32 zipfileTime(void){
5685 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
5687 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
5689 pVfs->xCurrentTimeInt64(pVfs, &ms);
5690 ret = (u32)((ms/1000) - ((i64)24405875 * 8640));
5693 pVfs->xCurrentTime(pVfs, &day);
5694 ret = (u32)((day - 2440587.5) * 86400);
5700 ** Return a 32-bit timestamp in UNIX epoch format.
5702 ** If the value passed as the only argument is either NULL or an SQL NULL,
5703 ** return the current time. Otherwise, return the value stored in (*pVal)
5704 ** cast to a 32-bit unsigned integer.
5706 static u32 zipfileGetTime(sqlite3_value *pVal){
5707 if( pVal==0 || sqlite3_value_type(pVal)==SQLITE_NULL ){
5708 return zipfileTime();
5710 return (u32)sqlite3_value_int64(pVal);
5714 ** Unless it is NULL, entry pOld is currently part of the pTab->pFirstEntry
5715 ** linked list. Remove it from the list and free the object.
5717 static void zipfileRemoveEntryFromList(ZipfileTab *pTab, ZipfileEntry *pOld){
5720 for(pp=&pTab->pFirstEntry; (*pp)!=pOld; pp=&((*pp)->pNext));
5722 zipfileEntryFree(pOld);
5729 static int zipfileUpdate(
5730 sqlite3_vtab *pVtab,
5732 sqlite3_value **apVal,
5733 sqlite_int64 *pRowid
5735 ZipfileTab *pTab = (ZipfileTab*)pVtab;
5736 int rc = SQLITE_OK; /* Return Code */
5737 ZipfileEntry *pNew = 0; /* New in-memory CDS entry */
5739 u32 mode = 0; /* Mode for new entry */
5740 u32 mTime = 0; /* Modification time for new entry */
5741 i64 sz = 0; /* Uncompressed size */
5742 const char *zPath = 0; /* Path for new entry */
5743 int nPath = 0; /* strlen(zPath) */
5744 const u8 *pData = 0; /* Pointer to buffer containing content */
5745 int nData = 0; /* Size of pData buffer in bytes */
5746 int iMethod = 0; /* Compression method for new entry */
5747 u8 *pFree = 0; /* Free this */
5748 char *zFree = 0; /* Also free this */
5749 ZipfileEntry *pOld = 0;
5750 ZipfileEntry *pOld2 = 0;
5751 int bUpdate = 0; /* True for an update that modifies "name" */
5755 if( pTab->pWriteFd==0 ){
5756 rc = zipfileBegin(pVtab);
5757 if( rc!=SQLITE_OK ) return rc;
5760 /* If this is a DELETE or UPDATE, find the archive entry to delete. */
5761 if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){
5762 const char *zDelete = (const char*)sqlite3_value_text(apVal[0]);
5763 int nDelete = (int)strlen(zDelete);
5765 const char *zUpdate = (const char*)sqlite3_value_text(apVal[1]);
5766 if( zUpdate && zipfileComparePath(zUpdate, zDelete, nDelete)!=0 ){
5770 for(pOld=pTab->pFirstEntry; 1; pOld=pOld->pNext){
5771 if( zipfileComparePath(pOld->cds.zFile, zDelete, nDelete)==0 ){
5774 assert( pOld->pNext );
5779 /* Check that "sz" and "rawdata" are both NULL: */
5780 if( sqlite3_value_type(apVal[5])!=SQLITE_NULL ){
5781 zipfileTableErr(pTab, "sz must be NULL");
5782 rc = SQLITE_CONSTRAINT;
5784 if( sqlite3_value_type(apVal[6])!=SQLITE_NULL ){
5785 zipfileTableErr(pTab, "rawdata must be NULL");
5786 rc = SQLITE_CONSTRAINT;
5789 if( rc==SQLITE_OK ){
5790 if( sqlite3_value_type(apVal[7])==SQLITE_NULL ){
5791 /* data=NULL. A directory */
5794 /* Value specified for "data", and possibly "method". This must be
5795 ** a regular file or a symlink. */
5796 const u8 *aIn = sqlite3_value_blob(apVal[7]);
5797 int nIn = sqlite3_value_bytes(apVal[7]);
5798 int bAuto = sqlite3_value_type(apVal[8])==SQLITE_NULL;
5800 iMethod = sqlite3_value_int(apVal[8]);
5804 if( iMethod!=0 && iMethod!=8 ){
5805 zipfileTableErr(pTab, "unknown compression method: %d", iMethod);
5806 rc = SQLITE_CONSTRAINT;
5808 if( bAuto || iMethod ){
5810 rc = zipfileDeflate(aIn, nIn, &pFree, &nCmp, &pTab->base.zErrMsg);
5811 if( rc==SQLITE_OK ){
5812 if( iMethod || nCmp<nIn ){
5819 iCrc32 = crc32(0, aIn, nIn);
5824 if( rc==SQLITE_OK ){
5825 rc = zipfileGetMode(apVal[3], bIsDir, &mode, &pTab->base.zErrMsg);
5828 if( rc==SQLITE_OK ){
5829 zPath = (const char*)sqlite3_value_text(apVal[2]);
5830 nPath = (int)strlen(zPath);
5831 mTime = zipfileGetTime(apVal[4]);
5834 if( rc==SQLITE_OK && bIsDir ){
5835 /* For a directory, check that the last character in the path is a
5836 ** '/'. This appears to be required for compatibility with info-zip
5837 ** (the unzip command on unix). It does not create directories
5839 if( zPath[nPath-1]!='/' ){
5840 zFree = sqlite3_mprintf("%s/", zPath);
5841 if( zFree==0 ){ rc = SQLITE_NOMEM; }
5842 zPath = (const char*)zFree;
5847 /* Check that we're not inserting a duplicate entry -OR- updating an
5848 ** entry with a path, thereby making it into a duplicate. */
5849 if( (pOld==0 || bUpdate) && rc==SQLITE_OK ){
5851 for(p=pTab->pFirstEntry; p; p=p->pNext){
5852 if( zipfileComparePath(p->cds.zFile, zPath, nPath)==0 ){
5853 switch( sqlite3_vtab_on_conflict(pTab->db) ){
5854 case SQLITE_IGNORE: {
5855 goto zipfile_update_done;
5857 case SQLITE_REPLACE: {
5862 zipfileTableErr(pTab, "duplicate name: \"%s\"", zPath);
5863 rc = SQLITE_CONSTRAINT;
5872 if( rc==SQLITE_OK ){
5873 /* Create the new CDS record. */
5874 pNew = zipfileNewEntry(zPath);
5878 pNew->cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY;
5879 pNew->cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED;
5880 pNew->cds.flags = ZIPFILE_NEWENTRY_FLAGS;
5881 pNew->cds.iCompression = (u16)iMethod;
5882 zipfileMtimeToDos(&pNew->cds, mTime);
5883 pNew->cds.crc32 = iCrc32;
5884 pNew->cds.szCompressed = nData;
5885 pNew->cds.szUncompressed = (u32)sz;
5886 pNew->cds.iExternalAttr = (mode<<16);
5887 pNew->cds.iOffset = (u32)pTab->szCurrent;
5888 pNew->cds.nFile = (u16)nPath;
5889 pNew->mUnixTime = (u32)mTime;
5890 rc = zipfileAppendEntry(pTab, pNew, pData, nData);
5891 zipfileAddEntry(pTab, pOld, pNew);
5896 if( rc==SQLITE_OK && (pOld || pOld2) ){
5898 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){
5899 if( pCsr->pCurrent && (pCsr->pCurrent==pOld || pCsr->pCurrent==pOld2) ){
5900 pCsr->pCurrent = pCsr->pCurrent->pNext;
5905 zipfileRemoveEntryFromList(pTab, pOld);
5906 zipfileRemoveEntryFromList(pTab, pOld2);
5909 zipfile_update_done:
5910 sqlite3_free(pFree);
5911 sqlite3_free(zFree);
5915 static int zipfileSerializeEOCD(ZipfileEOCD *p, u8 *aBuf){
5917 zipfileWrite32(a, ZIPFILE_SIGNATURE_EOCD);
5918 zipfileWrite16(a, p->iDisk);
5919 zipfileWrite16(a, p->iFirstDisk);
5920 zipfileWrite16(a, p->nEntry);
5921 zipfileWrite16(a, p->nEntryTotal);
5922 zipfileWrite32(a, p->nSize);
5923 zipfileWrite32(a, p->iOffset);
5924 zipfileWrite16(a, 0); /* Size of trailing comment in bytes*/
5929 static int zipfileAppendEOCD(ZipfileTab *pTab, ZipfileEOCD *p){
5930 int nBuf = zipfileSerializeEOCD(p, pTab->aBuffer);
5931 assert( nBuf==ZIPFILE_EOCD_FIXED_SZ );
5932 return zipfileAppendData(pTab, pTab->aBuffer, nBuf);
5936 ** Serialize the CDS structure into buffer aBuf[]. Return the number
5937 ** of bytes written.
5939 static int zipfileSerializeCDS(ZipfileEntry *pEntry, u8 *aBuf){
5941 ZipfileCDS *pCDS = &pEntry->cds;
5943 if( pEntry->aExtra==0 ){
5947 zipfileWrite32(a, ZIPFILE_SIGNATURE_CDS);
5948 zipfileWrite16(a, pCDS->iVersionMadeBy);
5949 zipfileWrite16(a, pCDS->iVersionExtract);
5950 zipfileWrite16(a, pCDS->flags);
5951 zipfileWrite16(a, pCDS->iCompression);
5952 zipfileWrite16(a, pCDS->mTime);
5953 zipfileWrite16(a, pCDS->mDate);
5954 zipfileWrite32(a, pCDS->crc32);
5955 zipfileWrite32(a, pCDS->szCompressed);
5956 zipfileWrite32(a, pCDS->szUncompressed);
5957 assert( a==&aBuf[ZIPFILE_CDS_NFILE_OFF] );
5958 zipfileWrite16(a, pCDS->nFile);
5959 zipfileWrite16(a, pCDS->nExtra);
5960 zipfileWrite16(a, pCDS->nComment);
5961 zipfileWrite16(a, pCDS->iDiskStart);
5962 zipfileWrite16(a, pCDS->iInternalAttr);
5963 zipfileWrite32(a, pCDS->iExternalAttr);
5964 zipfileWrite32(a, pCDS->iOffset);
5966 memcpy(a, pCDS->zFile, pCDS->nFile);
5969 if( pEntry->aExtra ){
5970 int n = (int)pCDS->nExtra + (int)pCDS->nComment;
5971 memcpy(a, pEntry->aExtra, n);
5974 assert( pCDS->nExtra==9 );
5975 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP);
5976 zipfileWrite16(a, 5);
5978 zipfileWrite32(a, pEntry->mUnixTime);
5984 static int zipfileCommit(sqlite3_vtab *pVtab){
5985 ZipfileTab *pTab = (ZipfileTab*)pVtab;
5987 if( pTab->pWriteFd ){
5988 i64 iOffset = pTab->szCurrent;
5993 /* Write out all entries */
5994 for(p=pTab->pFirstEntry; rc==SQLITE_OK && p; p=p->pNext){
5995 int n = zipfileSerializeCDS(p, pTab->aBuffer);
5996 rc = zipfileAppendData(pTab, pTab->aBuffer, n);
6000 /* Write out the EOCD record */
6002 eocd.iFirstDisk = 0;
6003 eocd.nEntry = (u16)nEntry;
6004 eocd.nEntryTotal = (u16)nEntry;
6005 eocd.nSize = (u32)(pTab->szCurrent - iOffset);
6006 eocd.iOffset = (u32)iOffset;
6007 rc = zipfileAppendEOCD(pTab, &eocd);
6009 zipfileCleanupTransaction(pTab);
6014 static int zipfileRollback(sqlite3_vtab *pVtab){
6015 return zipfileCommit(pVtab);
6018 static ZipfileCsr *zipfileFindCursor(ZipfileTab *pTab, i64 iId){
6020 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){
6021 if( iId==pCsr->iId ) break;
6026 static void zipfileFunctionCds(
6027 sqlite3_context *context,
6029 sqlite3_value **argv
6032 ZipfileTab *pTab = (ZipfileTab*)sqlite3_user_data(context);
6035 pCsr = zipfileFindCursor(pTab, sqlite3_value_int64(argv[0]));
6037 ZipfileCDS *p = &pCsr->pCurrent->cds;
6038 char *zRes = sqlite3_mprintf("{"
6039 "\"version-made-by\" : %u, "
6040 "\"version-to-extract\" : %u, "
6042 "\"compression\" : %u, "
6046 "\"compressed-size\" : %u, "
6047 "\"uncompressed-size\" : %u, "
6048 "\"file-name-length\" : %u, "
6049 "\"extra-field-length\" : %u, "
6050 "\"file-comment-length\" : %u, "
6051 "\"disk-number-start\" : %u, "
6052 "\"internal-attr\" : %u, "
6053 "\"external-attr\" : %u, "
6054 "\"offset\" : %u }",
6055 (u32)p->iVersionMadeBy, (u32)p->iVersionExtract,
6056 (u32)p->flags, (u32)p->iCompression,
6057 (u32)p->mTime, (u32)p->mDate,
6058 (u32)p->crc32, (u32)p->szCompressed,
6059 (u32)p->szUncompressed, (u32)p->nFile,
6060 (u32)p->nExtra, (u32)p->nComment,
6061 (u32)p->iDiskStart, (u32)p->iInternalAttr,
6062 (u32)p->iExternalAttr, (u32)p->iOffset
6066 sqlite3_result_error_nomem(context);
6068 sqlite3_result_text(context, zRes, -1, SQLITE_TRANSIENT);
6075 ** xFindFunction method.
6077 static int zipfileFindFunction(
6078 sqlite3_vtab *pVtab, /* Virtual table handle */
6079 int nArg, /* Number of SQL function arguments */
6080 const char *zName, /* Name of SQL function */
6081 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
6082 void **ppArg /* OUT: User data for *pxFunc */
6084 if( sqlite3_stricmp("zipfile_cds", zName)==0 ){
6085 *pxFunc = zipfileFunctionCds;
6086 *ppArg = (void*)pVtab;
6092 typedef struct ZipfileBuffer ZipfileBuffer;
6093 struct ZipfileBuffer {
6094 u8 *a; /* Pointer to buffer */
6095 int n; /* Size of buffer in bytes */
6096 int nAlloc; /* Byte allocated at a[] */
6099 typedef struct ZipfileCtx ZipfileCtx;
6106 static int zipfileBufferGrow(ZipfileBuffer *pBuf, int nByte){
6107 if( pBuf->n+nByte>pBuf->nAlloc ){
6109 sqlite3_int64 nNew = pBuf->n ? pBuf->n*2 : 512;
6110 int nReq = pBuf->n + nByte;
6112 while( nNew<nReq ) nNew = nNew*2;
6113 aNew = sqlite3_realloc64(pBuf->a, nNew);
6114 if( aNew==0 ) return SQLITE_NOMEM;
6116 pBuf->nAlloc = (int)nNew;
6122 ** xStep() callback for the zipfile() aggregate. This can be called in
6123 ** any of the following ways:
6125 ** SELECT zipfile(name,data) ...
6126 ** SELECT zipfile(name,mode,mtime,data) ...
6127 ** SELECT zipfile(name,mode,mtime,data,method) ...
6129 void zipfileStep(sqlite3_context *pCtx, int nVal, sqlite3_value **apVal){
6130 ZipfileCtx *p; /* Aggregate function context */
6131 ZipfileEntry e; /* New entry to add to zip archive */
6133 sqlite3_value *pName = 0;
6134 sqlite3_value *pMode = 0;
6135 sqlite3_value *pMtime = 0;
6136 sqlite3_value *pData = 0;
6137 sqlite3_value *pMethod = 0;
6144 int iMethod = -1; /* Compression method to use (0 or 8) */
6146 const u8 *aData = 0; /* Possibly compressed data for new entry */
6147 int nData = 0; /* Size of aData[] in bytes */
6148 int szUncompressed = 0; /* Size of data before compression */
6149 u8 *aFree = 0; /* Free this before returning */
6150 u32 iCrc32 = 0; /* crc32 of uncompressed data */
6152 char *zName = 0; /* Path (name) of new entry */
6153 int nName = 0; /* Size of zName in bytes */
6154 char *zFree = 0; /* Free this before returning */
6157 memset(&e, 0, sizeof(e));
6158 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx));
6161 /* Martial the arguments into stack variables */
6162 if( nVal!=2 && nVal!=4 && nVal!=5 ){
6163 zErr = sqlite3_mprintf("wrong number of arguments to function zipfile()");
6165 goto zipfile_step_out;
6179 /* Check that the 'name' parameter looks ok. */
6180 zName = (char*)sqlite3_value_text(pName);
6181 nName = sqlite3_value_bytes(pName);
6183 zErr = sqlite3_mprintf("first argument to zipfile() must be non-NULL");
6185 goto zipfile_step_out;
6188 /* Inspect the 'method' parameter. This must be either 0 (store), 8 (use
6189 ** deflate compression) or NULL (choose automatically). */
6190 if( pMethod && SQLITE_NULL!=sqlite3_value_type(pMethod) ){
6191 iMethod = (int)sqlite3_value_int64(pMethod);
6192 if( iMethod!=0 && iMethod!=8 ){
6193 zErr = sqlite3_mprintf("illegal method value: %d", iMethod);
6195 goto zipfile_step_out;
6199 /* Now inspect the data. If this is NULL, then the new entry must be a
6200 ** directory. Otherwise, figure out whether or not the data should
6201 ** be deflated or simply stored in the zip archive. */
6202 if( sqlite3_value_type(pData)==SQLITE_NULL ){
6206 aData = sqlite3_value_blob(pData);
6207 szUncompressed = nData = sqlite3_value_bytes(pData);
6208 iCrc32 = crc32(0, aData, nData);
6209 if( iMethod<0 || iMethod==8 ){
6211 rc = zipfileDeflate(aData, nData, &aFree, &nOut, &zErr);
6212 if( rc!=SQLITE_OK ){
6213 goto zipfile_step_out;
6215 if( iMethod==8 || nOut<nData ){
6225 /* Decode the "mode" argument. */
6226 rc = zipfileGetMode(pMode, bIsDir, &mode, &zErr);
6227 if( rc ) goto zipfile_step_out;
6229 /* Decode the "mtime" argument. */
6230 e.mUnixTime = zipfileGetTime(pMtime);
6232 /* If this is a directory entry, ensure that there is exactly one '/'
6233 ** at the end of the path. Or, if this is not a directory and the path
6234 ** ends in '/' it is an error. */
6236 if( zName[nName-1]=='/' ){
6237 zErr = sqlite3_mprintf("non-directory name must not end with /");
6239 goto zipfile_step_out;
6242 if( zName[nName-1]!='/' ){
6243 zName = zFree = sqlite3_mprintf("%s/", zName);
6247 goto zipfile_step_out;
6250 while( nName>1 && zName[nName-2]=='/' ) nName--;
6254 /* Assemble the ZipfileEntry object for the new zip archive entry */
6255 e.cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY;
6256 e.cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED;
6257 e.cds.flags = ZIPFILE_NEWENTRY_FLAGS;
6258 e.cds.iCompression = (u16)iMethod;
6259 zipfileMtimeToDos(&e.cds, (u32)e.mUnixTime);
6260 e.cds.crc32 = iCrc32;
6261 e.cds.szCompressed = nData;
6262 e.cds.szUncompressed = szUncompressed;
6263 e.cds.iExternalAttr = (mode<<16);
6264 e.cds.iOffset = p->body.n;
6265 e.cds.nFile = (u16)nName;
6266 e.cds.zFile = zName;
6268 /* Append the LFH to the body of the new archive */
6269 nByte = ZIPFILE_LFH_FIXED_SZ + e.cds.nFile + 9;
6270 if( (rc = zipfileBufferGrow(&p->body, nByte)) ) goto zipfile_step_out;
6271 p->body.n += zipfileSerializeLFH(&e, &p->body.a[p->body.n]);
6273 /* Append the data to the body of the new archive */
6275 if( (rc = zipfileBufferGrow(&p->body, nData)) ) goto zipfile_step_out;
6276 memcpy(&p->body.a[p->body.n], aData, nData);
6280 /* Append the CDS record to the directory of the new archive */
6281 nByte = ZIPFILE_CDS_FIXED_SZ + e.cds.nFile + 9;
6282 if( (rc = zipfileBufferGrow(&p->cds, nByte)) ) goto zipfile_step_out;
6283 p->cds.n += zipfileSerializeCDS(&e, &p->cds.a[p->cds.n]);
6285 /* Increment the count of entries in the archive */
6289 sqlite3_free(aFree);
6290 sqlite3_free(zFree);
6293 sqlite3_result_error(pCtx, zErr, -1);
6295 sqlite3_result_error_code(pCtx, rc);
6302 ** xFinalize() callback for zipfile aggregate function.
6304 void zipfileFinal(sqlite3_context *pCtx){
6310 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx));
6313 memset(&eocd, 0, sizeof(eocd));
6314 eocd.nEntry = (u16)p->nEntry;
6315 eocd.nEntryTotal = (u16)p->nEntry;
6316 eocd.nSize = p->cds.n;
6317 eocd.iOffset = p->body.n;
6319 nZip = p->body.n + p->cds.n + ZIPFILE_EOCD_FIXED_SZ;
6320 aZip = (u8*)sqlite3_malloc64(nZip);
6322 sqlite3_result_error_nomem(pCtx);
6324 memcpy(aZip, p->body.a, p->body.n);
6325 memcpy(&aZip[p->body.n], p->cds.a, p->cds.n);
6326 zipfileSerializeEOCD(&eocd, &aZip[p->body.n + p->cds.n]);
6327 sqlite3_result_blob(pCtx, aZip, (int)nZip, zipfileFree);
6331 sqlite3_free(p->body.a);
6332 sqlite3_free(p->cds.a);
6337 ** Register the "zipfile" virtual table.
6339 static int zipfileRegister(sqlite3 *db){
6340 static sqlite3_module zipfileModule = {
6342 zipfileConnect, /* xCreate */
6343 zipfileConnect, /* xConnect */
6344 zipfileBestIndex, /* xBestIndex */
6345 zipfileDisconnect, /* xDisconnect */
6346 zipfileDisconnect, /* xDestroy */
6347 zipfileOpen, /* xOpen - open a cursor */
6348 zipfileClose, /* xClose - close a cursor */
6349 zipfileFilter, /* xFilter - configure scan constraints */
6350 zipfileNext, /* xNext - advance a cursor */
6351 zipfileEof, /* xEof - check for end of scan */
6352 zipfileColumn, /* xColumn - read data */
6353 0, /* xRowid - read data */
6354 zipfileUpdate, /* xUpdate */
6355 zipfileBegin, /* xBegin */
6357 zipfileCommit, /* xCommit */
6358 zipfileRollback, /* xRollback */
6359 zipfileFindFunction, /* xFindMethod */
6363 int rc = sqlite3_create_module(db, "zipfile" , &zipfileModule, 0);
6364 if( rc==SQLITE_OK ) rc = sqlite3_overload_function(db, "zipfile_cds", -1);
6365 if( rc==SQLITE_OK ){
6366 rc = sqlite3_create_function(db, "zipfile", -1, SQLITE_UTF8, 0, 0,
6367 zipfileStep, zipfileFinal
6372 #else /* SQLITE_OMIT_VIRTUALTABLE */
6373 # define zipfileRegister(x) SQLITE_OK
6379 int sqlite3_zipfile_init(
6382 const sqlite3_api_routines *pApi
6384 SQLITE_EXTENSION_INIT2(pApi);
6385 (void)pzErrMsg; /* Unused parameter */
6386 return zipfileRegister(db);
6389 /************************* End ../ext/misc/zipfile.c ********************/
6390 /************************* Begin ../ext/misc/sqlar.c ******************/
6394 ** The author disclaims copyright to this source code. In place of
6395 ** a legal notice, here is a blessing:
6397 ** May you do good and not evil.
6398 ** May you find forgiveness for yourself and forgive others.
6399 ** May you share freely, never taking more than you give.
6401 ******************************************************************************
6403 ** Utility functions sqlar_compress() and sqlar_uncompress(). Useful
6404 ** for working with sqlar archives and used by the shell tool's built-in
6407 /* #include "sqlite3ext.h" */
6408 SQLITE_EXTENSION_INIT1
6412 ** Implementation of the "sqlar_compress(X)" SQL function.
6414 ** If the type of X is SQLITE_BLOB, and compressing that blob using
6415 ** zlib utility function compress() yields a smaller blob, return the
6416 ** compressed blob. Otherwise, return a copy of X.
6418 ** SQLar uses the "zlib format" for compressed content. The zlib format
6419 ** contains a two-byte identification header and a four-byte checksum at
6420 ** the end. This is different from ZIP which uses the raw deflate format.
6422 ** Future enhancements to SQLar might add support for new compression formats.
6423 ** If so, those new formats will be identified by alternative headers in the
6426 static void sqlarCompressFunc(
6427 sqlite3_context *context,
6429 sqlite3_value **argv
6432 if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){
6433 const Bytef *pData = sqlite3_value_blob(argv[0]);
6434 uLong nData = sqlite3_value_bytes(argv[0]);
6435 uLongf nOut = compressBound(nData);
6438 pOut = (Bytef*)sqlite3_malloc(nOut);
6440 sqlite3_result_error_nomem(context);
6443 if( Z_OK!=compress(pOut, &nOut, pData, nData) ){
6444 sqlite3_result_error(context, "error in compress()", -1);
6445 }else if( nOut<nData ){
6446 sqlite3_result_blob(context, pOut, nOut, SQLITE_TRANSIENT);
6448 sqlite3_result_value(context, argv[0]);
6453 sqlite3_result_value(context, argv[0]);
6458 ** Implementation of the "sqlar_uncompress(X,SZ)" SQL function
6460 ** Parameter SZ is interpreted as an integer. If it is less than or
6461 ** equal to zero, then this function returns a copy of X. Or, if
6462 ** SZ is equal to the size of X when interpreted as a blob, also
6463 ** return a copy of X. Otherwise, decompress blob X using zlib
6464 ** utility function uncompress() and return the results (another
6467 static void sqlarUncompressFunc(
6468 sqlite3_context *context,
6470 sqlite3_value **argv
6476 sz = sqlite3_value_int(argv[1]);
6478 if( sz<=0 || sz==(nData = sqlite3_value_bytes(argv[0])) ){
6479 sqlite3_result_value(context, argv[0]);
6481 const Bytef *pData= sqlite3_value_blob(argv[0]);
6482 Bytef *pOut = sqlite3_malloc(sz);
6483 if( Z_OK!=uncompress(pOut, &sz, pData, nData) ){
6484 sqlite3_result_error(context, "error in uncompress()", -1);
6486 sqlite3_result_blob(context, pOut, sz, SQLITE_TRANSIENT);
6496 int sqlite3_sqlar_init(
6499 const sqlite3_api_routines *pApi
6502 SQLITE_EXTENSION_INIT2(pApi);
6503 (void)pzErrMsg; /* Unused parameter */
6504 rc = sqlite3_create_function(db, "sqlar_compress", 1, SQLITE_UTF8, 0,
6505 sqlarCompressFunc, 0, 0);
6506 if( rc==SQLITE_OK ){
6507 rc = sqlite3_create_function(db, "sqlar_uncompress", 2, SQLITE_UTF8, 0,
6508 sqlarUncompressFunc, 0, 0);
6513 /************************* End ../ext/misc/sqlar.c ********************/
6515 /************************* Begin ../ext/expert/sqlite3expert.h ******************/
6519 ** The author disclaims copyright to this source code. In place of
6520 ** a legal notice, here is a blessing:
6522 ** May you do good and not evil.
6523 ** May you find forgiveness for yourself and forgive others.
6524 ** May you share freely, never taking more than you give.
6526 *************************************************************************
6530 /* #include "sqlite3.h" */
6532 typedef struct sqlite3expert sqlite3expert;
6535 ** Create a new sqlite3expert object.
6537 ** If successful, a pointer to the new object is returned and (*pzErr) set
6538 ** to NULL. Or, if an error occurs, NULL is returned and (*pzErr) set to
6539 ** an English-language error message. In this case it is the responsibility
6540 ** of the caller to eventually free the error message buffer using
6543 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErr);
6546 ** Configure an sqlite3expert object.
6548 ** EXPERT_CONFIG_SAMPLE:
6549 ** By default, sqlite3_expert_analyze() generates sqlite_stat1 data for
6550 ** each candidate index. This involves scanning and sorting the entire
6551 ** contents of each user database table once for each candidate index
6552 ** associated with the table. For large databases, this can be
6553 ** prohibitively slow. This option allows the sqlite3expert object to
6554 ** be configured so that sqlite_stat1 data is instead generated based on a
6555 ** subset of each table, or so that no sqlite_stat1 data is used at all.
6557 ** A single integer argument is passed to this option. If the value is less
6558 ** than or equal to zero, then no sqlite_stat1 data is generated or used by
6559 ** the analysis - indexes are recommended based on the database schema only.
6560 ** Or, if the value is 100 or greater, complete sqlite_stat1 data is
6561 ** generated for each candidate index (this is the default). Finally, if the
6562 ** value falls between 0 and 100, then it represents the percentage of user
6563 ** table rows that should be considered when generating sqlite_stat1 data.
6567 ** // Do not generate any sqlite_stat1 data
6568 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 0);
6570 ** // Generate sqlite_stat1 data based on 10% of the rows in each table.
6571 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 10);
6573 int sqlite3_expert_config(sqlite3expert *p, int op, ...);
6575 #define EXPERT_CONFIG_SAMPLE 1 /* int */
6578 ** Specify zero or more SQL statements to be included in the analysis.
6580 ** Buffer zSql must contain zero or more complete SQL statements. This
6581 ** function parses all statements contained in the buffer and adds them
6582 ** to the internal list of statements to analyze. If successful, SQLITE_OK
6583 ** is returned and (*pzErr) set to NULL. Or, if an error occurs - for example
6584 ** due to a error in the SQL - an SQLite error code is returned and (*pzErr)
6585 ** may be set to point to an English language error message. In this case
6586 ** the caller is responsible for eventually freeing the error message buffer
6587 ** using sqlite3_free().
6589 ** If an error does occur while processing one of the statements in the
6590 ** buffer passed as the second argument, none of the statements in the
6591 ** buffer are added to the analysis.
6593 ** This function must be called before sqlite3_expert_analyze(). If a call
6594 ** to this function is made on an sqlite3expert object that has already
6595 ** been passed to sqlite3_expert_analyze() SQLITE_MISUSE is returned
6596 ** immediately and no statements are added to the analysis.
6598 int sqlite3_expert_sql(
6599 sqlite3expert *p, /* From a successful sqlite3_expert_new() */
6600 const char *zSql, /* SQL statement(s) to add */
6601 char **pzErr /* OUT: Error message (if any) */
6606 ** This function is called after the sqlite3expert object has been configured
6607 ** with all SQL statements using sqlite3_expert_sql() to actually perform
6608 ** the analysis. Once this function has been called, it is not possible to
6609 ** add further SQL statements to the analysis.
6611 ** If successful, SQLITE_OK is returned and (*pzErr) is set to NULL. Or, if
6612 ** an error occurs, an SQLite error code is returned and (*pzErr) set to
6613 ** point to a buffer containing an English language error message. In this
6614 ** case it is the responsibility of the caller to eventually free the buffer
6615 ** using sqlite3_free().
6617 ** If an error does occur within this function, the sqlite3expert object
6618 ** is no longer useful for any purpose. At that point it is no longer
6619 ** possible to add further SQL statements to the object or to re-attempt
6620 ** the analysis. The sqlite3expert object must still be freed using a call
6621 ** sqlite3_expert_destroy().
6623 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr);
6626 ** Return the total number of statements loaded using sqlite3_expert_sql().
6627 ** The total number of SQL statements may be different from the total number
6628 ** to calls to sqlite3_expert_sql().
6630 int sqlite3_expert_count(sqlite3expert*);
6633 ** Return a component of the report.
6635 ** This function is called after sqlite3_expert_analyze() to extract the
6636 ** results of the analysis. Each call to this function returns either a
6637 ** NULL pointer or a pointer to a buffer containing a nul-terminated string.
6638 ** The value passed as the third argument must be one of the EXPERT_REPORT_*
6639 ** #define constants defined below.
6641 ** For some EXPERT_REPORT_* parameters, the buffer returned contains
6642 ** information relating to a specific SQL statement. In these cases that
6643 ** SQL statement is identified by the value passed as the second argument.
6644 ** SQL statements are numbered from 0 in the order in which they are parsed.
6645 ** If an out-of-range value (less than zero or equal to or greater than the
6646 ** value returned by sqlite3_expert_count()) is passed as the second argument
6647 ** along with such an EXPERT_REPORT_* parameter, NULL is always returned.
6649 ** EXPERT_REPORT_SQL:
6650 ** Return the text of SQL statement iStmt.
6652 ** EXPERT_REPORT_INDEXES:
6653 ** Return a buffer containing the CREATE INDEX statements for all recommended
6654 ** indexes for statement iStmt. If there are no new recommeded indexes, NULL
6657 ** EXPERT_REPORT_PLAN:
6658 ** Return a buffer containing the EXPLAIN QUERY PLAN output for SQL query
6659 ** iStmt after the proposed indexes have been added to the database schema.
6661 ** EXPERT_REPORT_CANDIDATES:
6662 ** Return a pointer to a buffer containing the CREATE INDEX statements
6663 ** for all indexes that were tested (for all SQL statements). The iStmt
6664 ** parameter is ignored for EXPERT_REPORT_CANDIDATES calls.
6666 const char *sqlite3_expert_report(sqlite3expert*, int iStmt, int eReport);
6669 ** Values for the third argument passed to sqlite3_expert_report().
6671 #define EXPERT_REPORT_SQL 1
6672 #define EXPERT_REPORT_INDEXES 2
6673 #define EXPERT_REPORT_PLAN 3
6674 #define EXPERT_REPORT_CANDIDATES 4
6677 ** Free an (sqlite3expert*) handle and all associated resources. There
6678 ** should be one call to this function for each successful call to
6679 ** sqlite3-expert_new().
6681 void sqlite3_expert_destroy(sqlite3expert*);
6685 /************************* End ../ext/expert/sqlite3expert.h ********************/
6686 /************************* Begin ../ext/expert/sqlite3expert.c ******************/
6690 ** The author disclaims copyright to this source code. In place of
6691 ** a legal notice, here is a blessing:
6693 ** May you do good and not evil.
6694 ** May you find forgiveness for yourself and forgive others.
6695 ** May you share freely, never taking more than you give.
6697 *************************************************************************
6699 /* #include "sqlite3expert.h" */
6704 #ifndef SQLITE_OMIT_VIRTUALTABLE
6706 /* typedef sqlite3_int64 i64; */
6707 /* typedef sqlite3_uint64 u64; */
6709 typedef struct IdxColumn IdxColumn;
6710 typedef struct IdxConstraint IdxConstraint;
6711 typedef struct IdxScan IdxScan;
6712 typedef struct IdxStatement IdxStatement;
6713 typedef struct IdxTable IdxTable;
6714 typedef struct IdxWrite IdxWrite;
6716 #define STRLEN (int)strlen
6719 ** A temp table name that we assume no user database will actually use.
6720 ** If this assumption proves incorrect triggers on the table with the
6721 ** conflicting name will be ignored.
6723 #define UNIQUE_TABLE_NAME "t592690916721053953805701627921227776"
6726 ** A single constraint. Equivalent to either "col = ?" or "col < ?" (or
6727 ** any other type of single-ended range constraint on a column).
6730 ** Used to temporarily link IdxConstraint objects into lists while
6731 ** creating candidate indexes.
6733 struct IdxConstraint {
6734 char *zColl; /* Collation sequence */
6735 int bRange; /* True for range, false for eq */
6736 int iCol; /* Constrained table column */
6737 int bFlag; /* Used by idxFindCompatible() */
6738 int bDesc; /* True if ORDER BY <expr> DESC */
6739 IdxConstraint *pNext; /* Next constraint in pEq or pRange list */
6740 IdxConstraint *pLink; /* See above */
6744 ** A single scan of a single table.
6747 IdxTable *pTab; /* Associated table object */
6748 int iDb; /* Database containing table zTable */
6749 i64 covering; /* Mask of columns required for cov. index */
6750 IdxConstraint *pOrder; /* ORDER BY columns */
6751 IdxConstraint *pEq; /* List of == constraints */
6752 IdxConstraint *pRange; /* List of < constraints */
6753 IdxScan *pNextScan; /* Next IdxScan object for same analysis */
6757 ** Information regarding a single database table. Extracted from
6758 ** "PRAGMA table_info" by function idxGetTableInfo().
6767 char *zName; /* Table name */
6769 IdxTable *pNext; /* Next table in linked list of all tables */
6773 ** An object of the following type is created for each unique table/write-op
6774 ** seen. The objects are stored in a singly-linked list beginning at
6775 ** sqlite3expert.pWrite.
6779 int eOp; /* SQLITE_UPDATE, DELETE or INSERT */
6784 ** Each statement being analyzed is represented by an instance of this
6787 struct IdxStatement {
6788 int iId; /* Statement number */
6789 char *zSql; /* SQL statement */
6790 char *zIdx; /* Indexes */
6791 char *zEQP; /* Plan */
6792 IdxStatement *pNext;
6797 ** A hash table for storing strings. With space for a payload string
6798 ** with each entry. Methods are:
6805 #define IDX_HASH_SIZE 1023
6806 typedef struct IdxHashEntry IdxHashEntry;
6807 typedef struct IdxHash IdxHash;
6808 struct IdxHashEntry {
6809 char *zKey; /* nul-terminated key */
6810 char *zVal; /* nul-terminated value string */
6811 char *zVal2; /* nul-terminated value string 2 */
6812 IdxHashEntry *pHashNext; /* Next entry in same hash bucket */
6813 IdxHashEntry *pNext; /* Next entry in hash */
6816 IdxHashEntry *pFirst;
6817 IdxHashEntry *aHash[IDX_HASH_SIZE];
6821 ** sqlite3expert object.
6823 struct sqlite3expert {
6824 int iSample; /* Percentage of tables to sample for stat1 */
6825 sqlite3 *db; /* User database */
6826 sqlite3 *dbm; /* In-memory db for this analysis */
6827 sqlite3 *dbv; /* Vtab schema for this analysis */
6828 IdxTable *pTable; /* List of all IdxTable objects */
6829 IdxScan *pScan; /* List of scan objects */
6830 IdxWrite *pWrite; /* List of write objects */
6831 IdxStatement *pStatement; /* List of IdxStatement objects */
6832 int bRun; /* True once analysis has run */
6834 int rc; /* Error code from whereinfo hook */
6835 IdxHash hIdx; /* Hash containing all candidate indexes */
6836 char *zCandidates; /* For EXPERT_REPORT_CANDIDATES */
6841 ** Allocate and return nByte bytes of zeroed memory using sqlite3_malloc().
6842 ** If the allocation fails, set *pRc to SQLITE_NOMEM and return NULL.
6844 static void *idxMalloc(int *pRc, int nByte){
6846 assert( *pRc==SQLITE_OK );
6848 pRet = sqlite3_malloc(nByte);
6850 memset(pRet, 0, nByte);
6852 *pRc = SQLITE_NOMEM;
6858 ** Initialize an IdxHash hash table.
6860 static void idxHashInit(IdxHash *pHash){
6861 memset(pHash, 0, sizeof(IdxHash));
6865 ** Reset an IdxHash hash table.
6867 static void idxHashClear(IdxHash *pHash){
6869 for(i=0; i<IDX_HASH_SIZE; i++){
6870 IdxHashEntry *pEntry;
6871 IdxHashEntry *pNext;
6872 for(pEntry=pHash->aHash[i]; pEntry; pEntry=pNext){
6873 pNext = pEntry->pHashNext;
6874 sqlite3_free(pEntry->zVal2);
6875 sqlite3_free(pEntry);
6878 memset(pHash, 0, sizeof(IdxHash));
6882 ** Return the index of the hash bucket that the string specified by the
6883 ** arguments to this function belongs.
6885 static int idxHashString(const char *z, int n){
6886 unsigned int ret = 0;
6889 ret += (ret<<3) + (unsigned char)(z[i]);
6891 return (int)(ret % IDX_HASH_SIZE);
6895 ** If zKey is already present in the hash table, return non-zero and do
6896 ** nothing. Otherwise, add an entry with key zKey and payload string zVal to
6897 ** the hash table passed as the second argument.
6899 static int idxHashAdd(
6905 int nKey = STRLEN(zKey);
6906 int iHash = idxHashString(zKey, nKey);
6907 int nVal = (zVal ? STRLEN(zVal) : 0);
6908 IdxHashEntry *pEntry;
6910 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){
6911 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){
6915 pEntry = idxMalloc(pRc, sizeof(IdxHashEntry) + nKey+1 + nVal+1);
6917 pEntry->zKey = (char*)&pEntry[1];
6918 memcpy(pEntry->zKey, zKey, nKey);
6920 pEntry->zVal = &pEntry->zKey[nKey+1];
6921 memcpy(pEntry->zVal, zVal, nVal);
6923 pEntry->pHashNext = pHash->aHash[iHash];
6924 pHash->aHash[iHash] = pEntry;
6926 pEntry->pNext = pHash->pFirst;
6927 pHash->pFirst = pEntry;
6933 ** If zKey/nKey is present in the hash table, return a pointer to the
6934 ** hash-entry object.
6936 static IdxHashEntry *idxHashFind(IdxHash *pHash, const char *zKey, int nKey){
6938 IdxHashEntry *pEntry;
6939 if( nKey<0 ) nKey = STRLEN(zKey);
6940 iHash = idxHashString(zKey, nKey);
6942 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){
6943 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){
6951 ** If the hash table contains an entry with a key equal to the string
6952 ** passed as the final two arguments to this function, return a pointer
6953 ** to the payload string. Otherwise, if zKey/nKey is not present in the
6954 ** hash table, return NULL.
6956 static const char *idxHashSearch(IdxHash *pHash, const char *zKey, int nKey){
6957 IdxHashEntry *pEntry = idxHashFind(pHash, zKey, nKey);
6958 if( pEntry ) return pEntry->zVal;
6963 ** Allocate and return a new IdxConstraint object. Set the IdxConstraint.zColl
6964 ** variable to point to a copy of nul-terminated string zColl.
6966 static IdxConstraint *idxNewConstraint(int *pRc, const char *zColl){
6967 IdxConstraint *pNew;
6968 int nColl = STRLEN(zColl);
6970 assert( *pRc==SQLITE_OK );
6971 pNew = (IdxConstraint*)idxMalloc(pRc, sizeof(IdxConstraint) * nColl + 1);
6973 pNew->zColl = (char*)&pNew[1];
6974 memcpy(pNew->zColl, zColl, nColl+1);
6980 ** An error associated with database handle db has just occurred. Pass
6981 ** the error message to callback function xOut.
6983 static void idxDatabaseError(
6984 sqlite3 *db, /* Database handle */
6985 char **pzErrmsg /* Write error here */
6987 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
6991 ** Prepare an SQL statement.
6993 static int idxPrepareStmt(
6994 sqlite3 *db, /* Database handle to compile against */
6995 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */
6996 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */
6997 const char *zSql /* SQL statement to compile */
6999 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
7000 if( rc!=SQLITE_OK ){
7002 idxDatabaseError(db, pzErrmsg);
7008 ** Prepare an SQL statement using the results of a printf() formatting.
7010 static int idxPrintfPrepareStmt(
7011 sqlite3 *db, /* Database handle to compile against */
7012 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */
7013 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */
7014 const char *zFmt, /* printf() format of SQL statement */
7015 ... /* Trailing printf() arguments */
7021 zSql = sqlite3_vmprintf(zFmt, ap);
7025 rc = idxPrepareStmt(db, ppStmt, pzErrmsg, zSql);
7033 /*************************************************************************
7034 ** Beginning of virtual table implementation.
7036 typedef struct ExpertVtab ExpertVtab;
7040 sqlite3expert *pExpert;
7043 typedef struct ExpertCsr ExpertCsr;
7045 sqlite3_vtab_cursor base;
7046 sqlite3_stmt *pData;
7049 static char *expertDequote(const char *zIn){
7050 int n = STRLEN(zIn);
7051 char *zRet = sqlite3_malloc(n);
7053 assert( zIn[0]=='\'' );
7054 assert( zIn[n-1]=='\'' );
7059 for(iIn=1; iIn<(n-1); iIn++){
7060 if( zIn[iIn]=='\'' ){
7061 assert( zIn[iIn+1]=='\'' );
7064 zRet[iOut++] = zIn[iIn];
7073 ** This function is the implementation of both the xConnect and xCreate
7074 ** methods of the r-tree virtual table.
7076 ** argv[0] -> module name
7077 ** argv[1] -> database name
7078 ** argv[2] -> table name
7079 ** argv[...] -> column names...
7081 static int expertConnect(
7084 int argc, const char *const*argv,
7085 sqlite3_vtab **ppVtab,
7088 sqlite3expert *pExpert = (sqlite3expert*)pAux;
7093 *pzErr = sqlite3_mprintf("internal error!");
7096 char *zCreateTable = expertDequote(argv[3]);
7098 rc = sqlite3_declare_vtab(db, zCreateTable);
7099 if( rc==SQLITE_OK ){
7100 p = idxMalloc(&rc, sizeof(ExpertVtab));
7102 if( rc==SQLITE_OK ){
7103 p->pExpert = pExpert;
7104 p->pTab = pExpert->pTable;
7105 assert( sqlite3_stricmp(p->pTab->zName, argv[2])==0 );
7107 sqlite3_free(zCreateTable);
7113 *ppVtab = (sqlite3_vtab*)p;
7117 static int expertDisconnect(sqlite3_vtab *pVtab){
7118 ExpertVtab *p = (ExpertVtab*)pVtab;
7123 static int expertBestIndex(sqlite3_vtab *pVtab, sqlite3_index_info *pIdxInfo){
7124 ExpertVtab *p = (ExpertVtab*)pVtab;
7129 SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_GT |
7130 SQLITE_INDEX_CONSTRAINT_LT | SQLITE_INDEX_CONSTRAINT_GE |
7131 SQLITE_INDEX_CONSTRAINT_LE;
7133 pScan = idxMalloc(&rc, sizeof(IdxScan));
7137 /* Link the new scan object into the list */
7138 pScan->pTab = p->pTab;
7139 pScan->pNextScan = p->pExpert->pScan;
7140 p->pExpert->pScan = pScan;
7142 /* Add the constraints to the IdxScan object */
7143 for(i=0; i<pIdxInfo->nConstraint; i++){
7144 struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i];
7146 && pCons->iColumn>=0
7147 && p->pTab->aCol[pCons->iColumn].iPk==0
7148 && (pCons->op & opmask)
7150 IdxConstraint *pNew;
7151 const char *zColl = sqlite3_vtab_collation(pIdxInfo, i);
7152 pNew = idxNewConstraint(&rc, zColl);
7154 pNew->iCol = pCons->iColumn;
7155 if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){
7156 pNew->pNext = pScan->pEq;
7160 pNew->pNext = pScan->pRange;
7161 pScan->pRange = pNew;
7165 pIdxInfo->aConstraintUsage[i].argvIndex = n;
7169 /* Add the ORDER BY to the IdxScan object */
7170 for(i=pIdxInfo->nOrderBy-1; i>=0; i--){
7171 int iCol = pIdxInfo->aOrderBy[i].iColumn;
7173 IdxConstraint *pNew = idxNewConstraint(&rc, p->pTab->aCol[iCol].zColl);
7176 pNew->bDesc = pIdxInfo->aOrderBy[i].desc;
7177 pNew->pNext = pScan->pOrder;
7178 pNew->pLink = pScan->pOrder;
7179 pScan->pOrder = pNew;
7186 pIdxInfo->estimatedCost = 1000000.0 / (n+1);
7190 static int expertUpdate(
7191 sqlite3_vtab *pVtab,
7193 sqlite3_value **azData,
7194 sqlite_int64 *pRowid
7204 ** Virtual table module xOpen method.
7206 static int expertOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
7210 pCsr = idxMalloc(&rc, sizeof(ExpertCsr));
7211 *ppCursor = (sqlite3_vtab_cursor*)pCsr;
7216 ** Virtual table module xClose method.
7218 static int expertClose(sqlite3_vtab_cursor *cur){
7219 ExpertCsr *pCsr = (ExpertCsr*)cur;
7220 sqlite3_finalize(pCsr->pData);
7226 ** Virtual table module xEof method.
7228 ** Return non-zero if the cursor does not currently point to a valid
7229 ** record (i.e if the scan has finished), or zero otherwise.
7231 static int expertEof(sqlite3_vtab_cursor *cur){
7232 ExpertCsr *pCsr = (ExpertCsr*)cur;
7233 return pCsr->pData==0;
7237 ** Virtual table module xNext method.
7239 static int expertNext(sqlite3_vtab_cursor *cur){
7240 ExpertCsr *pCsr = (ExpertCsr*)cur;
7243 assert( pCsr->pData );
7244 rc = sqlite3_step(pCsr->pData);
7245 if( rc!=SQLITE_ROW ){
7246 rc = sqlite3_finalize(pCsr->pData);
7256 ** Virtual table module xRowid method.
7258 static int expertRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
7265 ** Virtual table module xColumn method.
7267 static int expertColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
7268 ExpertCsr *pCsr = (ExpertCsr*)cur;
7269 sqlite3_value *pVal;
7270 pVal = sqlite3_column_value(pCsr->pData, i);
7272 sqlite3_result_value(ctx, pVal);
7278 ** Virtual table module xFilter method.
7280 static int expertFilter(
7281 sqlite3_vtab_cursor *cur,
7282 int idxNum, const char *idxStr,
7283 int argc, sqlite3_value **argv
7285 ExpertCsr *pCsr = (ExpertCsr*)cur;
7286 ExpertVtab *pVtab = (ExpertVtab*)(cur->pVtab);
7287 sqlite3expert *pExpert = pVtab->pExpert;
7294 rc = sqlite3_finalize(pCsr->pData);
7296 if( rc==SQLITE_OK ){
7297 rc = idxPrintfPrepareStmt(pExpert->db, &pCsr->pData, &pVtab->base.zErrMsg,
7298 "SELECT * FROM main.%Q WHERE sample()", pVtab->pTab->zName
7302 if( rc==SQLITE_OK ){
7303 rc = expertNext(cur);
7308 static int idxRegisterVtab(sqlite3expert *p){
7309 static sqlite3_module expertModule = {
7311 expertConnect, /* xCreate - create a table */
7312 expertConnect, /* xConnect - connect to an existing table */
7313 expertBestIndex, /* xBestIndex - Determine search strategy */
7314 expertDisconnect, /* xDisconnect - Disconnect from a table */
7315 expertDisconnect, /* xDestroy - Drop a table */
7316 expertOpen, /* xOpen - open a cursor */
7317 expertClose, /* xClose - close a cursor */
7318 expertFilter, /* xFilter - configure scan constraints */
7319 expertNext, /* xNext - advance a cursor */
7320 expertEof, /* xEof */
7321 expertColumn, /* xColumn - read data */
7322 expertRowid, /* xRowid - read data */
7323 expertUpdate, /* xUpdate - write data */
7324 0, /* xBegin - begin transaction */
7325 0, /* xSync - sync transaction */
7326 0, /* xCommit - commit transaction */
7327 0, /* xRollback - rollback transaction */
7328 0, /* xFindFunction - function overloading */
7329 0, /* xRename - rename the table */
7332 0, /* xRollbackTo */
7333 0, /* xShadowName */
7336 return sqlite3_create_module(p->dbv, "expert", &expertModule, (void*)p);
7339 ** End of virtual table implementation.
7340 *************************************************************************/
7342 ** Finalize SQL statement pStmt. If (*pRc) is SQLITE_OK when this function
7343 ** is called, set it to the return value of sqlite3_finalize() before
7344 ** returning. Otherwise, discard the sqlite3_finalize() return value.
7346 static void idxFinalize(int *pRc, sqlite3_stmt *pStmt){
7347 int rc = sqlite3_finalize(pStmt);
7348 if( *pRc==SQLITE_OK ) *pRc = rc;
7352 ** Attempt to allocate an IdxTable structure corresponding to table zTab
7353 ** in the main database of connection db. If successful, set (*ppOut) to
7354 ** point to the new object and return SQLITE_OK. Otherwise, return an
7355 ** SQLite error code and set (*ppOut) to NULL. In this case *pzErrmsg may be
7356 ** set to point to an error string.
7358 ** It is the responsibility of the caller to eventually free either the
7359 ** IdxTable object or error message using sqlite3_free().
7361 static int idxGetTableInfo(
7362 sqlite3 *db, /* Database connection to read details from */
7363 const char *zTab, /* Table name */
7364 IdxTable **ppOut, /* OUT: New object (if successful) */
7365 char **pzErrmsg /* OUT: Error message (if not) */
7367 sqlite3_stmt *p1 = 0;
7369 int nTab = STRLEN(zTab);
7370 int nByte = sizeof(IdxTable) + nTab + 1;
7375 rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_info=%Q", zTab);
7376 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
7377 const char *zCol = (const char*)sqlite3_column_text(p1, 1);
7378 nByte += 1 + STRLEN(zCol);
7379 rc = sqlite3_table_column_metadata(
7380 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0
7382 nByte += 1 + STRLEN(zCol);
7385 rc2 = sqlite3_reset(p1);
7386 if( rc==SQLITE_OK ) rc = rc2;
7388 nByte += sizeof(IdxColumn) * nCol;
7389 if( rc==SQLITE_OK ){
7390 pNew = idxMalloc(&rc, nByte);
7392 if( rc==SQLITE_OK ){
7393 pNew->aCol = (IdxColumn*)&pNew[1];
7395 pCsr = (char*)&pNew->aCol[nCol];
7399 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
7400 const char *zCol = (const char*)sqlite3_column_text(p1, 1);
7401 int nCopy = STRLEN(zCol) + 1;
7402 pNew->aCol[nCol].zName = pCsr;
7403 pNew->aCol[nCol].iPk = sqlite3_column_int(p1, 5);
7404 memcpy(pCsr, zCol, nCopy);
7407 rc = sqlite3_table_column_metadata(
7408 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0
7410 if( rc==SQLITE_OK ){
7411 nCopy = STRLEN(zCol) + 1;
7412 pNew->aCol[nCol].zColl = pCsr;
7413 memcpy(pCsr, zCol, nCopy);
7419 idxFinalize(&rc, p1);
7421 if( rc!=SQLITE_OK ){
7426 memcpy(pNew->zName, zTab, nTab+1);
7434 ** This function is a no-op if *pRc is set to anything other than
7435 ** SQLITE_OK when it is called.
7437 ** If *pRc is initially set to SQLITE_OK, then the text specified by
7438 ** the printf() style arguments is appended to zIn and the result returned
7439 ** in a buffer allocated by sqlite3_malloc(). sqlite3_free() is called on
7440 ** zIn before returning.
7442 static char *idxAppendText(int *pRc, char *zIn, const char *zFmt, ...){
7446 int nIn = zIn ? STRLEN(zIn) : 0;
7449 if( *pRc==SQLITE_OK ){
7450 zAppend = sqlite3_vmprintf(zFmt, ap);
7452 nAppend = STRLEN(zAppend);
7453 zRet = (char*)sqlite3_malloc(nIn + nAppend + 1);
7455 if( zAppend && zRet ){
7456 if( nIn ) memcpy(zRet, zIn, nIn);
7457 memcpy(&zRet[nIn], zAppend, nAppend+1);
7461 *pRc = SQLITE_NOMEM;
7463 sqlite3_free(zAppend);
7471 ** Return true if zId must be quoted in order to use it as an SQL
7472 ** identifier, or false otherwise.
7474 static int idxIdentifierRequiresQuotes(const char *zId){
7476 for(i=0; zId[i]; i++){
7478 && !(zId[i]>='0' && zId[i]<='9')
7479 && !(zId[i]>='a' && zId[i]<='z')
7480 && !(zId[i]>='A' && zId[i]<='Z')
7489 ** This function appends an index column definition suitable for constraint
7490 ** pCons to the string passed as zIn and returns the result.
7492 static char *idxAppendColDefn(
7493 int *pRc, /* IN/OUT: Error code */
7494 char *zIn, /* Column defn accumulated so far */
7495 IdxTable *pTab, /* Table index will be created on */
7496 IdxConstraint *pCons
7499 IdxColumn *p = &pTab->aCol[pCons->iCol];
7500 if( zRet ) zRet = idxAppendText(pRc, zRet, ", ");
7502 if( idxIdentifierRequiresQuotes(p->zName) ){
7503 zRet = idxAppendText(pRc, zRet, "%Q", p->zName);
7505 zRet = idxAppendText(pRc, zRet, "%s", p->zName);
7508 if( sqlite3_stricmp(p->zColl, pCons->zColl) ){
7509 if( idxIdentifierRequiresQuotes(pCons->zColl) ){
7510 zRet = idxAppendText(pRc, zRet, " COLLATE %Q", pCons->zColl);
7512 zRet = idxAppendText(pRc, zRet, " COLLATE %s", pCons->zColl);
7517 zRet = idxAppendText(pRc, zRet, " DESC");
7523 ** Search database dbm for an index compatible with the one idxCreateFromCons()
7524 ** would create from arguments pScan, pEq and pTail. If no error occurs and
7525 ** such an index is found, return non-zero. Or, if no such index is found,
7528 ** If an error occurs, set *pRc to an SQLite error code and return zero.
7530 static int idxFindCompatible(
7531 int *pRc, /* OUT: Error code */
7532 sqlite3* dbm, /* Database to search */
7533 IdxScan *pScan, /* Scan for table to search for index on */
7534 IdxConstraint *pEq, /* List of == constraints */
7535 IdxConstraint *pTail /* List of range constraints */
7537 const char *zTbl = pScan->pTab->zName;
7538 sqlite3_stmt *pIdxList = 0;
7539 IdxConstraint *pIter;
7540 int nEq = 0; /* Number of elements in pEq */
7543 /* Count the elements in list pEq */
7544 for(pIter=pEq; pIter; pIter=pIter->pLink) nEq++;
7546 rc = idxPrintfPrepareStmt(dbm, &pIdxList, 0, "PRAGMA index_list=%Q", zTbl);
7547 while( rc==SQLITE_OK && sqlite3_step(pIdxList)==SQLITE_ROW ){
7549 IdxConstraint *pT = pTail;
7550 sqlite3_stmt *pInfo = 0;
7551 const char *zIdx = (const char*)sqlite3_column_text(pIdxList, 1);
7553 /* Zero the IdxConstraint.bFlag values in the pEq list */
7554 for(pIter=pEq; pIter; pIter=pIter->pLink) pIter->bFlag = 0;
7556 rc = idxPrintfPrepareStmt(dbm, &pInfo, 0, "PRAGMA index_xInfo=%Q", zIdx);
7557 while( rc==SQLITE_OK && sqlite3_step(pInfo)==SQLITE_ROW ){
7558 int iIdx = sqlite3_column_int(pInfo, 0);
7559 int iCol = sqlite3_column_int(pInfo, 1);
7560 const char *zColl = (const char*)sqlite3_column_text(pInfo, 4);
7563 for(pIter=pEq; pIter; pIter=pIter->pLink){
7564 if( pIter->bFlag ) continue;
7565 if( pIter->iCol!=iCol ) continue;
7566 if( sqlite3_stricmp(pIter->zColl, zColl) ) continue;
7576 if( pT->iCol!=iCol || sqlite3_stricmp(pT->zColl, zColl) ){
7584 idxFinalize(&rc, pInfo);
7586 if( rc==SQLITE_OK && bMatch ){
7587 sqlite3_finalize(pIdxList);
7591 idxFinalize(&rc, pIdxList);
7597 static int idxCreateFromCons(
7601 IdxConstraint *pTail
7603 sqlite3 *dbm = p->dbm;
7605 if( (pEq || pTail) && 0==idxFindCompatible(&rc, dbm, pScan, pEq, pTail) ){
7606 IdxTable *pTab = pScan->pTab;
7609 IdxConstraint *pCons;
7613 for(pCons=pEq; pCons; pCons=pCons->pLink){
7614 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons);
7616 for(pCons=pTail; pCons; pCons=pCons->pLink){
7617 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons);
7620 if( rc==SQLITE_OK ){
7621 /* Hash the list of columns to come up with a name for the index */
7622 const char *zTable = pScan->pTab->zName;
7623 char *zName; /* Index name */
7625 for(i=0; zCols[i]; i++){
7626 h += ((h<<3) + zCols[i]);
7628 zName = sqlite3_mprintf("%s_idx_%08x", zTable, h);
7632 if( idxIdentifierRequiresQuotes(zTable) ){
7633 zFmt = "CREATE INDEX '%q' ON %Q(%s)";
7635 zFmt = "CREATE INDEX %s ON %s(%s)";
7637 zIdx = sqlite3_mprintf(zFmt, zName, zTable, zCols);
7641 rc = sqlite3_exec(dbm, zIdx, 0, 0, p->pzErrmsg);
7642 idxHashAdd(&rc, &p->hIdx, zName, zIdx);
7644 sqlite3_free(zName);
7649 sqlite3_free(zCols);
7655 ** Return true if list pList (linked by IdxConstraint.pLink) contains
7656 ** a constraint compatible with *p. Otherwise return false.
7658 static int idxFindConstraint(IdxConstraint *pList, IdxConstraint *p){
7659 IdxConstraint *pCmp;
7660 for(pCmp=pList; pCmp; pCmp=pCmp->pLink){
7661 if( p->iCol==pCmp->iCol ) return 1;
7666 static int idxCreateFromWhere(
7668 IdxScan *pScan, /* Create indexes for this scan */
7669 IdxConstraint *pTail /* range/ORDER BY constraints for inclusion */
7671 IdxConstraint *p1 = 0;
7672 IdxConstraint *pCon;
7675 /* Gather up all the == constraints. */
7676 for(pCon=pScan->pEq; pCon; pCon=pCon->pNext){
7677 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){
7683 /* Create an index using the == constraints collected above. And the
7684 ** range constraint/ORDER BY terms passed in by the caller, if any. */
7685 rc = idxCreateFromCons(p, pScan, p1, pTail);
7687 /* If no range/ORDER BY passed by the caller, create a version of the
7688 ** index for each range constraint. */
7690 for(pCon=pScan->pRange; rc==SQLITE_OK && pCon; pCon=pCon->pNext){
7691 assert( pCon->pLink==0 );
7692 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){
7693 rc = idxCreateFromCons(p, pScan, p1, pCon);
7702 ** Create candidate indexes in database [dbm] based on the data in
7703 ** linked-list pScan.
7705 static int idxCreateCandidates(sqlite3expert *p){
7709 for(pIter=p->pScan; pIter && rc==SQLITE_OK; pIter=pIter->pNextScan){
7710 rc = idxCreateFromWhere(p, pIter, 0);
7711 if( rc==SQLITE_OK && pIter->pOrder ){
7712 rc = idxCreateFromWhere(p, pIter, pIter->pOrder);
7720 ** Free all elements of the linked list starting at pConstraint.
7722 static void idxConstraintFree(IdxConstraint *pConstraint){
7723 IdxConstraint *pNext;
7726 for(p=pConstraint; p; p=pNext){
7733 ** Free all elements of the linked list starting from pScan up until pLast
7734 ** (pLast is not freed).
7736 static void idxScanFree(IdxScan *pScan, IdxScan *pLast){
7739 for(p=pScan; p!=pLast; p=pNext){
7740 pNext = p->pNextScan;
7741 idxConstraintFree(p->pOrder);
7742 idxConstraintFree(p->pEq);
7743 idxConstraintFree(p->pRange);
7749 ** Free all elements of the linked list starting from pStatement up
7750 ** until pLast (pLast is not freed).
7752 static void idxStatementFree(IdxStatement *pStatement, IdxStatement *pLast){
7754 IdxStatement *pNext;
7755 for(p=pStatement; p!=pLast; p=pNext){
7757 sqlite3_free(p->zEQP);
7758 sqlite3_free(p->zIdx);
7764 ** Free the linked list of IdxTable objects starting at pTab.
7766 static void idxTableFree(IdxTable *pTab){
7769 for(pIter=pTab; pIter; pIter=pNext){
7770 pNext = pIter->pNext;
7771 sqlite3_free(pIter);
7776 ** Free the linked list of IdxWrite objects starting at pTab.
7778 static void idxWriteFree(IdxWrite *pTab){
7781 for(pIter=pTab; pIter; pIter=pNext){
7782 pNext = pIter->pNext;
7783 sqlite3_free(pIter);
7790 ** This function is called after candidate indexes have been created. It
7791 ** runs all the queries to see which indexes they prefer, and populates
7792 ** IdxStatement.zIdx and IdxStatement.zEQP with the results.
7796 char **pzErr /* OUT: Error message (sqlite3_malloc) */
7798 IdxStatement *pStmt;
7799 sqlite3 *dbm = p->dbm;
7805 for(pStmt=p->pStatement; rc==SQLITE_OK && pStmt; pStmt=pStmt->pNext){
7806 IdxHashEntry *pEntry;
7807 sqlite3_stmt *pExplain = 0;
7808 idxHashClear(&hIdx);
7809 rc = idxPrintfPrepareStmt(dbm, &pExplain, pzErr,
7810 "EXPLAIN QUERY PLAN %s", pStmt->zSql
7812 while( rc==SQLITE_OK && sqlite3_step(pExplain)==SQLITE_ROW ){
7813 /* int iId = sqlite3_column_int(pExplain, 0); */
7814 /* int iParent = sqlite3_column_int(pExplain, 1); */
7815 /* int iNotUsed = sqlite3_column_int(pExplain, 2); */
7816 const char *zDetail = (const char*)sqlite3_column_text(pExplain, 3);
7817 int nDetail = STRLEN(zDetail);
7820 for(i=0; i<nDetail; i++){
7821 const char *zIdx = 0;
7822 if( memcmp(&zDetail[i], " USING INDEX ", 13)==0 ){
7823 zIdx = &zDetail[i+13];
7824 }else if( memcmp(&zDetail[i], " USING COVERING INDEX ", 22)==0 ){
7825 zIdx = &zDetail[i+22];
7830 while( zIdx[nIdx]!='\0' && (zIdx[nIdx]!=' ' || zIdx[nIdx+1]!='(') ){
7833 zSql = idxHashSearch(&p->hIdx, zIdx, nIdx);
7835 idxHashAdd(&rc, &hIdx, zSql, 0);
7836 if( rc ) goto find_indexes_out;
7842 if( zDetail[0]!='-' ){
7843 pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail);
7847 for(pEntry=hIdx.pFirst; pEntry; pEntry=pEntry->pNext){
7848 pStmt->zIdx = idxAppendText(&rc, pStmt->zIdx, "%s;\n", pEntry->zKey);
7851 idxFinalize(&rc, pExplain);
7855 idxHashClear(&hIdx);
7859 static int idxAuthCallback(
7865 const char *zTrigger
7870 if( eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE || eOp==SQLITE_DELETE ){
7871 if( sqlite3_stricmp(zDb, "main")==0 ){
7872 sqlite3expert *p = (sqlite3expert*)pCtx;
7874 for(pTab=p->pTable; pTab; pTab=pTab->pNext){
7875 if( 0==sqlite3_stricmp(z3, pTab->zName) ) break;
7879 for(pWrite=p->pWrite; pWrite; pWrite=pWrite->pNext){
7880 if( pWrite->pTab==pTab && pWrite->eOp==eOp ) break;
7883 pWrite = idxMalloc(&rc, sizeof(IdxWrite));
7884 if( rc==SQLITE_OK ){
7885 pWrite->pTab = pTab;
7887 pWrite->pNext = p->pWrite;
7897 static int idxProcessOneTrigger(
7902 static const char *zInt = UNIQUE_TABLE_NAME;
7903 static const char *zDrop = "DROP TABLE " UNIQUE_TABLE_NAME;
7904 IdxTable *pTab = pWrite->pTab;
7905 const char *zTab = pTab->zName;
7907 "SELECT 'CREATE TEMP' || substr(sql, 7) FROM sqlite_master "
7908 "WHERE tbl_name = %Q AND type IN ('table', 'trigger') "
7910 sqlite3_stmt *pSelect = 0;
7914 /* Create the table and its triggers in the temp schema */
7915 rc = idxPrintfPrepareStmt(p->db, &pSelect, pzErr, zSql, zTab, zTab);
7916 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSelect) ){
7917 const char *zCreate = (const char*)sqlite3_column_text(pSelect, 0);
7918 rc = sqlite3_exec(p->dbv, zCreate, 0, 0, pzErr);
7920 idxFinalize(&rc, pSelect);
7922 /* Rename the table in the temp schema to zInt */
7923 if( rc==SQLITE_OK ){
7924 char *z = sqlite3_mprintf("ALTER TABLE temp.%Q RENAME TO %Q", zTab, zInt);
7928 rc = sqlite3_exec(p->dbv, z, 0, 0, pzErr);
7933 switch( pWrite->eOp ){
7934 case SQLITE_INSERT: {
7936 zWrite = idxAppendText(&rc, zWrite, "INSERT INTO %Q VALUES(", zInt);
7937 for(i=0; i<pTab->nCol; i++){
7938 zWrite = idxAppendText(&rc, zWrite, "%s?", i==0 ? "" : ", ");
7940 zWrite = idxAppendText(&rc, zWrite, ")");
7943 case SQLITE_UPDATE: {
7945 zWrite = idxAppendText(&rc, zWrite, "UPDATE %Q SET ", zInt);
7946 for(i=0; i<pTab->nCol; i++){
7947 zWrite = idxAppendText(&rc, zWrite, "%s%Q=?", i==0 ? "" : ", ",
7954 assert( pWrite->eOp==SQLITE_DELETE );
7955 if( rc==SQLITE_OK ){
7956 zWrite = sqlite3_mprintf("DELETE FROM %Q", zInt);
7957 if( zWrite==0 ) rc = SQLITE_NOMEM;
7962 if( rc==SQLITE_OK ){
7963 sqlite3_stmt *pX = 0;
7964 rc = sqlite3_prepare_v2(p->dbv, zWrite, -1, &pX, 0);
7965 idxFinalize(&rc, pX);
7966 if( rc!=SQLITE_OK ){
7967 idxDatabaseError(p->dbv, pzErr);
7970 sqlite3_free(zWrite);
7972 if( rc==SQLITE_OK ){
7973 rc = sqlite3_exec(p->dbv, zDrop, 0, 0, pzErr);
7979 static int idxProcessTriggers(sqlite3expert *p, char **pzErr){
7982 IdxWrite *pFirst = p->pWrite;
7984 while( rc==SQLITE_OK && pFirst!=pEnd ){
7986 for(pIter=pFirst; rc==SQLITE_OK && pIter!=pEnd; pIter=pIter->pNext){
7987 rc = idxProcessOneTrigger(p, pIter, pzErr);
7997 static int idxCreateVtabSchema(sqlite3expert *p, char **pzErrmsg){
7998 int rc = idxRegisterVtab(p);
7999 sqlite3_stmt *pSchema = 0;
8001 /* For each table in the main db schema:
8003 ** 1) Add an entry to the p->pTable list, and
8004 ** 2) Create the equivalent virtual table in dbv.
8006 rc = idxPrepareStmt(p->db, &pSchema, pzErrmsg,
8007 "SELECT type, name, sql, 1 FROM sqlite_master "
8008 "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%%' "
8010 "SELECT type, name, sql, 2 FROM sqlite_master "
8011 "WHERE type = 'trigger'"
8012 " AND tbl_name IN(SELECT name FROM sqlite_master WHERE type = 'view') "
8015 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSchema) ){
8016 const char *zType = (const char*)sqlite3_column_text(pSchema, 0);
8017 const char *zName = (const char*)sqlite3_column_text(pSchema, 1);
8018 const char *zSql = (const char*)sqlite3_column_text(pSchema, 2);
8020 if( zType[0]=='v' || zType[1]=='r' ){
8021 rc = sqlite3_exec(p->dbv, zSql, 0, 0, pzErrmsg);
8024 rc = idxGetTableInfo(p->db, zName, &pTab, pzErrmsg);
8025 if( rc==SQLITE_OK ){
8029 pTab->pNext = p->pTable;
8032 /* The statement the vtab will pass to sqlite3_declare_vtab() */
8033 zInner = idxAppendText(&rc, 0, "CREATE TABLE x(");
8034 for(i=0; i<pTab->nCol; i++){
8035 zInner = idxAppendText(&rc, zInner, "%s%Q COLLATE %s",
8036 (i==0 ? "" : ", "), pTab->aCol[i].zName, pTab->aCol[i].zColl
8039 zInner = idxAppendText(&rc, zInner, ")");
8041 /* The CVT statement to create the vtab */
8042 zOuter = idxAppendText(&rc, 0,
8043 "CREATE VIRTUAL TABLE %Q USING expert(%Q)", zName, zInner
8045 if( rc==SQLITE_OK ){
8046 rc = sqlite3_exec(p->dbv, zOuter, 0, 0, pzErrmsg);
8048 sqlite3_free(zInner);
8049 sqlite3_free(zOuter);
8053 idxFinalize(&rc, pSchema);
8057 struct IdxSampleCtx {
8059 double target; /* Target nRet/nRow value */
8060 double nRow; /* Number of rows seen */
8061 double nRet; /* Number of rows returned */
8064 static void idxSampleFunc(
8065 sqlite3_context *pCtx,
8067 sqlite3_value **argv
8069 struct IdxSampleCtx *p = (struct IdxSampleCtx*)sqlite3_user_data(pCtx);
8077 bRet = (p->nRet / p->nRow) <= p->target;
8080 sqlite3_randomness(2, (void*)&rnd);
8081 bRet = ((int)rnd % 100) <= p->iTarget;
8085 sqlite3_result_int(pCtx, bRet);
8087 p->nRet += (double)bRet;
8093 int eType; /* SQLITE_NULL, INTEGER, REAL, TEXT, BLOB */
8094 i64 iVal; /* SQLITE_INTEGER value */
8095 double rVal; /* SQLITE_FLOAT value */
8096 int nByte; /* Bytes of space allocated at z */
8097 int n; /* Size of buffer z */
8098 char *z; /* SQLITE_TEXT/BLOB value */
8103 ** Implementation of scalar function rem().
8105 static void idxRemFunc(
8106 sqlite3_context *pCtx,
8108 sqlite3_value **argv
8110 struct IdxRemCtx *p = (struct IdxRemCtx*)sqlite3_user_data(pCtx);
8111 struct IdxRemSlot *pSlot;
8115 iSlot = sqlite3_value_int(argv[0]);
8116 assert( iSlot<=p->nSlot );
8117 pSlot = &p->aSlot[iSlot];
8119 switch( pSlot->eType ){
8124 case SQLITE_INTEGER:
8125 sqlite3_result_int64(pCtx, pSlot->iVal);
8129 sqlite3_result_double(pCtx, pSlot->rVal);
8133 sqlite3_result_blob(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT);
8137 sqlite3_result_text(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT);
8141 pSlot->eType = sqlite3_value_type(argv[1]);
8142 switch( pSlot->eType ){
8147 case SQLITE_INTEGER:
8148 pSlot->iVal = sqlite3_value_int64(argv[1]);
8152 pSlot->rVal = sqlite3_value_double(argv[1]);
8157 int nByte = sqlite3_value_bytes(argv[1]);
8158 if( nByte>pSlot->nByte ){
8159 char *zNew = (char*)sqlite3_realloc(pSlot->z, nByte*2);
8161 sqlite3_result_error_nomem(pCtx);
8164 pSlot->nByte = nByte*2;
8168 if( pSlot->eType==SQLITE_BLOB ){
8169 memcpy(pSlot->z, sqlite3_value_blob(argv[1]), nByte);
8171 memcpy(pSlot->z, sqlite3_value_text(argv[1]), nByte);
8178 static int idxLargestIndex(sqlite3 *db, int *pnMax, char **pzErr){
8181 "SELECT max(i.seqno) FROM "
8182 " sqlite_master AS s, "
8183 " pragma_index_list(s.name) AS l, "
8184 " pragma_index_info(l.name) AS i "
8185 "WHERE s.type = 'table'";
8186 sqlite3_stmt *pMax = 0;
8189 rc = idxPrepareStmt(db, &pMax, pzErr, zMax);
8190 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
8191 *pnMax = sqlite3_column_int(pMax, 0) + 1;
8193 idxFinalize(&rc, pMax);
8198 static int idxPopulateOneStat1(
8200 sqlite3_stmt *pIndexXInfo,
8201 sqlite3_stmt *pWriteStat,
8211 sqlite3_stmt *pQuery = 0;
8215 assert( p->iSample>0 );
8217 /* Formulate the query text */
8218 sqlite3_bind_text(pIndexXInfo, 1, zIdx, -1, SQLITE_STATIC);
8219 while( SQLITE_OK==rc && SQLITE_ROW==sqlite3_step(pIndexXInfo) ){
8220 const char *zComma = zCols==0 ? "" : ", ";
8221 const char *zName = (const char*)sqlite3_column_text(pIndexXInfo, 0);
8222 const char *zColl = (const char*)sqlite3_column_text(pIndexXInfo, 1);
8223 zCols = idxAppendText(&rc, zCols,
8224 "%sx.%Q IS rem(%d, x.%Q) COLLATE %s", zComma, zName, nCol, zName, zColl
8226 zOrder = idxAppendText(&rc, zOrder, "%s%d", zComma, ++nCol);
8228 sqlite3_reset(pIndexXInfo);
8229 if( rc==SQLITE_OK ){
8230 if( p->iSample==100 ){
8231 zQuery = sqlite3_mprintf(
8232 "SELECT %s FROM %Q x ORDER BY %s", zCols, zTab, zOrder
8235 zQuery = sqlite3_mprintf(
8236 "SELECT %s FROM temp."UNIQUE_TABLE_NAME" x ORDER BY %s", zCols, zOrder
8240 sqlite3_free(zCols);
8241 sqlite3_free(zOrder);
8243 /* Formulate the query text */
8244 if( rc==SQLITE_OK ){
8245 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv);
8246 rc = idxPrepareStmt(dbrem, &pQuery, pzErr, zQuery);
8248 sqlite3_free(zQuery);
8250 if( rc==SQLITE_OK ){
8251 aStat = (int*)idxMalloc(&rc, sizeof(int)*(nCol+1));
8253 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){
8254 IdxHashEntry *pEntry;
8256 for(i=0; i<=nCol; i++) aStat[i] = 1;
8257 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){
8259 for(i=0; i<nCol; i++){
8260 if( sqlite3_column_int(pQuery, i)==0 ) break;
8262 for(/*no-op*/; i<nCol; i++){
8267 if( rc==SQLITE_OK ){
8269 zStat = sqlite3_mprintf("%d", s0);
8270 if( zStat==0 ) rc = SQLITE_NOMEM;
8271 for(i=1; rc==SQLITE_OK && i<=nCol; i++){
8272 zStat = idxAppendText(&rc, zStat, " %d", (s0+aStat[i]/2) / aStat[i]);
8276 if( rc==SQLITE_OK ){
8277 sqlite3_bind_text(pWriteStat, 1, zTab, -1, SQLITE_STATIC);
8278 sqlite3_bind_text(pWriteStat, 2, zIdx, -1, SQLITE_STATIC);
8279 sqlite3_bind_text(pWriteStat, 3, zStat, -1, SQLITE_STATIC);
8280 sqlite3_step(pWriteStat);
8281 rc = sqlite3_reset(pWriteStat);
8284 pEntry = idxHashFind(&p->hIdx, zIdx, STRLEN(zIdx));
8286 assert( pEntry->zVal2==0 );
8287 pEntry->zVal2 = zStat;
8289 sqlite3_free(zStat);
8292 sqlite3_free(aStat);
8293 idxFinalize(&rc, pQuery);
8298 static int idxBuildSampleTable(sqlite3expert *p, const char *zTab){
8302 rc = sqlite3_exec(p->dbv,"DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0);
8303 if( rc!=SQLITE_OK ) return rc;
8305 zSql = sqlite3_mprintf(
8306 "CREATE TABLE temp." UNIQUE_TABLE_NAME " AS SELECT * FROM %Q", zTab
8308 if( zSql==0 ) return SQLITE_NOMEM;
8309 rc = sqlite3_exec(p->dbv, zSql, 0, 0, 0);
8316 ** This function is called as part of sqlite3_expert_analyze(). Candidate
8317 ** indexes have already been created in database sqlite3expert.dbm, this
8318 ** function populates sqlite_stat1 table in the same database.
8320 ** The stat1 data is generated by querying the
8322 static int idxPopulateStat1(sqlite3expert *p, char **pzErr){
8325 struct IdxRemCtx *pCtx = 0;
8326 struct IdxSampleCtx samplectx;
8328 i64 iPrev = -100000;
8329 sqlite3_stmt *pAllIndex = 0;
8330 sqlite3_stmt *pIndexXInfo = 0;
8331 sqlite3_stmt *pWrite = 0;
8333 const char *zAllIndex =
8334 "SELECT s.rowid, s.name, l.name FROM "
8335 " sqlite_master AS s, "
8336 " pragma_index_list(s.name) AS l "
8337 "WHERE s.type = 'table'";
8338 const char *zIndexXInfo =
8339 "SELECT name, coll FROM pragma_index_xinfo(?) WHERE key";
8340 const char *zWrite = "INSERT INTO sqlite_stat1 VALUES(?, ?, ?)";
8342 /* If iSample==0, no sqlite_stat1 data is required. */
8343 if( p->iSample==0 ) return SQLITE_OK;
8345 rc = idxLargestIndex(p->dbm, &nMax, pzErr);
8346 if( nMax<=0 || rc!=SQLITE_OK ) return rc;
8348 rc = sqlite3_exec(p->dbm, "ANALYZE; PRAGMA writable_schema=1", 0, 0, 0);
8350 if( rc==SQLITE_OK ){
8351 int nByte = sizeof(struct IdxRemCtx) + (sizeof(struct IdxRemSlot) * nMax);
8352 pCtx = (struct IdxRemCtx*)idxMalloc(&rc, nByte);
8355 if( rc==SQLITE_OK ){
8356 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv);
8357 rc = sqlite3_create_function(
8358 dbrem, "rem", 2, SQLITE_UTF8, (void*)pCtx, idxRemFunc, 0, 0
8361 if( rc==SQLITE_OK ){
8362 rc = sqlite3_create_function(
8363 p->db, "sample", 0, SQLITE_UTF8, (void*)&samplectx, idxSampleFunc, 0, 0
8367 if( rc==SQLITE_OK ){
8368 pCtx->nSlot = nMax+1;
8369 rc = idxPrepareStmt(p->dbm, &pAllIndex, pzErr, zAllIndex);
8371 if( rc==SQLITE_OK ){
8372 rc = idxPrepareStmt(p->dbm, &pIndexXInfo, pzErr, zIndexXInfo);
8374 if( rc==SQLITE_OK ){
8375 rc = idxPrepareStmt(p->dbm, &pWrite, pzErr, zWrite);
8378 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pAllIndex) ){
8379 i64 iRowid = sqlite3_column_int64(pAllIndex, 0);
8380 const char *zTab = (const char*)sqlite3_column_text(pAllIndex, 1);
8381 const char *zIdx = (const char*)sqlite3_column_text(pAllIndex, 2);
8382 if( p->iSample<100 && iPrev!=iRowid ){
8383 samplectx.target = (double)p->iSample / 100.0;
8384 samplectx.iTarget = p->iSample;
8385 samplectx.nRow = 0.0;
8386 samplectx.nRet = 0.0;
8387 rc = idxBuildSampleTable(p, zTab);
8388 if( rc!=SQLITE_OK ) break;
8390 rc = idxPopulateOneStat1(p, pIndexXInfo, pWrite, zTab, zIdx, pzErr);
8393 if( rc==SQLITE_OK && p->iSample<100 ){
8394 rc = sqlite3_exec(p->dbv,
8395 "DROP TABLE IF EXISTS temp." UNIQUE_TABLE_NAME, 0,0,0
8399 idxFinalize(&rc, pAllIndex);
8400 idxFinalize(&rc, pIndexXInfo);
8401 idxFinalize(&rc, pWrite);
8403 for(i=0; i<pCtx->nSlot; i++){
8404 sqlite3_free(pCtx->aSlot[i].z);
8408 if( rc==SQLITE_OK ){
8409 rc = sqlite3_exec(p->dbm, "ANALYZE sqlite_master", 0, 0, 0);
8412 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0);
8417 ** Allocate a new sqlite3expert object.
8419 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErrmsg){
8421 sqlite3expert *pNew;
8423 pNew = (sqlite3expert*)idxMalloc(&rc, sizeof(sqlite3expert));
8425 /* Open two in-memory databases to work with. The "vtab database" (dbv)
8426 ** will contain a virtual table corresponding to each real table in
8427 ** the user database schema, and a copy of each view. It is used to
8428 ** collect information regarding the WHERE, ORDER BY and other clauses
8429 ** of the user's query.
8431 if( rc==SQLITE_OK ){
8433 pNew->iSample = 100;
8434 rc = sqlite3_open(":memory:", &pNew->dbv);
8436 if( rc==SQLITE_OK ){
8437 rc = sqlite3_open(":memory:", &pNew->dbm);
8438 if( rc==SQLITE_OK ){
8439 sqlite3_db_config(pNew->dbm, SQLITE_DBCONFIG_TRIGGER_EQP, 1, (int*)0);
8444 /* Copy the entire schema of database [db] into [dbm]. */
8445 if( rc==SQLITE_OK ){
8447 rc = idxPrintfPrepareStmt(pNew->db, &pSql, pzErrmsg,
8448 "SELECT sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%%'"
8449 " AND sql NOT LIKE 'CREATE VIRTUAL %%'"
8451 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
8452 const char *zSql = (const char*)sqlite3_column_text(pSql, 0);
8453 rc = sqlite3_exec(pNew->dbm, zSql, 0, 0, pzErrmsg);
8455 idxFinalize(&rc, pSql);
8458 /* Create the vtab schema */
8459 if( rc==SQLITE_OK ){
8460 rc = idxCreateVtabSchema(pNew, pzErrmsg);
8463 /* Register the auth callback with dbv */
8464 if( rc==SQLITE_OK ){
8465 sqlite3_set_authorizer(pNew->dbv, idxAuthCallback, (void*)pNew);
8468 /* If an error has occurred, free the new object and reutrn NULL. Otherwise,
8469 ** return the new sqlite3expert handle. */
8470 if( rc!=SQLITE_OK ){
8471 sqlite3_expert_destroy(pNew);
8478 ** Configure an sqlite3expert object.
8480 int sqlite3_expert_config(sqlite3expert *p, int op, ...){
8485 case EXPERT_CONFIG_SAMPLE: {
8486 int iVal = va_arg(ap, int);
8487 if( iVal<0 ) iVal = 0;
8488 if( iVal>100 ) iVal = 100;
8493 rc = SQLITE_NOTFOUND;
8502 ** Add an SQL statement to the analysis.
8504 int sqlite3_expert_sql(
8505 sqlite3expert *p, /* From sqlite3_expert_new() */
8506 const char *zSql, /* SQL statement to add */
8507 char **pzErr /* OUT: Error message (if any) */
8509 IdxScan *pScanOrig = p->pScan;
8510 IdxStatement *pStmtOrig = p->pStatement;
8512 const char *zStmt = zSql;
8514 if( p->bRun ) return SQLITE_MISUSE;
8516 while( rc==SQLITE_OK && zStmt && zStmt[0] ){
8517 sqlite3_stmt *pStmt = 0;
8518 rc = sqlite3_prepare_v2(p->dbv, zStmt, -1, &pStmt, &zStmt);
8519 if( rc==SQLITE_OK ){
8522 const char *z = sqlite3_sql(pStmt);
8524 pNew = (IdxStatement*)idxMalloc(&rc, sizeof(IdxStatement) + n+1);
8525 if( rc==SQLITE_OK ){
8526 pNew->zSql = (char*)&pNew[1];
8527 memcpy(pNew->zSql, z, n+1);
8528 pNew->pNext = p->pStatement;
8529 if( p->pStatement ) pNew->iId = p->pStatement->iId+1;
8530 p->pStatement = pNew;
8532 sqlite3_finalize(pStmt);
8535 idxDatabaseError(p->dbv, pzErr);
8539 if( rc!=SQLITE_OK ){
8540 idxScanFree(p->pScan, pScanOrig);
8541 idxStatementFree(p->pStatement, pStmtOrig);
8542 p->pScan = pScanOrig;
8543 p->pStatement = pStmtOrig;
8549 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr){
8551 IdxHashEntry *pEntry;
8553 /* Do trigger processing to collect any extra IdxScan structures */
8554 rc = idxProcessTriggers(p, pzErr);
8556 /* Create candidate indexes within the in-memory database file */
8557 if( rc==SQLITE_OK ){
8558 rc = idxCreateCandidates(p);
8561 /* Generate the stat1 data */
8562 if( rc==SQLITE_OK ){
8563 rc = idxPopulateStat1(p, pzErr);
8566 /* Formulate the EXPERT_REPORT_CANDIDATES text */
8567 for(pEntry=p->hIdx.pFirst; pEntry; pEntry=pEntry->pNext){
8568 p->zCandidates = idxAppendText(&rc, p->zCandidates,
8569 "%s;%s%s\n", pEntry->zVal,
8570 pEntry->zVal2 ? " -- stat1: " : "", pEntry->zVal2
8574 /* Figure out which of the candidate indexes are preferred by the query
8575 ** planner and report the results to the user. */
8576 if( rc==SQLITE_OK ){
8577 rc = idxFindIndexes(p, pzErr);
8580 if( rc==SQLITE_OK ){
8587 ** Return the total number of statements that have been added to this
8588 ** sqlite3expert using sqlite3_expert_sql().
8590 int sqlite3_expert_count(sqlite3expert *p){
8592 if( p->pStatement ) nRet = p->pStatement->iId+1;
8597 ** Return a component of the report.
8599 const char *sqlite3_expert_report(sqlite3expert *p, int iStmt, int eReport){
8600 const char *zRet = 0;
8601 IdxStatement *pStmt;
8603 if( p->bRun==0 ) return 0;
8604 for(pStmt=p->pStatement; pStmt && pStmt->iId!=iStmt; pStmt=pStmt->pNext);
8606 case EXPERT_REPORT_SQL:
8607 if( pStmt ) zRet = pStmt->zSql;
8609 case EXPERT_REPORT_INDEXES:
8610 if( pStmt ) zRet = pStmt->zIdx;
8612 case EXPERT_REPORT_PLAN:
8613 if( pStmt ) zRet = pStmt->zEQP;
8615 case EXPERT_REPORT_CANDIDATES:
8616 zRet = p->zCandidates;
8623 ** Free an sqlite3expert object.
8625 void sqlite3_expert_destroy(sqlite3expert *p){
8627 sqlite3_close(p->dbm);
8628 sqlite3_close(p->dbv);
8629 idxScanFree(p->pScan, 0);
8630 idxStatementFree(p->pStatement, 0);
8631 idxTableFree(p->pTable);
8632 idxWriteFree(p->pWrite);
8633 idxHashClear(&p->hIdx);
8634 sqlite3_free(p->zCandidates);
8639 #endif /* ifndef SQLITE_OMIT_VIRTUAL_TABLE */
8641 /************************* End ../ext/expert/sqlite3expert.c ********************/
8643 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
8644 /************************* Begin ../ext/misc/dbdata.c ******************/
8648 ** The author disclaims copyright to this source code. In place of
8649 ** a legal notice, here is a blessing:
8651 ** May you do good and not evil.
8652 ** May you find forgiveness for yourself and forgive others.
8653 ** May you share freely, never taking more than you give.
8655 ******************************************************************************
8657 ** This file contains an implementation of two eponymous virtual tables,
8658 ** "sqlite_dbdata" and "sqlite_dbptr". Both modules require that the
8659 ** "sqlite_dbpage" eponymous virtual table be available.
8662 ** sqlite_dbdata is used to extract data directly from a database b-tree
8663 ** page and its associated overflow pages, bypassing the b-tree layer.
8664 ** The table schema is equivalent to:
8666 ** CREATE TABLE sqlite_dbdata(
8671 ** schema TEXT HIDDEN
8674 ** IMPORTANT: THE VIRTUAL TABLE SCHEMA ABOVE IS SUBJECT TO CHANGE. IN THE
8675 ** FUTURE NEW NON-HIDDEN COLUMNS MAY BE ADDED BETWEEN "value" AND
8678 ** Each page of the database is inspected. If it cannot be interpreted as
8679 ** a b-tree page, or if it is a b-tree page containing 0 entries, the
8680 ** sqlite_dbdata table contains no rows for that page. Otherwise, the
8681 ** table contains one row for each field in the record associated with
8682 ** each cell on the page. For intkey b-trees, the key value is stored in
8685 ** For example, for the database:
8687 ** CREATE TABLE t1(a, b); -- root page is page 2
8688 ** INSERT INTO t1(rowid, a, b) VALUES(5, 'v', 'five');
8689 ** INSERT INTO t1(rowid, a, b) VALUES(10, 'x', 'ten');
8691 ** the sqlite_dbdata table contains, as well as from entries related to
8692 ** page 1, content equivalent to:
8694 ** INSERT INTO sqlite_dbdata(pgno, cell, field, value) VALUES
8697 ** (2, 0, 1, 'five'),
8700 ** (2, 1, 1, 'ten' );
8702 ** If database corruption is encountered, this module does not report an
8703 ** error. Instead, it attempts to extract as much data as possible and
8704 ** ignores the corruption.
8707 ** The sqlite_dbptr table has the following schema:
8709 ** CREATE TABLE sqlite_dbptr(
8712 ** schema TEXT HIDDEN
8715 ** It contains one entry for each b-tree pointer between a parent and
8716 ** child page in the database.
8718 #if !defined(SQLITEINT_H)
8719 /* #include "sqlite3ext.h" */
8721 /* typedef unsigned char u8; */
8724 SQLITE_EXTENSION_INIT1
8728 #define DBDATA_PADDING_BYTES 100
8730 typedef struct DbdataTable DbdataTable;
8731 typedef struct DbdataCursor DbdataCursor;
8734 struct DbdataCursor {
8735 sqlite3_vtab_cursor base; /* Base class. Must be first */
8736 sqlite3_stmt *pStmt; /* For fetching database pages */
8738 int iPgno; /* Current page number */
8739 u8 *aPage; /* Buffer containing page */
8740 int nPage; /* Size of aPage[] in bytes */
8741 int nCell; /* Number of cells on aPage[] */
8742 int iCell; /* Current cell number */
8743 int bOnePage; /* True to stop after one page */
8745 sqlite3_int64 iRowid;
8747 /* Only for the sqlite_dbdata table */
8748 u8 *pRec; /* Buffer containing current record */
8749 int nRec; /* Size of pRec[] in bytes */
8750 int nHdr; /* Size of header in bytes */
8751 int iField; /* Current field number */
8755 sqlite3_int64 iIntkey; /* Integer key value */
8759 struct DbdataTable {
8760 sqlite3_vtab base; /* Base class. Must be first */
8761 sqlite3 *db; /* The database connection */
8762 sqlite3_stmt *pStmt; /* For fetching database pages */
8763 int bPtr; /* True for sqlite3_dbptr table */
8766 /* Column and schema definitions for sqlite_dbdata */
8767 #define DBDATA_COLUMN_PGNO 0
8768 #define DBDATA_COLUMN_CELL 1
8769 #define DBDATA_COLUMN_FIELD 2
8770 #define DBDATA_COLUMN_VALUE 3
8771 #define DBDATA_COLUMN_SCHEMA 4
8772 #define DBDATA_SCHEMA \
8778 " schema TEXT HIDDEN" \
8781 /* Column and schema definitions for sqlite_dbptr */
8782 #define DBPTR_COLUMN_PGNO 0
8783 #define DBPTR_COLUMN_CHILD 1
8784 #define DBPTR_COLUMN_SCHEMA 2
8785 #define DBPTR_SCHEMA \
8789 " schema TEXT HIDDEN" \
8793 ** Connect to an sqlite_dbdata (pAux==0) or sqlite_dbptr (pAux!=0) virtual
8796 static int dbdataConnect(
8799 int argc, const char *const*argv,
8800 sqlite3_vtab **ppVtab,
8803 DbdataTable *pTab = 0;
8804 int rc = sqlite3_declare_vtab(db, pAux ? DBPTR_SCHEMA : DBDATA_SCHEMA);
8806 if( rc==SQLITE_OK ){
8807 pTab = (DbdataTable*)sqlite3_malloc64(sizeof(DbdataTable));
8811 memset(pTab, 0, sizeof(DbdataTable));
8813 pTab->bPtr = (pAux!=0);
8817 *ppVtab = (sqlite3_vtab*)pTab;
8822 ** Disconnect from or destroy a sqlite_dbdata or sqlite_dbptr virtual table.
8824 static int dbdataDisconnect(sqlite3_vtab *pVtab){
8825 DbdataTable *pTab = (DbdataTable*)pVtab;
8827 sqlite3_finalize(pTab->pStmt);
8828 sqlite3_free(pVtab);
8834 ** This function interprets two types of constraints:
8839 ** If neither are present, idxNum is set to 0. If schema=? is present,
8840 ** the 0x01 bit in idxNum is set. If pgno=? is present, the 0x02 bit
8841 ** in idxNum is set.
8843 ** If both parameters are present, schema is in position 0 and pgno in
8846 static int dbdataBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdx){
8847 DbdataTable *pTab = (DbdataTable*)tab;
8851 int colSchema = (pTab->bPtr ? DBPTR_COLUMN_SCHEMA : DBDATA_COLUMN_SCHEMA);
8853 for(i=0; i<pIdx->nConstraint; i++){
8854 struct sqlite3_index_constraint *p = &pIdx->aConstraint[i];
8855 if( p->op==SQLITE_INDEX_CONSTRAINT_EQ ){
8856 if( p->iColumn==colSchema ){
8857 if( p->usable==0 ) return SQLITE_CONSTRAINT;
8860 if( p->iColumn==DBDATA_COLUMN_PGNO && p->usable ){
8867 pIdx->aConstraintUsage[iSchema].argvIndex = 1;
8868 pIdx->aConstraintUsage[iSchema].omit = 1;
8871 pIdx->aConstraintUsage[iPgno].argvIndex = 1 + (iSchema>=0);
8872 pIdx->aConstraintUsage[iPgno].omit = 1;
8873 pIdx->estimatedCost = 100;
8874 pIdx->estimatedRows = 50;
8876 if( pTab->bPtr==0 && pIdx->nOrderBy && pIdx->aOrderBy[0].desc==0 ){
8877 int iCol = pIdx->aOrderBy[0].iColumn;
8878 if( pIdx->nOrderBy==1 ){
8879 pIdx->orderByConsumed = (iCol==0 || iCol==1);
8880 }else if( pIdx->nOrderBy==2 && pIdx->aOrderBy[1].desc==0 && iCol==0 ){
8881 pIdx->orderByConsumed = (pIdx->aOrderBy[1].iColumn==1);
8886 pIdx->estimatedCost = 100000000;
8887 pIdx->estimatedRows = 1000000000;
8889 pIdx->idxNum = (iSchema>=0 ? 0x01 : 0x00) | (iPgno>=0 ? 0x02 : 0x00);
8894 ** Open a new sqlite_dbdata or sqlite_dbptr cursor.
8896 static int dbdataOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
8899 pCsr = (DbdataCursor*)sqlite3_malloc64(sizeof(DbdataCursor));
8901 return SQLITE_NOMEM;
8903 memset(pCsr, 0, sizeof(DbdataCursor));
8904 pCsr->base.pVtab = pVTab;
8907 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
8912 ** Restore a cursor object to the state it was in when first allocated
8915 static void dbdataResetCursor(DbdataCursor *pCsr){
8916 DbdataTable *pTab = (DbdataTable*)(pCsr->base.pVtab);
8917 if( pTab->pStmt==0 ){
8918 pTab->pStmt = pCsr->pStmt;
8920 sqlite3_finalize(pCsr->pStmt);
8927 sqlite3_free(pCsr->aPage);
8928 sqlite3_free(pCsr->pRec);
8934 ** Close an sqlite_dbdata or sqlite_dbptr cursor.
8936 static int dbdataClose(sqlite3_vtab_cursor *pCursor){
8937 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
8938 dbdataResetCursor(pCsr);
8944 ** Utility methods to decode 16 and 32-bit big-endian unsigned integers.
8946 static unsigned int get_uint16(unsigned char *a){
8947 return (a[0]<<8)|a[1];
8949 static unsigned int get_uint32(unsigned char *a){
8950 return ((unsigned int)a[0]<<24)
8951 | ((unsigned int)a[1]<<16)
8952 | ((unsigned int)a[2]<<8)
8953 | ((unsigned int)a[3]);
8957 ** Load page pgno from the database via the sqlite_dbpage virtual table.
8958 ** If successful, set (*ppPage) to point to a buffer containing the page
8959 ** data, (*pnPage) to the size of that buffer in bytes and return
8960 ** SQLITE_OK. In this case it is the responsibility of the caller to
8961 ** eventually free the buffer using sqlite3_free().
8963 ** Or, if an error occurs, set both (*ppPage) and (*pnPage) to 0 and
8964 ** return an SQLite error code.
8966 static int dbdataLoadPage(
8967 DbdataCursor *pCsr, /* Cursor object */
8968 unsigned int pgno, /* Page number of page to load */
8969 u8 **ppPage, /* OUT: pointer to page buffer */
8970 int *pnPage /* OUT: Size of (*ppPage) in bytes */
8974 sqlite3_stmt *pStmt = pCsr->pStmt;
8978 sqlite3_bind_int64(pStmt, 2, pgno);
8979 if( SQLITE_ROW==sqlite3_step(pStmt) ){
8980 int nCopy = sqlite3_column_bytes(pStmt, 0);
8983 pPage = (u8*)sqlite3_malloc64(nCopy + DBDATA_PADDING_BYTES);
8987 const u8 *pCopy = sqlite3_column_blob(pStmt, 0);
8988 memcpy(pPage, pCopy, nCopy);
8989 memset(&pPage[nCopy], 0, DBDATA_PADDING_BYTES);
8995 rc2 = sqlite3_reset(pStmt);
8996 if( rc==SQLITE_OK ) rc = rc2;
9002 ** Read a varint. Put the value in *pVal and return the number of bytes.
9004 static int dbdataGetVarint(const u8 *z, sqlite3_int64 *pVal){
9005 sqlite3_int64 v = 0;
9008 v = (v<<7) + (z[i]&0x7f);
9009 if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; }
9011 v = (v<<8) + (z[i]&0xff);
9017 ** Return the number of bytes of space used by an SQLite value of type
9020 static int dbdataValueBytes(int eType){
9022 case 0: case 8: case 9:
9040 return ((eType-12) / 2);
9047 ** Load a value of type eType from buffer pData and use it to set the
9048 ** result of context object pCtx.
9050 static void dbdataValue(
9051 sqlite3_context *pCtx,
9056 if( eType>=0 && dbdataValueBytes(eType)<=nData ){
9061 sqlite3_result_null(pCtx);
9065 sqlite3_result_int(pCtx, 0);
9068 sqlite3_result_int(pCtx, 1);
9071 case 1: case 2: case 3: case 4: case 5: case 6: case 7: {
9072 sqlite3_uint64 v = (signed char)pData[0];
9076 case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
9077 case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
9078 case 4: v = (v<<8) + pData[0]; pData++;
9079 case 3: v = (v<<8) + pData[0]; pData++;
9080 case 2: v = (v<<8) + pData[0]; pData++;
9085 memcpy(&r, &v, sizeof(r));
9086 sqlite3_result_double(pCtx, r);
9088 sqlite3_result_int64(pCtx, (sqlite3_int64)v);
9094 int n = ((eType-12) / 2);
9096 sqlite3_result_text(pCtx, (const char*)pData, n, SQLITE_TRANSIENT);
9098 sqlite3_result_blob(pCtx, pData, n, SQLITE_TRANSIENT);
9106 ** Move an sqlite_dbdata or sqlite_dbptr cursor to the next entry.
9108 static int dbdataNext(sqlite3_vtab_cursor *pCursor){
9109 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9110 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab;
9115 int iOff = (pCsr->iPgno==1 ? 100 : 0);
9118 if( pCsr->aPage==0 ){
9120 if( pCsr->bOnePage==0 && pCsr->iPgno>pCsr->szDb ) return SQLITE_OK;
9121 rc = dbdataLoadPage(pCsr, pCsr->iPgno, &pCsr->aPage, &pCsr->nPage);
9122 if( rc!=SQLITE_OK ) return rc;
9123 if( pCsr->aPage ) break;
9126 pCsr->iCell = pTab->bPtr ? -2 : 0;
9127 pCsr->nCell = get_uint16(&pCsr->aPage[iOff+3]);
9131 if( pCsr->aPage[iOff]!=0x02 && pCsr->aPage[iOff]!=0x05 ){
9132 pCsr->iCell = pCsr->nCell;
9135 if( pCsr->iCell>=pCsr->nCell ){
9136 sqlite3_free(pCsr->aPage);
9138 if( pCsr->bOnePage ) return SQLITE_OK;
9144 /* If there is no record loaded, load it now. */
9145 if( pCsr->pRec==0 ){
9148 sqlite3_int64 nPayload = 0;
9149 sqlite3_int64 nHdr = 0;
9154 switch( pCsr->aPage[iOff] ){
9164 /* This is not a b-tree page with records on it. Continue. */
9165 pCsr->iCell = pCsr->nCell;
9169 if( pCsr->iCell>=pCsr->nCell ){
9173 iOff += 8 + nPointer + pCsr->iCell*2;
9174 if( iOff>pCsr->nPage ){
9177 iOff = get_uint16(&pCsr->aPage[iOff]);
9180 /* For an interior node cell, skip past the child-page number */
9183 /* Load the "byte of payload including overflow" field */
9184 if( bNextPage || iOff>pCsr->nPage ){
9187 iOff += dbdataGetVarint(&pCsr->aPage[iOff], &nPayload);
9190 /* If this is a leaf intkey cell, load the rowid */
9191 if( bHasRowid && !bNextPage && iOff<pCsr->nPage ){
9192 iOff += dbdataGetVarint(&pCsr->aPage[iOff], &pCsr->iIntkey);
9195 /* Figure out how much data to read from the local page */
9200 X = ((U-12)*64/255)-23;
9206 M = ((U-12)*32/255)-23;
9207 K = M+((nPayload-M)%(U-4));
9215 if( bNextPage || nLocal+iOff>pCsr->nPage ){
9219 /* Allocate space for payload. And a bit more to catch small buffer
9220 ** overruns caused by attempting to read a varint or similar from
9221 ** near the end of a corrupt record. */
9222 pCsr->pRec = (u8*)sqlite3_malloc64(nPayload+DBDATA_PADDING_BYTES);
9223 if( pCsr->pRec==0 ) return SQLITE_NOMEM;
9224 memset(pCsr->pRec, 0, nPayload+DBDATA_PADDING_BYTES);
9225 pCsr->nRec = nPayload;
9227 /* Load the nLocal bytes of payload */
9228 memcpy(pCsr->pRec, &pCsr->aPage[iOff], nLocal);
9231 /* Load content from overflow pages */
9232 if( nPayload>nLocal ){
9233 sqlite3_int64 nRem = nPayload - nLocal;
9234 unsigned int pgnoOvfl = get_uint32(&pCsr->aPage[iOff]);
9239 rc = dbdataLoadPage(pCsr, pgnoOvfl, &aOvfl, &nOvfl);
9240 assert( rc!=SQLITE_OK || aOvfl==0 || nOvfl==pCsr->nPage );
9241 if( rc!=SQLITE_OK ) return rc;
9242 if( aOvfl==0 ) break;
9245 if( nCopy>nRem ) nCopy = nRem;
9246 memcpy(&pCsr->pRec[nPayload-nRem], &aOvfl[4], nCopy);
9249 pgnoOvfl = get_uint32(aOvfl);
9250 sqlite3_free(aOvfl);
9254 iHdr = dbdataGetVarint(pCsr->pRec, &nHdr);
9256 pCsr->pHdrPtr = &pCsr->pRec[iHdr];
9257 pCsr->pPtr = &pCsr->pRec[pCsr->nHdr];
9258 pCsr->iField = (bHasRowid ? -1 : 0);
9263 if( pCsr->iField>0 ){
9264 sqlite3_int64 iType;
9265 if( pCsr->pHdrPtr>&pCsr->pRec[pCsr->nRec] ){
9268 pCsr->pHdrPtr += dbdataGetVarint(pCsr->pHdrPtr, &iType);
9269 pCsr->pPtr += dbdataValueBytes(iType);
9275 sqlite3_free(pCsr->aPage);
9276 sqlite3_free(pCsr->pRec);
9279 if( pCsr->bOnePage ) return SQLITE_OK;
9282 if( pCsr->iField<0 || pCsr->pHdrPtr<&pCsr->pRec[pCsr->nHdr] ){
9286 /* Advance to the next cell. The next iteration of the loop will load
9287 ** the record and so on. */
9288 sqlite3_free(pCsr->pRec);
9295 assert( !"can't get here" );
9300 ** Return true if the cursor is at EOF.
9302 static int dbdataEof(sqlite3_vtab_cursor *pCursor){
9303 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9304 return pCsr->aPage==0;
9308 ** Determine the size in pages of database zSchema (where zSchema is
9309 ** "main", "temp" or the name of an attached database) and set
9310 ** pCsr->szDb accordingly. If successful, return SQLITE_OK. Otherwise,
9311 ** an SQLite error code.
9313 static int dbdataDbsize(DbdataCursor *pCsr, const char *zSchema){
9314 DbdataTable *pTab = (DbdataTable*)pCsr->base.pVtab;
9317 sqlite3_stmt *pStmt = 0;
9319 zSql = sqlite3_mprintf("PRAGMA %Q.page_count", zSchema);
9320 if( zSql==0 ) return SQLITE_NOMEM;
9321 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0);
9323 if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
9324 pCsr->szDb = sqlite3_column_int(pStmt, 0);
9326 rc2 = sqlite3_finalize(pStmt);
9327 if( rc==SQLITE_OK ) rc = rc2;
9332 ** xFilter method for sqlite_dbdata and sqlite_dbptr.
9334 static int dbdataFilter(
9335 sqlite3_vtab_cursor *pCursor,
9336 int idxNum, const char *idxStr,
9337 int argc, sqlite3_value **argv
9339 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9340 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab;
9342 const char *zSchema = "main";
9344 dbdataResetCursor(pCsr);
9345 assert( pCsr->iPgno==1 );
9346 if( idxNum & 0x01 ){
9347 zSchema = (const char*)sqlite3_value_text(argv[0]);
9349 if( idxNum & 0x02 ){
9350 pCsr->iPgno = sqlite3_value_int(argv[(idxNum & 0x01)]);
9353 pCsr->nPage = dbdataDbsize(pCsr, zSchema);
9354 rc = dbdataDbsize(pCsr, zSchema);
9357 if( rc==SQLITE_OK ){
9359 pCsr->pStmt = pTab->pStmt;
9362 rc = sqlite3_prepare_v2(pTab->db,
9363 "SELECT data FROM sqlite_dbpage(?) WHERE pgno=?", -1,
9368 if( rc==SQLITE_OK ){
9369 rc = sqlite3_bind_text(pCsr->pStmt, 1, zSchema, -1, SQLITE_TRANSIENT);
9371 pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db));
9373 if( rc==SQLITE_OK ){
9374 rc = dbdataNext(pCursor);
9380 ** Return a column for the sqlite_dbdata or sqlite_dbptr table.
9382 static int dbdataColumn(
9383 sqlite3_vtab_cursor *pCursor,
9384 sqlite3_context *ctx,
9387 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9388 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab;
9391 case DBPTR_COLUMN_PGNO:
9392 sqlite3_result_int64(ctx, pCsr->iPgno);
9394 case DBPTR_COLUMN_CHILD: {
9395 int iOff = pCsr->iPgno==1 ? 100 : 0;
9396 if( pCsr->iCell<0 ){
9399 iOff += 12 + pCsr->iCell*2;
9400 if( iOff>pCsr->nPage ) return SQLITE_OK;
9401 iOff = get_uint16(&pCsr->aPage[iOff]);
9403 if( iOff<=pCsr->nPage ){
9404 sqlite3_result_int64(ctx, get_uint32(&pCsr->aPage[iOff]));
9411 case DBDATA_COLUMN_PGNO:
9412 sqlite3_result_int64(ctx, pCsr->iPgno);
9414 case DBDATA_COLUMN_CELL:
9415 sqlite3_result_int(ctx, pCsr->iCell);
9417 case DBDATA_COLUMN_FIELD:
9418 sqlite3_result_int(ctx, pCsr->iField);
9420 case DBDATA_COLUMN_VALUE: {
9421 if( pCsr->iField<0 ){
9422 sqlite3_result_int64(ctx, pCsr->iIntkey);
9424 sqlite3_int64 iType;
9425 dbdataGetVarint(pCsr->pHdrPtr, &iType);
9427 ctx, iType, pCsr->pPtr, &pCsr->pRec[pCsr->nRec] - pCsr->pPtr
9438 ** Return the rowid for an sqlite_dbdata or sqlite_dptr table.
9440 static int dbdataRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
9441 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9442 *pRowid = pCsr->iRowid;
9448 ** Invoke this routine to register the "sqlite_dbdata" virtual table module
9450 static int sqlite3DbdataRegister(sqlite3 *db){
9451 static sqlite3_module dbdata_module = {
9454 dbdataConnect, /* xConnect */
9455 dbdataBestIndex, /* xBestIndex */
9456 dbdataDisconnect, /* xDisconnect */
9458 dbdataOpen, /* xOpen - open a cursor */
9459 dbdataClose, /* xClose - close a cursor */
9460 dbdataFilter, /* xFilter - configure scan constraints */
9461 dbdataNext, /* xNext - advance a cursor */
9462 dbdataEof, /* xEof - check for end of scan */
9463 dbdataColumn, /* xColumn - read data */
9464 dbdataRowid, /* xRowid - read data */
9470 0, /* xFindMethod */
9474 0, /* xRollbackTo */
9478 int rc = sqlite3_create_module(db, "sqlite_dbdata", &dbdata_module, 0);
9479 if( rc==SQLITE_OK ){
9480 rc = sqlite3_create_module(db, "sqlite_dbptr", &dbdata_module, (void*)1);
9488 int sqlite3_dbdata_init(
9491 const sqlite3_api_routines *pApi
9493 SQLITE_EXTENSION_INIT2(pApi);
9494 return sqlite3DbdataRegister(db);
9497 /************************* End ../ext/misc/dbdata.c ********************/
9500 #if defined(SQLITE_ENABLE_SESSION)
9502 ** State information for a single open session
9504 typedef struct OpenSession OpenSession;
9505 struct OpenSession {
9506 char *zName; /* Symbolic name for this session */
9507 int nFilter; /* Number of xFilter rejection GLOB patterns */
9508 char **azFilter; /* Array of xFilter rejection GLOB patterns */
9509 sqlite3_session *p; /* The open session */
9514 ** Shell output mode information from before ".explain on",
9515 ** saved so that it can be restored by ".explain off"
9517 typedef struct SavedModeInfo SavedModeInfo;
9518 struct SavedModeInfo {
9519 int valid; /* Is there legit data in here? */
9520 int mode; /* Mode prior to ".explain on" */
9521 int showHeader; /* The ".header" setting prior to ".explain on" */
9522 int colWidth[100]; /* Column widths prior to ".explain on" */
9525 typedef struct ExpertInfo ExpertInfo;
9527 sqlite3expert *pExpert;
9531 /* A single line in the EQP output */
9532 typedef struct EQPGraphRow EQPGraphRow;
9533 struct EQPGraphRow {
9534 int iEqpId; /* ID for this row */
9535 int iParentId; /* ID of the parent row */
9536 EQPGraphRow *pNext; /* Next row in sequence */
9537 char zText[1]; /* Text to display for this row */
9540 /* All EQP output is collected into an instance of the following */
9541 typedef struct EQPGraph EQPGraph;
9543 EQPGraphRow *pRow; /* Linked list of all rows of the EQP output */
9544 EQPGraphRow *pLast; /* Last element of the pRow list */
9545 char zPrefix[100]; /* Graph prefix */
9549 ** State information about the database connection is contained in an
9550 ** instance of the following structure.
9552 typedef struct ShellState ShellState;
9554 sqlite3 *db; /* The database */
9555 u8 autoExplain; /* Automatically turn on .explain mode */
9556 u8 autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
9557 u8 autoEQPtest; /* autoEQP is in test mode */
9558 u8 autoEQPtrace; /* autoEQP is in trace mode */
9559 u8 statsOn; /* True to display memory stats before each finalize */
9560 u8 scanstatsOn; /* True to display scan stats before each finalize */
9561 u8 openMode; /* SHELL_OPEN_NORMAL, _APPENDVFS, or _ZIPFILE */
9562 u8 doXdgOpen; /* Invoke start/open/xdg-open in output_reset() */
9563 u8 nEqpLevel; /* Depth of the EQP output graph */
9564 u8 eTraceType; /* SHELL_TRACE_* value for type of trace */
9565 unsigned mEqpLines; /* Mask of veritical lines in the EQP output graph */
9566 int outCount; /* Revert to stdout when reaching zero */
9567 int cnt; /* Number of records displayed so far */
9568 int lineno; /* Line number of last line read from in */
9569 FILE *in; /* Read commands from this stream */
9570 FILE *out; /* Write results here */
9571 FILE *traceOut; /* Output for sqlite3_trace() */
9572 int nErr; /* Number of errors seen */
9573 int mode; /* An output mode setting */
9574 int modePrior; /* Saved mode */
9575 int cMode; /* temporary output mode for the current query */
9576 int normalMode; /* Output mode before ".explain on" */
9577 int writableSchema; /* True if PRAGMA writable_schema=ON */
9578 int showHeader; /* True to show column names in List or Column mode */
9579 int nCheck; /* Number of ".check" commands run */
9580 unsigned nProgress; /* Number of progress callbacks encountered */
9581 unsigned mxProgress; /* Maximum progress callbacks before failing */
9582 unsigned flgProgress; /* Flags for the progress callback */
9583 unsigned shellFlgs; /* Various flags */
9584 sqlite3_int64 szMax; /* --maxsize argument to .open */
9585 char *zDestTable; /* Name of destination table when MODE_Insert */
9586 char *zTempFile; /* Temporary file that might need deleting */
9587 char zTestcase[30]; /* Name of current test case */
9588 char colSeparator[20]; /* Column separator character for several modes */
9589 char rowSeparator[20]; /* Row separator character for MODE_Ascii */
9590 char colSepPrior[20]; /* Saved column separator */
9591 char rowSepPrior[20]; /* Saved row separator */
9592 int colWidth[100]; /* Requested width of each column when in column mode*/
9593 int actualWidth[100]; /* Actual width of each column */
9594 char nullValue[20]; /* The text to print when a NULL comes back from
9596 char outfile[FILENAME_MAX]; /* Filename for *out */
9597 const char *zDbFilename; /* name of the database file */
9598 char *zFreeOnClose; /* Filename to free when closing */
9599 const char *zVfs; /* Name of VFS to use */
9600 sqlite3_stmt *pStmt; /* Current statement if any. */
9601 FILE *pLog; /* Write log output here */
9602 int *aiIndent; /* Array of indents used in MODE_Explain */
9603 int nIndent; /* Size of array aiIndent[] */
9604 int iIndent; /* Index of current op in aiIndent[] */
9605 EQPGraph sGraph; /* Information for the graphical EXPLAIN QUERY PLAN */
9606 #if defined(SQLITE_ENABLE_SESSION)
9607 int nSession; /* Number of active sessions */
9608 OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */
9610 ExpertInfo expert; /* Valid if previous command was ".expert OPT..." */
9614 /* Allowed values for ShellState.autoEQP
9616 #define AUTOEQP_off 0 /* Automatic EXPLAIN QUERY PLAN is off */
9617 #define AUTOEQP_on 1 /* Automatic EQP is on */
9618 #define AUTOEQP_trigger 2 /* On and also show plans for triggers */
9619 #define AUTOEQP_full 3 /* Show full EXPLAIN */
9621 /* Allowed values for ShellState.openMode
9623 #define SHELL_OPEN_UNSPEC 0 /* No open-mode specified */
9624 #define SHELL_OPEN_NORMAL 1 /* Normal database file */
9625 #define SHELL_OPEN_APPENDVFS 2 /* Use appendvfs */
9626 #define SHELL_OPEN_ZIPFILE 3 /* Use the zipfile virtual table */
9627 #define SHELL_OPEN_READONLY 4 /* Open a normal database read-only */
9628 #define SHELL_OPEN_DESERIALIZE 5 /* Open using sqlite3_deserialize() */
9629 #define SHELL_OPEN_HEXDB 6 /* Use "dbtotxt" output as data source */
9631 /* Allowed values for ShellState.eTraceType
9633 #define SHELL_TRACE_PLAIN 0 /* Show input SQL text */
9634 #define SHELL_TRACE_EXPANDED 1 /* Show expanded SQL text */
9635 #define SHELL_TRACE_NORMALIZED 2 /* Show normalized SQL text */
9637 /* Bits in the ShellState.flgProgress variable */
9638 #define SHELL_PROGRESS_QUIET 0x01 /* Omit announcing every progress callback */
9639 #define SHELL_PROGRESS_RESET 0x02 /* Reset the count when the progres
9640 ** callback limit is reached, and for each
9641 ** top-level SQL statement */
9642 #define SHELL_PROGRESS_ONCE 0x04 /* Cancel the --limit after firing once */
9645 ** These are the allowed shellFlgs values
9647 #define SHFLG_Pagecache 0x00000001 /* The --pagecache option is used */
9648 #define SHFLG_Lookaside 0x00000002 /* Lookaside memory is used */
9649 #define SHFLG_Backslash 0x00000004 /* The --backslash option is used */
9650 #define SHFLG_PreserveRowid 0x00000008 /* .dump preserves rowid values */
9651 #define SHFLG_Newlines 0x00000010 /* .dump --newline flag */
9652 #define SHFLG_CountChanges 0x00000020 /* .changes setting */
9653 #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
9656 ** Macros for testing and setting shellFlgs
9658 #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
9659 #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
9660 #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
9663 ** These are the allowed modes.
9665 #define MODE_Line 0 /* One column per line. Blank line between records */
9666 #define MODE_Column 1 /* One record per line in neat columns */
9667 #define MODE_List 2 /* One record per line with a separator */
9668 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
9669 #define MODE_Html 4 /* Generate an XHTML table */
9670 #define MODE_Insert 5 /* Generate SQL "insert" statements */
9671 #define MODE_Quote 6 /* Quote values as for SQL */
9672 #define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */
9673 #define MODE_Csv 8 /* Quote strings, numbers are plain */
9674 #define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */
9675 #define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */
9676 #define MODE_Pretty 11 /* Pretty-print schemas */
9677 #define MODE_EQP 12 /* Converts EXPLAIN QUERY PLAN output into a graph */
9679 static const char *modeDescr[] = {
9696 ** These are the column/row/line separators used by the various
9697 ** import/export modes.
9699 #define SEP_Column "|"
9700 #define SEP_Row "\n"
9701 #define SEP_Tab "\t"
9702 #define SEP_Space " "
9703 #define SEP_Comma ","
9704 #define SEP_CrLf "\r\n"
9705 #define SEP_Unit "\x1F"
9706 #define SEP_Record "\x1E"
9709 ** A callback for the sqlite3_log() interface.
9711 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
9712 ShellState *p = (ShellState*)pArg;
9713 if( p->pLog==0 ) return;
9714 utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
9719 ** SQL function: shell_putsnl(X)
9721 ** Write the text X to the screen (or whatever output is being directed)
9722 ** adding a newline at the end, and then return X.
9724 static void shellPutsFunc(
9725 sqlite3_context *pCtx,
9727 sqlite3_value **apVal
9729 ShellState *p = (ShellState*)sqlite3_user_data(pCtx);
9731 utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0]));
9732 sqlite3_result_value(pCtx, apVal[0]);
9736 ** SQL function: edit(VALUE)
9737 ** edit(VALUE,EDITOR)
9741 ** (1) Write VALUE into a temporary file.
9742 ** (2) Run program EDITOR on that temporary file.
9743 ** (3) Read the temporary file back and return its content as the result.
9744 ** (4) Delete the temporary file
9746 ** If the EDITOR argument is omitted, use the value in the VISUAL
9747 ** environment variable. If still there is no EDITOR, through an error.
9749 ** Also throw an error if the EDITOR program returns a non-zero exit code.
9751 #ifndef SQLITE_NOHAVE_SYSTEM
9752 static void editFunc(
9753 sqlite3_context *context,
9755 sqlite3_value **argv
9757 const char *zEditor;
9758 char *zTempFile = 0;
9767 unsigned char *p = 0;
9770 zEditor = (const char*)sqlite3_value_text(argv[1]);
9772 zEditor = getenv("VISUAL");
9775 sqlite3_result_error(context, "no editor for edit()", -1);
9778 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
9779 sqlite3_result_error(context, "NULL input to edit()", -1);
9782 db = sqlite3_context_db_handle(context);
9784 sqlite3_file_control(db, 0, SQLITE_FCNTL_TEMPFILENAME, &zTempFile);
9786 sqlite3_uint64 r = 0;
9787 sqlite3_randomness(sizeof(r), &r);
9788 zTempFile = sqlite3_mprintf("temp%llx", r);
9790 sqlite3_result_error_nomem(context);
9794 bBin = sqlite3_value_type(argv[0])==SQLITE_BLOB;
9795 /* When writing the file to be edited, do \n to \r\n conversions on systems
9796 ** that want \r\n line endings */
9797 f = fopen(zTempFile, bBin ? "wb" : "w");
9799 sqlite3_result_error(context, "edit() cannot open temp file", -1);
9802 sz = sqlite3_value_bytes(argv[0]);
9804 x = fwrite(sqlite3_value_blob(argv[0]), 1, sz, f);
9806 const char *z = (const char*)sqlite3_value_text(argv[0]);
9807 /* Remember whether or not the value originally contained \r\n */
9808 if( z && strstr(z,"\r\n")!=0 ) hasCRNL = 1;
9809 x = fwrite(sqlite3_value_text(argv[0]), 1, sz, f);
9814 sqlite3_result_error(context, "edit() could not write the whole file", -1);
9817 zCmd = sqlite3_mprintf("%s \"%s\"", zEditor, zTempFile);
9819 sqlite3_result_error_nomem(context);
9825 sqlite3_result_error(context, "EDITOR returned non-zero", -1);
9828 f = fopen(zTempFile, "rb");
9830 sqlite3_result_error(context,
9831 "edit() cannot reopen temp file after edit", -1);
9834 fseek(f, 0, SEEK_END);
9837 p = sqlite3_malloc64( sz+(bBin==0) );
9839 sqlite3_result_error_nomem(context);
9842 x = fread(p, 1, sz, f);
9846 sqlite3_result_error(context, "could not read back the whole file", -1);
9850 sqlite3_result_blob64(context, p, sz, sqlite3_free);
9854 /* If the original contains \r\n then do no conversions back to \n */
9857 /* If the file did not originally contain \r\n then convert any new
9858 ** \r\n back into \n */
9859 for(i=j=0; i<sz; i++){
9860 if( p[i]=='\r' && p[i+1]=='\n' ) i++;
9866 sqlite3_result_text64(context, (const char*)p, sz,
9867 sqlite3_free, SQLITE_UTF8);
9874 sqlite3_free(zTempFile);
9877 #endif /* SQLITE_NOHAVE_SYSTEM */
9880 ** Save or restore the current output mode
9882 static void outputModePush(ShellState *p){
9883 p->modePrior = p->mode;
9884 memcpy(p->colSepPrior, p->colSeparator, sizeof(p->colSeparator));
9885 memcpy(p->rowSepPrior, p->rowSeparator, sizeof(p->rowSeparator));
9887 static void outputModePop(ShellState *p){
9888 p->mode = p->modePrior;
9889 memcpy(p->colSeparator, p->colSepPrior, sizeof(p->colSeparator));
9890 memcpy(p->rowSeparator, p->rowSepPrior, sizeof(p->rowSeparator));
9894 ** Output the given string as a hex-encoded blob (eg. X'1234' )
9896 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
9898 char *zBlob = (char *)pBlob;
9899 raw_printf(out,"X'");
9900 for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); }
9901 raw_printf(out,"'");
9905 ** Find a string that is not found anywhere in z[]. Return a pointer
9908 ** Try to use zA and zB first. If both of those are already found in z[]
9909 ** then make up some string and store it in the buffer zBuf.
9911 static const char *unused_string(
9912 const char *z, /* Result must not appear anywhere in z */
9913 const char *zA, const char *zB, /* Try these first */
9914 char *zBuf /* Space to store a generated string */
9917 if( strstr(z, zA)==0 ) return zA;
9918 if( strstr(z, zB)==0 ) return zB;
9920 sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++);
9921 }while( strstr(z,zBuf)!=0 );
9926 ** Output the given string as a quoted string using SQL quoting conventions.
9928 ** See also: output_quoted_escaped_string()
9930 static void output_quoted_string(FILE *out, const char *z){
9933 setBinaryMode(out, 1);
9934 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
9936 utf8_printf(out,"'%s'",z);
9938 raw_printf(out, "'");
9940 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
9943 utf8_printf(out, "%.*s", i, z);
9947 raw_printf(out, "'");
9955 raw_printf(out, "'");
9957 setTextMode(out, 1);
9961 ** Output the given string as a quoted string using SQL quoting conventions.
9962 ** Additionallly , escape the "\n" and "\r" characters so that they do not
9963 ** get corrupted by end-of-line translation facilities in some operating
9966 ** This is like output_quoted_string() but with the addition of the \r\n
9967 ** escape mechanism.
9969 static void output_quoted_escaped_string(FILE *out, const char *z){
9972 setBinaryMode(out, 1);
9973 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
9975 utf8_printf(out,"'%s'",z);
9977 const char *zNL = 0;
9978 const char *zCR = 0;
9981 char zBuf1[20], zBuf2[20];
9982 for(i=0; z[i]; i++){
9983 if( z[i]=='\n' ) nNL++;
9984 if( z[i]=='\r' ) nCR++;
9987 raw_printf(out, "replace(");
9988 zNL = unused_string(z, "\\n", "\\012", zBuf1);
9991 raw_printf(out, "replace(");
9992 zCR = unused_string(z, "\\r", "\\015", zBuf2);
9994 raw_printf(out, "'");
9996 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
9999 utf8_printf(out, "%.*s", i, z);
10003 raw_printf(out, "'");
10011 raw_printf(out, "%s", zNL);
10014 raw_printf(out, "%s", zCR);
10016 raw_printf(out, "'");
10018 raw_printf(out, ",'%s',char(13))", zCR);
10021 raw_printf(out, ",'%s',char(10))", zNL);
10024 setTextMode(out, 1);
10028 ** Output the given string as a quoted according to C or TCL quoting rules.
10030 static void output_c_string(FILE *out, const char *z){
10033 while( (c = *(z++))!=0 ){
10037 }else if( c=='"' ){
10040 }else if( c=='\t' ){
10043 }else if( c=='\n' ){
10046 }else if( c=='\r' ){
10049 }else if( !isprint(c&0xff) ){
10050 raw_printf(out, "\\%03o", c&0xff);
10059 ** Output the given string with characters that are special to
10062 static void output_html_string(FILE *out, const char *z){
10074 utf8_printf(out,"%.*s",i,z);
10077 raw_printf(out,"<");
10078 }else if( z[i]=='&' ){
10079 raw_printf(out,"&");
10080 }else if( z[i]=='>' ){
10081 raw_printf(out,">");
10082 }else if( z[i]=='\"' ){
10083 raw_printf(out,""");
10084 }else if( z[i]=='\'' ){
10085 raw_printf(out,"'");
10094 ** If a field contains any character identified by a 1 in the following
10095 ** array, then the string must be quoted for CSV.
10097 static const char needCsvQuote[] = {
10098 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10099 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10100 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
10101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
10106 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10107 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10109 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10110 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10113 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10117 ** Output a single term of CSV. Actually, p->colSeparator is used for
10118 ** the separator, which may or may not be a comma. p->nullValue is
10119 ** the null value. Strings are quoted if necessary. The separator
10120 ** is only issued if bSep is true.
10122 static void output_csv(ShellState *p, const char *z, int bSep){
10123 FILE *out = p->out;
10125 utf8_printf(out,"%s",p->nullValue);
10128 int nSep = strlen30(p->colSeparator);
10129 for(i=0; z[i]; i++){
10130 if( needCsvQuote[((unsigned char*)z)[i]]
10131 || (z[i]==p->colSeparator[0] &&
10132 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
10138 char *zQuoted = sqlite3_mprintf("\"%w\"", z);
10139 utf8_printf(out, "%s", zQuoted);
10140 sqlite3_free(zQuoted);
10142 utf8_printf(out, "%s", z);
10146 utf8_printf(p->out, "%s", p->colSeparator);
10151 ** This routine runs when the user presses Ctrl-C
10153 static void interrupt_handler(int NotUsed){
10154 UNUSED_PARAMETER(NotUsed);
10156 if( seenInterrupt>2 ) exit(1);
10157 if( globalDb ) sqlite3_interrupt(globalDb);
10160 #if (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE)
10162 ** This routine runs for console events (e.g. Ctrl-C) on Win32
10164 static BOOL WINAPI ConsoleCtrlHandler(
10165 DWORD dwCtrlType /* One of the CTRL_*_EVENT constants */
10167 if( dwCtrlType==CTRL_C_EVENT ){
10168 interrupt_handler(0);
10175 #ifndef SQLITE_OMIT_AUTHORIZATION
10177 ** When the ".auth ON" is set, the following authorizer callback is
10178 ** invoked. It always returns SQLITE_OK.
10180 static int shellAuth(
10188 ShellState *p = (ShellState*)pClientData;
10189 static const char *azAction[] = { 0,
10190 "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX",
10191 "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW",
10192 "CREATE_TRIGGER", "CREATE_VIEW", "DELETE",
10193 "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX",
10194 "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW",
10195 "DROP_TRIGGER", "DROP_VIEW", "INSERT",
10196 "PRAGMA", "READ", "SELECT",
10197 "TRANSACTION", "UPDATE", "ATTACH",
10198 "DETACH", "ALTER_TABLE", "REINDEX",
10199 "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE",
10200 "FUNCTION", "SAVEPOINT", "RECURSIVE"
10208 utf8_printf(p->out, "authorizer: %s", azAction[op]);
10209 for(i=0; i<4; i++){
10210 raw_printf(p->out, " ");
10212 output_c_string(p->out, az[i]);
10214 raw_printf(p->out, "NULL");
10217 raw_printf(p->out, "\n");
10223 ** Print a schema statement. Part of MODE_Semi and MODE_Pretty output.
10225 ** This routine converts some CREATE TABLE statements for shadow tables
10226 ** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements.
10228 static void printSchemaLine(FILE *out, const char *z, const char *zTail){
10230 if( zTail==0 ) return;
10231 if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
10232 utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
10234 utf8_printf(out, "%s%s", z, zTail);
10237 static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){
10240 printSchemaLine(out, z, zTail);
10245 ** Return true if string z[] has nothing but whitespace and comments to the
10246 ** end of the first line.
10248 static int wsToEol(const char *z){
10250 for(i=0; z[i]; i++){
10251 if( z[i]=='\n' ) return 1;
10252 if( IsSpace(z[i]) ) continue;
10253 if( z[i]=='-' && z[i+1]=='-' ) return 1;
10260 ** Add a new entry to the EXPLAIN QUERY PLAN data
10262 static void eqp_append(ShellState *p, int iEqpId, int p2, const char *zText){
10264 int nText = strlen30(zText);
10265 if( p->autoEQPtest ){
10266 utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText);
10268 pNew = sqlite3_malloc64( sizeof(*pNew) + nText );
10269 if( pNew==0 ) shell_out_of_memory();
10270 pNew->iEqpId = iEqpId;
10271 pNew->iParentId = p2;
10272 memcpy(pNew->zText, zText, nText+1);
10274 if( p->sGraph.pLast ){
10275 p->sGraph.pLast->pNext = pNew;
10277 p->sGraph.pRow = pNew;
10279 p->sGraph.pLast = pNew;
10283 ** Free and reset the EXPLAIN QUERY PLAN data that has been collected
10286 static void eqp_reset(ShellState *p){
10287 EQPGraphRow *pRow, *pNext;
10288 for(pRow = p->sGraph.pRow; pRow; pRow = pNext){
10289 pNext = pRow->pNext;
10290 sqlite3_free(pRow);
10292 memset(&p->sGraph, 0, sizeof(p->sGraph));
10295 /* Return the next EXPLAIN QUERY PLAN line with iEqpId that occurs after
10296 ** pOld, or return the first such line if pOld is NULL
10298 static EQPGraphRow *eqp_next_row(ShellState *p, int iEqpId, EQPGraphRow *pOld){
10299 EQPGraphRow *pRow = pOld ? pOld->pNext : p->sGraph.pRow;
10300 while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext;
10304 /* Render a single level of the graph that has iEqpId as its parent. Called
10305 ** recursively to render sublevels.
10307 static void eqp_render_level(ShellState *p, int iEqpId){
10308 EQPGraphRow *pRow, *pNext;
10309 int n = strlen30(p->sGraph.zPrefix);
10311 for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){
10312 pNext = eqp_next_row(p, iEqpId, pRow);
10314 utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix, pNext ? "|--" : "`--", z);
10315 if( n<(int)sizeof(p->sGraph.zPrefix)-7 ){
10316 memcpy(&p->sGraph.zPrefix[n], pNext ? "| " : " ", 4);
10317 eqp_render_level(p, pRow->iEqpId);
10318 p->sGraph.zPrefix[n] = 0;
10324 ** Display and reset the EXPLAIN QUERY PLAN data
10326 static void eqp_render(ShellState *p){
10327 EQPGraphRow *pRow = p->sGraph.pRow;
10329 if( pRow->zText[0]=='-' ){
10330 if( pRow->pNext==0 ){
10334 utf8_printf(p->out, "%s\n", pRow->zText+3);
10335 p->sGraph.pRow = pRow->pNext;
10336 sqlite3_free(pRow);
10338 utf8_printf(p->out, "QUERY PLAN\n");
10340 p->sGraph.zPrefix[0] = 0;
10341 eqp_render_level(p, 0);
10346 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
10348 ** Progress handler callback.
10350 static int progress_handler(void *pClientData) {
10351 ShellState *p = (ShellState*)pClientData;
10353 if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){
10354 raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress);
10355 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
10356 if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0;
10359 if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){
10360 raw_printf(p->out, "Progress %u\n", p->nProgress);
10364 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
10367 ** This is the callback routine that the shell
10368 ** invokes for each row of a query result.
10370 static int shell_callback(
10372 int nArg, /* Number of result columns */
10373 char **azArg, /* Text of each result column */
10374 char **azCol, /* Column names */
10375 int *aiType /* Column types */
10378 ShellState *p = (ShellState*)pArg;
10380 if( azArg==0 ) return 0;
10381 switch( p->cMode ){
10384 if( azArg==0 ) break;
10385 for(i=0; i<nArg; i++){
10386 int len = strlen30(azCol[i] ? azCol[i] : "");
10387 if( len>w ) w = len;
10389 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
10390 for(i=0; i<nArg; i++){
10391 utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
10392 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
10397 case MODE_Column: {
10398 static const int aExplainWidths[] = {4, 13, 4, 4, 4, 13, 2, 13};
10399 const int *colWidth;
10402 if( p->cMode==MODE_Column ){
10403 colWidth = p->colWidth;
10404 showHdr = p->showHeader;
10405 rowSep = p->rowSeparator;
10407 colWidth = aExplainWidths;
10412 for(i=0; i<nArg; i++){
10414 if( i<ArraySize(p->colWidth) ){
10420 w = strlenChar(azCol[i] ? azCol[i] : "");
10422 n = strlenChar(azArg && azArg[i] ? azArg[i] : p->nullValue);
10425 if( i<ArraySize(p->actualWidth) ){
10426 p->actualWidth[i] = w;
10429 utf8_width_print(p->out, w, azCol[i]);
10430 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
10434 for(i=0; i<nArg; i++){
10436 if( i<ArraySize(p->actualWidth) ){
10437 w = p->actualWidth[i];
10442 utf8_printf(p->out,"%-*.*s%s",w,w,
10443 "----------------------------------------------------------"
10444 "----------------------------------------------------------",
10445 i==nArg-1 ? rowSep : " ");
10449 if( azArg==0 ) break;
10450 for(i=0; i<nArg; i++){
10452 if( i<ArraySize(p->actualWidth) ){
10453 w = p->actualWidth[i];
10457 if( p->cMode==MODE_Explain && azArg[i] && strlenChar(azArg[i])>w ){
10458 w = strlenChar(azArg[i]);
10460 if( i==1 && p->aiIndent && p->pStmt ){
10461 if( p->iIndent<p->nIndent ){
10462 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
10466 utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue);
10467 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
10471 case MODE_Semi: { /* .schema and .fullschema output */
10472 printSchemaLine(p->out, azArg[0], ";\n");
10475 case MODE_Pretty: { /* .schema and .fullschema with --indent */
10483 if( azArg[0]==0 ) break;
10484 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
10485 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
10487 utf8_printf(p->out, "%s;\n", azArg[0]);
10490 z = sqlite3_mprintf("%s", azArg[0]);
10492 for(i=0; IsSpace(z[i]); i++){}
10493 for(; (c = z[i])!=0; i++){
10495 if( z[j-1]=='\r' ) z[j-1] = '\n';
10496 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue;
10497 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){
10502 while( j>0 && IsSpace(z[j-1]) ){ j--; }
10504 if( strlen30(z)>=79 ){
10505 for(i=j=0; (c = z[i])!=0; i++){ /* Copy changes from z[i] back to z[j] */
10508 }else if( c=='"' || c=='\'' || c=='`' ){
10510 }else if( c=='[' ){
10512 }else if( c=='-' && z[i+1]=='-' ){
10514 }else if( c=='(' ){
10516 }else if( c==')' ){
10518 if( nLine>0 && nParen==0 && j>0 ){
10519 printSchemaLineN(p->out, z, j, "\n");
10524 if( nParen==1 && cEnd==0
10525 && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1)))
10528 printSchemaLineN(p->out, z, j, "\n ");
10531 while( IsSpace(z[i+1]) ){ i++; }
10536 printSchemaLine(p->out, z, ";\n");
10541 if( p->cnt++==0 && p->showHeader ){
10542 for(i=0; i<nArg; i++){
10543 utf8_printf(p->out,"%s%s",azCol[i],
10544 i==nArg-1 ? p->rowSeparator : p->colSeparator);
10547 if( azArg==0 ) break;
10548 for(i=0; i<nArg; i++){
10549 char *z = azArg[i];
10550 if( z==0 ) z = p->nullValue;
10551 utf8_printf(p->out, "%s", z);
10553 utf8_printf(p->out, "%s", p->colSeparator);
10555 utf8_printf(p->out, "%s", p->rowSeparator);
10561 if( p->cnt++==0 && p->showHeader ){
10562 raw_printf(p->out,"<TR>");
10563 for(i=0; i<nArg; i++){
10564 raw_printf(p->out,"<TH>");
10565 output_html_string(p->out, azCol[i]);
10566 raw_printf(p->out,"</TH>\n");
10568 raw_printf(p->out,"</TR>\n");
10570 if( azArg==0 ) break;
10571 raw_printf(p->out,"<TR>");
10572 for(i=0; i<nArg; i++){
10573 raw_printf(p->out,"<TD>");
10574 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
10575 raw_printf(p->out,"</TD>\n");
10577 raw_printf(p->out,"</TR>\n");
10581 if( p->cnt++==0 && p->showHeader ){
10582 for(i=0; i<nArg; i++){
10583 output_c_string(p->out,azCol[i] ? azCol[i] : "");
10584 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
10586 utf8_printf(p->out, "%s", p->rowSeparator);
10588 if( azArg==0 ) break;
10589 for(i=0; i<nArg; i++){
10590 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
10591 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
10593 utf8_printf(p->out, "%s", p->rowSeparator);
10597 setBinaryMode(p->out, 1);
10598 if( p->cnt++==0 && p->showHeader ){
10599 for(i=0; i<nArg; i++){
10600 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
10602 utf8_printf(p->out, "%s", p->rowSeparator);
10605 for(i=0; i<nArg; i++){
10606 output_csv(p, azArg[i], i<nArg-1);
10608 utf8_printf(p->out, "%s", p->rowSeparator);
10610 setTextMode(p->out, 1);
10613 case MODE_Insert: {
10614 if( azArg==0 ) break;
10615 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
10616 if( p->showHeader ){
10617 raw_printf(p->out,"(");
10618 for(i=0; i<nArg; i++){
10619 if( i>0 ) raw_printf(p->out, ",");
10620 if( quoteChar(azCol[i]) ){
10621 char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
10622 utf8_printf(p->out, "%s", z);
10625 raw_printf(p->out, "%s", azCol[i]);
10628 raw_printf(p->out,")");
10631 for(i=0; i<nArg; i++){
10632 raw_printf(p->out, i>0 ? "," : " VALUES(");
10633 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
10634 utf8_printf(p->out,"NULL");
10635 }else if( aiType && aiType[i]==SQLITE_TEXT ){
10636 if( ShellHasFlag(p, SHFLG_Newlines) ){
10637 output_quoted_string(p->out, azArg[i]);
10639 output_quoted_escaped_string(p->out, azArg[i]);
10641 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
10642 utf8_printf(p->out,"%s", azArg[i]);
10643 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
10645 double r = sqlite3_column_double(p->pStmt, i);
10647 memcpy(&ur,&r,sizeof(r));
10648 if( ur==0x7ff0000000000000LL ){
10649 raw_printf(p->out, "1e999");
10650 }else if( ur==0xfff0000000000000LL ){
10651 raw_printf(p->out, "-1e999");
10653 sqlite3_snprintf(50,z,"%!.20g", r);
10654 raw_printf(p->out, "%s", z);
10656 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
10657 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
10658 int nBlob = sqlite3_column_bytes(p->pStmt, i);
10659 output_hex_blob(p->out, pBlob, nBlob);
10660 }else if( isNumber(azArg[i], 0) ){
10661 utf8_printf(p->out,"%s", azArg[i]);
10662 }else if( ShellHasFlag(p, SHFLG_Newlines) ){
10663 output_quoted_string(p->out, azArg[i]);
10665 output_quoted_escaped_string(p->out, azArg[i]);
10668 raw_printf(p->out,");\n");
10672 if( azArg==0 ) break;
10673 if( p->cnt==0 && p->showHeader ){
10674 for(i=0; i<nArg; i++){
10675 if( i>0 ) raw_printf(p->out, ",");
10676 output_quoted_string(p->out, azCol[i]);
10678 raw_printf(p->out,"\n");
10681 for(i=0; i<nArg; i++){
10682 if( i>0 ) raw_printf(p->out, ",");
10683 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
10684 utf8_printf(p->out,"NULL");
10685 }else if( aiType && aiType[i]==SQLITE_TEXT ){
10686 output_quoted_string(p->out, azArg[i]);
10687 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
10688 utf8_printf(p->out,"%s", azArg[i]);
10689 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
10691 double r = sqlite3_column_double(p->pStmt, i);
10692 sqlite3_snprintf(50,z,"%!.20g", r);
10693 raw_printf(p->out, "%s", z);
10694 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
10695 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
10696 int nBlob = sqlite3_column_bytes(p->pStmt, i);
10697 output_hex_blob(p->out, pBlob, nBlob);
10698 }else if( isNumber(azArg[i], 0) ){
10699 utf8_printf(p->out,"%s", azArg[i]);
10701 output_quoted_string(p->out, azArg[i]);
10704 raw_printf(p->out,"\n");
10708 if( p->cnt++==0 && p->showHeader ){
10709 for(i=0; i<nArg; i++){
10710 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
10711 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
10713 utf8_printf(p->out, "%s", p->rowSeparator);
10715 if( azArg==0 ) break;
10716 for(i=0; i<nArg; i++){
10717 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
10718 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
10720 utf8_printf(p->out, "%s", p->rowSeparator);
10724 eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]);
10732 ** This is the callback routine that the SQLite library
10733 ** invokes for each row of a query result.
10735 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
10736 /* since we don't have type info, call the shell_callback with a NULL value */
10737 return shell_callback(pArg, nArg, azArg, azCol, NULL);
10741 ** This is the callback routine from sqlite3_exec() that appends all
10742 ** output onto the end of a ShellText object.
10744 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
10745 ShellText *p = (ShellText*)pArg;
10747 UNUSED_PARAMETER(az);
10748 if( azArg==0 ) return 0;
10749 if( p->n ) appendText(p, "|", 0);
10750 for(i=0; i<nArg; i++){
10751 if( i ) appendText(p, ",", 0);
10752 if( azArg[i] ) appendText(p, azArg[i], 0);
10758 ** Generate an appropriate SELFTEST table in the main database.
10760 static void createSelftestTable(ShellState *p){
10762 sqlite3_exec(p->db,
10763 "SAVEPOINT selftest_init;\n"
10764 "CREATE TABLE IF NOT EXISTS selftest(\n"
10765 " tno INTEGER PRIMARY KEY,\n" /* Test number */
10766 " op TEXT,\n" /* Operator: memo run */
10767 " cmd TEXT,\n" /* Command text */
10768 " ans TEXT\n" /* Desired answer */
10770 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
10771 "INSERT INTO [_shell$self](rowid,op,cmd)\n"
10772 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
10773 " 'memo','Tests generated by --init');\n"
10774 "INSERT INTO [_shell$self]\n"
10776 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
10777 "FROM sqlite_master ORDER BY 2'',224))',\n"
10778 " hex(sha3_query('SELECT type,name,tbl_name,sql "
10779 "FROM sqlite_master ORDER BY 2',224));\n"
10780 "INSERT INTO [_shell$self]\n"
10782 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
10783 " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
10784 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
10786 " SELECT name FROM sqlite_master\n"
10787 " WHERE type='table'\n"
10788 " AND name<>'selftest'\n"
10789 " AND coalesce(rootpage,0)>0\n"
10791 " ORDER BY name;\n"
10792 "INSERT INTO [_shell$self]\n"
10793 " VALUES('run','PRAGMA integrity_check','ok');\n"
10794 "INSERT INTO selftest(tno,op,cmd,ans)"
10795 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
10796 "DROP TABLE [_shell$self];"
10799 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
10800 sqlite3_free(zErrMsg);
10802 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
10807 ** Set the destination table field of the ShellState structure to
10808 ** the name of the table given. Escape any quote characters in the
10811 static void set_table_name(ShellState *p, const char *zName){
10816 if( p->zDestTable ){
10817 free(p->zDestTable);
10820 if( zName==0 ) return;
10821 cQuote = quoteChar(zName);
10822 n = strlen30(zName);
10823 if( cQuote ) n += n+2;
10824 z = p->zDestTable = malloc( n+1 );
10825 if( z==0 ) shell_out_of_memory();
10827 if( cQuote ) z[n++] = cQuote;
10828 for(i=0; zName[i]; i++){
10830 if( zName[i]==cQuote ) z[n++] = cQuote;
10832 if( cQuote ) z[n++] = cQuote;
10838 ** Execute a query statement that will generate SQL output. Print
10839 ** the result columns, comma-separated, on a line and then add a
10840 ** semicolon terminator to the end of that line.
10842 ** If the number of columns is 1 and that column contains text "--"
10843 ** then write the semicolon on a separate line. That way, if a
10844 ** "--" comment occurs at the end of the statement, the comment
10845 ** won't consume the semicolon terminator.
10847 static int run_table_dump_query(
10848 ShellState *p, /* Query context */
10849 const char *zSelect, /* SELECT statement to extract content */
10850 const char *zFirstRow /* Print before first row, if not NULL */
10852 sqlite3_stmt *pSelect;
10857 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
10858 if( rc!=SQLITE_OK || !pSelect ){
10859 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
10860 sqlite3_errmsg(p->db));
10861 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
10864 rc = sqlite3_step(pSelect);
10865 nResult = sqlite3_column_count(pSelect);
10866 while( rc==SQLITE_ROW ){
10868 utf8_printf(p->out, "%s", zFirstRow);
10871 z = (const char*)sqlite3_column_text(pSelect, 0);
10872 utf8_printf(p->out, "%s", z);
10873 for(i=1; i<nResult; i++){
10874 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
10877 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
10879 raw_printf(p->out, "\n;\n");
10881 raw_printf(p->out, ";\n");
10883 rc = sqlite3_step(pSelect);
10885 rc = sqlite3_finalize(pSelect);
10886 if( rc!=SQLITE_OK ){
10887 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
10888 sqlite3_errmsg(p->db));
10889 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
10895 ** Allocate space and save off current error string.
10897 static char *save_err_msg(
10898 sqlite3 *db /* Database to query */
10900 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
10901 char *zErrMsg = sqlite3_malloc64(nErrMsg);
10903 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
10910 ** Attempt to display I/O stats on Linux using /proc/PID/io
10912 static void displayLinuxIoStats(FILE *out){
10915 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
10916 in = fopen(z, "rb");
10917 if( in==0 ) return;
10918 while( fgets(z, sizeof(z), in)!=0 ){
10919 static const struct {
10920 const char *zPattern;
10923 { "rchar: ", "Bytes received by read():" },
10924 { "wchar: ", "Bytes sent to write():" },
10925 { "syscr: ", "Read() system calls:" },
10926 { "syscw: ", "Write() system calls:" },
10927 { "read_bytes: ", "Bytes read from storage:" },
10928 { "write_bytes: ", "Bytes written to storage:" },
10929 { "cancelled_write_bytes: ", "Cancelled write bytes:" },
10932 for(i=0; i<ArraySize(aTrans); i++){
10933 int n = strlen30(aTrans[i].zPattern);
10934 if( strncmp(aTrans[i].zPattern, z, n)==0 ){
10935 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
10945 ** Display a single line of status using 64-bit values.
10947 static void displayStatLine(
10948 ShellState *p, /* The shell context */
10949 char *zLabel, /* Label for this one line */
10950 char *zFormat, /* Format for the result */
10951 int iStatusCtrl, /* Which status to display */
10952 int bReset /* True to reset the stats */
10954 sqlite3_int64 iCur = -1;
10955 sqlite3_int64 iHiwtr = -1;
10958 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
10959 for(i=0, nPercent=0; zFormat[i]; i++){
10960 if( zFormat[i]=='%' ) nPercent++;
10963 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
10965 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
10967 raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
10971 ** Display memory stats.
10973 static int display_stats(
10974 sqlite3 *db, /* Database to query */
10975 ShellState *pArg, /* Pointer to ShellState */
10976 int bReset /* True to reset the stats */
10981 if( pArg==0 || pArg->out==0 ) return 0;
10984 if( pArg->pStmt && (pArg->statsOn & 2) ){
10986 sqlite3_stmt *pStmt = pArg->pStmt;
10988 nCol = sqlite3_column_count(pStmt);
10989 raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol);
10990 for(i=0; i<nCol; i++){
10991 sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x);
10992 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i));
10993 #ifndef SQLITE_OMIT_DECLTYPE
10994 sqlite3_snprintf(30, z+x, "declared type:");
10995 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
10997 #ifdef SQLITE_ENABLE_COLUMN_METADATA
10998 sqlite3_snprintf(30, z+x, "database name:");
10999 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i));
11000 sqlite3_snprintf(30, z+x, "table name:");
11001 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
11002 sqlite3_snprintf(30, z+x, "origin name:");
11003 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i));
11008 displayStatLine(pArg, "Memory Used:",
11009 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
11010 displayStatLine(pArg, "Number of Outstanding Allocations:",
11011 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
11012 if( pArg->shellFlgs & SHFLG_Pagecache ){
11013 displayStatLine(pArg, "Number of Pcache Pages Used:",
11014 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
11016 displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
11017 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
11018 displayStatLine(pArg, "Largest Allocation:",
11019 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
11020 displayStatLine(pArg, "Largest Pcache Allocation:",
11021 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
11022 #ifdef YYTRACKMAXSTACKDEPTH
11023 displayStatLine(pArg, "Deepest Parser Stack:",
11024 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
11028 if( pArg->shellFlgs & SHFLG_Lookaside ){
11029 iHiwtr = iCur = -1;
11030 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
11031 &iCur, &iHiwtr, bReset);
11032 raw_printf(pArg->out,
11033 "Lookaside Slots Used: %d (max %d)\n",
11035 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
11036 &iCur, &iHiwtr, bReset);
11037 raw_printf(pArg->out, "Successful lookaside attempts: %d\n",
11039 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
11040 &iCur, &iHiwtr, bReset);
11041 raw_printf(pArg->out, "Lookaside failures due to size: %d\n",
11043 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
11044 &iCur, &iHiwtr, bReset);
11045 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n",
11048 iHiwtr = iCur = -1;
11049 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
11050 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n",
11052 iHiwtr = iCur = -1;
11053 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
11054 raw_printf(pArg->out, "Page cache hits: %d\n", iCur);
11055 iHiwtr = iCur = -1;
11056 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
11057 raw_printf(pArg->out, "Page cache misses: %d\n", iCur);
11058 iHiwtr = iCur = -1;
11059 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
11060 raw_printf(pArg->out, "Page cache writes: %d\n", iCur);
11061 iHiwtr = iCur = -1;
11062 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1);
11063 raw_printf(pArg->out, "Page cache spills: %d\n", iCur);
11064 iHiwtr = iCur = -1;
11065 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
11066 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n",
11068 iHiwtr = iCur = -1;
11069 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
11070 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",
11075 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
11077 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur);
11078 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
11079 raw_printf(pArg->out, "Sort Operations: %d\n", iCur);
11080 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
11081 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur);
11082 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
11083 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
11084 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE, bReset);
11085 raw_printf(pArg->out, "Reprepare operations: %d\n", iCur);
11086 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset);
11087 raw_printf(pArg->out, "Number of times run: %d\n", iCur);
11088 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset);
11089 raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur);
11093 displayLinuxIoStats(pArg->out);
11096 /* Do not remove this machine readable comment: extra-stats-output-here */
11102 ** Display scan stats.
11104 static void display_scanstats(
11105 sqlite3 *db, /* Database to query */
11106 ShellState *pArg /* Pointer to ShellState */
11108 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
11109 UNUSED_PARAMETER(db);
11110 UNUSED_PARAMETER(pArg);
11113 raw_printf(pArg->out, "-------- scanstats --------\n");
11115 for(k=0; k<=mx; k++){
11116 double rEstLoop = 1.0;
11117 for(i=n=0; 1; i++){
11118 sqlite3_stmt *p = pArg->pStmt;
11119 sqlite3_int64 nLoop, nVisit;
11122 const char *zExplain;
11123 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
11126 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
11127 if( iSid>mx ) mx = iSid;
11128 if( iSid!=k ) continue;
11130 rEstLoop = (double)nLoop;
11131 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k);
11134 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
11135 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
11136 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
11137 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain);
11139 raw_printf(pArg->out,
11140 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
11141 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
11145 raw_printf(pArg->out, "---------------------------\n");
11150 ** Parameter azArray points to a zero-terminated array of strings. zStr
11151 ** points to a single nul-terminated string. Return non-zero if zStr
11152 ** is equal, according to strcmp(), to any of the strings in the array.
11153 ** Otherwise, return zero.
11155 static int str_in_array(const char *zStr, const char **azArray){
11157 for(i=0; azArray[i]; i++){
11158 if( 0==strcmp(zStr, azArray[i]) ) return 1;
11164 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
11165 ** and populate the ShellState.aiIndent[] array with the number of
11166 ** spaces each opcode should be indented before it is output.
11168 ** The indenting rules are:
11170 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
11171 ** all opcodes that occur between the p2 jump destination and the opcode
11172 ** itself by 2 spaces.
11174 ** * For each "Goto", if the jump destination is earlier in the program
11175 ** and ends on one of:
11176 ** Yield SeekGt SeekLt RowSetRead Rewind
11177 ** or if the P1 parameter is one instead of zero,
11178 ** then indent all opcodes between the earlier instruction
11179 ** and "Goto" by 2 spaces.
11181 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
11182 const char *zSql; /* The text of the SQL statement */
11183 const char *z; /* Used to check if this is an EXPLAIN */
11184 int *abYield = 0; /* True if op is an OP_Yield */
11185 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
11186 int iOp; /* Index of operation in p->aiIndent[] */
11188 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 };
11189 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
11191 const char *azGoto[] = { "Goto", 0 };
11193 /* Try to figure out if this is really an EXPLAIN statement. If this
11194 ** cannot be verified, return early. */
11195 if( sqlite3_column_count(pSql)!=8 ){
11196 p->cMode = p->mode;
11199 zSql = sqlite3_sql(pSql);
11200 if( zSql==0 ) return;
11201 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
11202 if( sqlite3_strnicmp(z, "explain", 7) ){
11203 p->cMode = p->mode;
11207 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
11209 int iAddr = sqlite3_column_int(pSql, 0);
11210 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
11212 /* Set p2 to the P2 field of the current opcode. Then, assuming that
11213 ** p2 is an instruction address, set variable p2op to the index of that
11214 ** instruction in the aiIndent[] array. p2 and p2op may be different if
11215 ** the current instruction is part of a sub-program generated by an
11216 ** SQL trigger or foreign key. */
11217 int p2 = sqlite3_column_int(pSql, 3);
11218 int p2op = (p2 + (iOp-iAddr));
11220 /* Grow the p->aiIndent array as required */
11223 /* Do further verfication that this is explain output. Abort if
11225 static const char *explainCols[] = {
11226 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" };
11228 for(jj=0; jj<ArraySize(explainCols); jj++){
11229 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){
11230 p->cMode = p->mode;
11231 sqlite3_reset(pSql);
11237 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
11238 if( p->aiIndent==0 ) shell_out_of_memory();
11239 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
11240 if( abYield==0 ) shell_out_of_memory();
11242 abYield[iOp] = str_in_array(zOp, azYield);
11243 p->aiIndent[iOp] = 0;
11244 p->nIndent = iOp+1;
11246 if( str_in_array(zOp, azNext) ){
11247 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
11249 if( str_in_array(zOp, azGoto) && p2op<p->nIndent
11250 && (abYield[p2op] || sqlite3_column_int(pSql, 2))
11252 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
11257 sqlite3_free(abYield);
11258 sqlite3_reset(pSql);
11262 ** Free the array allocated by explain_data_prepare().
11264 static void explain_data_delete(ShellState *p){
11265 sqlite3_free(p->aiIndent);
11272 ** Disable and restore .wheretrace and .selecttrace settings.
11274 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11275 extern int sqlite3SelectTrace;
11276 static int savedSelectTrace;
11278 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11279 extern int sqlite3WhereTrace;
11280 static int savedWhereTrace;
11282 static void disable_debug_trace_modes(void){
11283 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11284 savedSelectTrace = sqlite3SelectTrace;
11285 sqlite3SelectTrace = 0;
11287 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11288 savedWhereTrace = sqlite3WhereTrace;
11289 sqlite3WhereTrace = 0;
11292 static void restore_debug_trace_modes(void){
11293 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11294 sqlite3SelectTrace = savedSelectTrace;
11296 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11297 sqlite3WhereTrace = savedWhereTrace;
11301 /* Create the TEMP table used to store parameter bindings */
11302 static void bind_table_init(ShellState *p){
11304 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema);
11305 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0);
11306 sqlite3_exec(p->db,
11307 "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n"
11308 " key TEXT PRIMARY KEY,\n"
11310 ") WITHOUT ROWID;",
11312 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0);
11316 ** Bind parameters on a prepared statement.
11318 ** Parameter bindings are taken from a TEMP table of the form:
11320 ** CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value)
11323 ** No bindings occur if this table does not exist. The special character '$'
11324 ** is included in the table name to help prevent collisions with actual tables.
11325 ** The table must be in the TEMP schema.
11327 static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){
11331 sqlite3_stmt *pQ = 0;
11333 nVar = sqlite3_bind_parameter_count(pStmt);
11334 if( nVar==0 ) return; /* Nothing to do */
11335 if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters",
11336 "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){
11337 return; /* Parameter table does not exist */
11339 rc = sqlite3_prepare_v2(pArg->db,
11340 "SELECT value FROM temp.sqlite_parameters"
11341 " WHERE key=?1", -1, &pQ, 0);
11342 if( rc || pQ==0 ) return;
11343 for(i=1; i<=nVar; i++){
11345 const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
11347 sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i);
11350 sqlite3_bind_text(pQ, 1, zVar, -1, SQLITE_STATIC);
11351 if( sqlite3_step(pQ)==SQLITE_ROW ){
11352 sqlite3_bind_value(pStmt, i, sqlite3_column_value(pQ, 0));
11354 sqlite3_bind_null(pStmt, i);
11358 sqlite3_finalize(pQ);
11362 ** Run a prepared statement
11364 static void exec_prepared_stmt(
11365 ShellState *pArg, /* Pointer to ShellState */
11366 sqlite3_stmt *pStmt /* Statment to run */
11370 /* perform the first step. this will tell us if we
11371 ** have a result set or not and how wide it is.
11373 rc = sqlite3_step(pStmt);
11374 /* if we have a result set... */
11375 if( SQLITE_ROW == rc ){
11376 /* allocate space for col name ptr, value ptr, and type */
11377 int nCol = sqlite3_column_count(pStmt);
11378 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
11382 char **azCols = (char **)pData; /* Names of result columns */
11383 char **azVals = &azCols[nCol]; /* Results */
11384 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
11386 assert(sizeof(int) <= sizeof(char *));
11387 /* save off ptrs to column names */
11388 for(i=0; i<nCol; i++){
11389 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
11392 /* extract the data and data types */
11393 for(i=0; i<nCol; i++){
11394 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
11395 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){
11398 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
11400 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
11402 break; /* from for */
11406 /* if data and types extracted successfully... */
11407 if( SQLITE_ROW == rc ){
11408 /* call the supplied callback with the result row data */
11409 if( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){
11412 rc = sqlite3_step(pStmt);
11415 } while( SQLITE_ROW == rc );
11416 sqlite3_free(pData);
11421 #ifndef SQLITE_OMIT_VIRTUALTABLE
11423 ** This function is called to process SQL if the previous shell command
11424 ** was ".expert". It passes the SQL in the second argument directly to
11425 ** the sqlite3expert object.
11427 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error
11428 ** code. In this case, (*pzErr) may be set to point to a buffer containing
11429 ** an English language error message. It is the responsibility of the
11430 ** caller to eventually free this buffer using sqlite3_free().
11432 static int expertHandleSQL(
11433 ShellState *pState,
11437 assert( pState->expert.pExpert );
11438 assert( pzErr==0 || *pzErr==0 );
11439 return sqlite3_expert_sql(pState->expert.pExpert, zSql, pzErr);
11443 ** This function is called either to silently clean up the object
11444 ** created by the ".expert" command (if bCancel==1), or to generate a
11445 ** report from it and then clean it up (if bCancel==0).
11447 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error
11448 ** code. In this case, (*pzErr) may be set to point to a buffer containing
11449 ** an English language error message. It is the responsibility of the
11450 ** caller to eventually free this buffer using sqlite3_free().
11452 static int expertFinish(
11453 ShellState *pState,
11457 int rc = SQLITE_OK;
11458 sqlite3expert *p = pState->expert.pExpert;
11460 assert( bCancel || pzErr==0 || *pzErr==0 );
11462 FILE *out = pState->out;
11463 int bVerbose = pState->expert.bVerbose;
11465 rc = sqlite3_expert_analyze(p, pzErr);
11466 if( rc==SQLITE_OK ){
11467 int nQuery = sqlite3_expert_count(p);
11471 const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
11472 raw_printf(out, "-- Candidates -----------------------------\n");
11473 raw_printf(out, "%s\n", zCand);
11475 for(i=0; i<nQuery; i++){
11476 const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
11477 const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
11478 const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
11479 if( zIdx==0 ) zIdx = "(no new indexes)\n";
11481 raw_printf(out, "-- Query %d --------------------------------\n",i+1);
11482 raw_printf(out, "%s\n\n", zSql);
11484 raw_printf(out, "%s\n", zIdx);
11485 raw_printf(out, "%s\n", zEQP);
11489 sqlite3_expert_destroy(p);
11490 pState->expert.pExpert = 0;
11495 ** Implementation of ".expert" dot command.
11497 static int expertDotCommand(
11498 ShellState *pState, /* Current shell tool state */
11499 char **azArg, /* Array of arguments passed to dot command */
11500 int nArg /* Number of entries in azArg[] */
11502 int rc = SQLITE_OK;
11507 assert( pState->expert.pExpert==0 );
11508 memset(&pState->expert, 0, sizeof(ExpertInfo));
11510 for(i=1; rc==SQLITE_OK && i<nArg; i++){
11511 char *z = azArg[i];
11513 if( z[0]=='-' && z[1]=='-' ) z++;
11515 if( n>=2 && 0==strncmp(z, "-verbose", n) ){
11516 pState->expert.bVerbose = 1;
11518 else if( n>=2 && 0==strncmp(z, "-sample", n) ){
11520 raw_printf(stderr, "option requires an argument: %s\n", z);
11523 iSample = (int)integerValue(azArg[++i]);
11524 if( iSample<0 || iSample>100 ){
11525 raw_printf(stderr, "value out of range: %s\n", azArg[i]);
11531 raw_printf(stderr, "unknown option: %s\n", z);
11536 if( rc==SQLITE_OK ){
11537 pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr);
11538 if( pState->expert.pExpert==0 ){
11539 raw_printf(stderr, "sqlite3_expert_new: %s\n", zErr);
11542 sqlite3_expert_config(
11543 pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample
11550 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
11553 ** Execute a statement or set of statements. Print
11554 ** any result rows/columns depending on the current mode
11555 ** set via the supplied callback.
11557 ** This is very similar to SQLite's built-in sqlite3_exec()
11558 ** function except it takes a slightly different callback
11559 ** and callback data argument.
11561 static int shell_exec(
11562 ShellState *pArg, /* Pointer to ShellState */
11563 const char *zSql, /* SQL to be evaluated */
11564 char **pzErrMsg /* Error msg written here */
11566 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
11567 int rc = SQLITE_OK; /* Return Code */
11569 const char *zLeftover; /* Tail of unprocessed SQL */
11570 sqlite3 *db = pArg->db;
11576 #ifndef SQLITE_OMIT_VIRTUALTABLE
11577 if( pArg->expert.pExpert ){
11578 rc = expertHandleSQL(pArg, zSql, pzErrMsg);
11579 return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg);
11583 while( zSql[0] && (SQLITE_OK == rc) ){
11584 static const char *zStmtSql;
11585 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
11586 if( SQLITE_OK != rc ){
11588 *pzErrMsg = save_err_msg(db);
11592 /* this happens for a comment or white-space */
11594 while( IsSpace(zSql[0]) ) zSql++;
11597 zStmtSql = sqlite3_sql(pStmt);
11598 if( zStmtSql==0 ) zStmtSql = "";
11599 while( IsSpace(zStmtSql[0]) ) zStmtSql++;
11601 /* save off the prepared statment handle and reset row count */
11603 pArg->pStmt = pStmt;
11607 /* echo the sql statement if echo on */
11608 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
11609 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
11612 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
11613 if( pArg && pArg->autoEQP && sqlite3_stmt_isexplain(pStmt)==0 ){
11614 sqlite3_stmt *pExplain;
11616 int triggerEQP = 0;
11617 disable_debug_trace_modes();
11618 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP);
11619 if( pArg->autoEQP>=AUTOEQP_trigger ){
11620 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0);
11622 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql);
11623 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
11624 if( rc==SQLITE_OK ){
11625 while( sqlite3_step(pExplain)==SQLITE_ROW ){
11626 const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3);
11627 int iEqpId = sqlite3_column_int(pExplain, 0);
11628 int iParentId = sqlite3_column_int(pExplain, 1);
11629 if( zEQPLine[0]=='-' ) eqp_render(pArg);
11630 eqp_append(pArg, iEqpId, iParentId, zEQPLine);
11634 sqlite3_finalize(pExplain);
11635 sqlite3_free(zEQP);
11636 if( pArg->autoEQP>=AUTOEQP_full ){
11637 /* Also do an EXPLAIN for ".eqp full" mode */
11638 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql);
11639 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
11640 if( rc==SQLITE_OK ){
11641 pArg->cMode = MODE_Explain;
11642 explain_data_prepare(pArg, pExplain);
11643 exec_prepared_stmt(pArg, pExplain);
11644 explain_data_delete(pArg);
11646 sqlite3_finalize(pExplain);
11647 sqlite3_free(zEQP);
11649 if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){
11650 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0);
11651 /* Reprepare pStmt before reactiving trace modes */
11652 sqlite3_finalize(pStmt);
11653 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
11654 if( pArg ) pArg->pStmt = pStmt;
11656 restore_debug_trace_modes();
11660 pArg->cMode = pArg->mode;
11661 if( pArg->autoExplain ){
11662 if( sqlite3_stmt_isexplain(pStmt)==1 ){
11663 pArg->cMode = MODE_Explain;
11665 if( sqlite3_stmt_isexplain(pStmt)==2 ){
11666 pArg->cMode = MODE_EQP;
11670 /* If the shell is currently in ".explain" mode, gather the extra
11671 ** data required to add indents to the output.*/
11672 if( pArg->cMode==MODE_Explain ){
11673 explain_data_prepare(pArg, pStmt);
11677 bind_prepared_stmt(pArg, pStmt);
11678 exec_prepared_stmt(pArg, pStmt);
11679 explain_data_delete(pArg);
11682 /* print usage stats if stats on */
11683 if( pArg && pArg->statsOn ){
11684 display_stats(db, pArg, 0);
11687 /* print loop-counters if required */
11688 if( pArg && pArg->scanstatsOn ){
11689 display_scanstats(db, pArg);
11692 /* Finalize the statement just executed. If this fails, save a
11693 ** copy of the error message. Otherwise, set zSql to point to the
11694 ** next statement to execute. */
11695 rc2 = sqlite3_finalize(pStmt);
11696 if( rc!=SQLITE_NOMEM ) rc = rc2;
11697 if( rc==SQLITE_OK ){
11699 while( IsSpace(zSql[0]) ) zSql++;
11700 }else if( pzErrMsg ){
11701 *pzErrMsg = save_err_msg(db);
11704 /* clear saved stmt handle */
11706 pArg->pStmt = NULL;
11715 ** Release memory previously allocated by tableColumnList().
11717 static void freeColumnList(char **azCol){
11719 for(i=1; azCol[i]; i++){
11720 sqlite3_free(azCol[i]);
11722 /* azCol[0] is a static string */
11723 sqlite3_free(azCol);
11727 ** Return a list of pointers to strings which are the names of all
11728 ** columns in table zTab. The memory to hold the names is dynamically
11729 ** allocated and must be released by the caller using a subsequent call
11730 ** to freeColumnList().
11732 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
11733 ** value that needs to be preserved, then azCol[0] is filled in with the
11734 ** name of the rowid column.
11736 ** The first regular column in the table is azCol[1]. The list is terminated
11737 ** by an entry with azCol[i]==0.
11739 static char **tableColumnList(ShellState *p, const char *zTab){
11741 sqlite3_stmt *pStmt;
11745 int nPK = 0; /* Number of PRIMARY KEY columns seen */
11746 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
11747 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
11750 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
11751 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
11752 sqlite3_free(zSql);
11754 while( sqlite3_step(pStmt)==SQLITE_ROW ){
11755 if( nCol>=nAlloc-2 ){
11756 nAlloc = nAlloc*2 + nCol + 10;
11757 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
11758 if( azCol==0 ) shell_out_of_memory();
11760 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
11761 if( sqlite3_column_int(pStmt, 5) ){
11764 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
11773 sqlite3_finalize(pStmt);
11774 if( azCol==0 ) return 0;
11778 /* The decision of whether or not a rowid really needs to be preserved
11779 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
11780 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
11781 ** rowids on tables where the rowid is inaccessible because there are other
11782 ** columns in the table named "rowid", "_rowid_", and "oid".
11784 if( preserveRowid && isIPK ){
11785 /* If a single PRIMARY KEY column with type INTEGER was seen, then it
11786 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
11787 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
11788 ** ROWID aliases. To distinguish these cases, check to see if
11789 ** there is a "pk" entry in "PRAGMA index_list". There will be
11790 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
11792 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
11793 " WHERE origin='pk'", zTab);
11794 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
11795 sqlite3_free(zSql);
11797 freeColumnList(azCol);
11800 rc = sqlite3_step(pStmt);
11801 sqlite3_finalize(pStmt);
11802 preserveRowid = rc==SQLITE_ROW;
11804 if( preserveRowid ){
11805 /* Only preserve the rowid if we can find a name to use for the
11807 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
11809 for(j=0; j<3; j++){
11810 for(i=1; i<=nCol; i++){
11811 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
11814 /* At this point, we know that azRowid[j] is not the name of any
11815 ** ordinary column in the table. Verify that azRowid[j] is a valid
11816 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
11817 ** tables will fail this last check */
11818 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
11819 if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
11828 ** Toggle the reverse_unordered_selects setting.
11830 static void toggleSelectOrder(sqlite3 *db){
11831 sqlite3_stmt *pStmt = 0;
11834 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
11835 if( sqlite3_step(pStmt)==SQLITE_ROW ){
11836 iSetting = sqlite3_column_int(pStmt, 0);
11838 sqlite3_finalize(pStmt);
11839 sqlite3_snprintf(sizeof(zStmt), zStmt,
11840 "PRAGMA reverse_unordered_selects(%d)", !iSetting);
11841 sqlite3_exec(db, zStmt, 0, 0, 0);
11845 ** This is a different callback routine used for dumping the database.
11846 ** Each row received by this callback consists of a table name,
11847 ** the table type ("index" or "table") and SQL to create the table.
11848 ** This routine should print text sufficient to recreate the table.
11850 static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
11852 const char *zTable;
11855 ShellState *p = (ShellState *)pArg;
11857 UNUSED_PARAMETER(azNotUsed);
11858 if( nArg!=3 || azArg==0 ) return 0;
11863 if( strcmp(zTable, "sqlite_sequence")==0 ){
11864 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
11865 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
11866 raw_printf(p->out, "ANALYZE sqlite_master;\n");
11867 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
11869 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
11871 if( !p->writableSchema ){
11872 raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
11873 p->writableSchema = 1;
11875 zIns = sqlite3_mprintf(
11876 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
11877 "VALUES('table','%q','%q',0,'%q');",
11878 zTable, zTable, zSql);
11879 utf8_printf(p->out, "%s\n", zIns);
11880 sqlite3_free(zIns);
11883 printSchemaLine(p->out, zSql, ";\n");
11886 if( strcmp(zType, "table")==0 ){
11891 char *savedDestTable;
11894 azCol = tableColumnList(p, zTable);
11900 /* Always quote the table name, even if it appears to be pure ascii,
11901 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
11903 appendText(&sTable, zTable, quoteChar(zTable));
11904 /* If preserving the rowid, add a column list after the table name.
11905 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
11906 ** instead of the usual "INSERT INTO tab VALUES(...)".
11909 appendText(&sTable, "(", 0);
11910 appendText(&sTable, azCol[0], 0);
11911 for(i=1; azCol[i]; i++){
11912 appendText(&sTable, ",", 0);
11913 appendText(&sTable, azCol[i], quoteChar(azCol[i]));
11915 appendText(&sTable, ")", 0);
11918 /* Build an appropriate SELECT statement */
11919 initText(&sSelect);
11920 appendText(&sSelect, "SELECT ", 0);
11922 appendText(&sSelect, azCol[0], 0);
11923 appendText(&sSelect, ",", 0);
11925 for(i=1; azCol[i]; i++){
11926 appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
11928 appendText(&sSelect, ",", 0);
11931 freeColumnList(azCol);
11932 appendText(&sSelect, " FROM ", 0);
11933 appendText(&sSelect, zTable, quoteChar(zTable));
11935 savedDestTable = p->zDestTable;
11936 savedMode = p->mode;
11937 p->zDestTable = sTable.z;
11938 p->mode = p->cMode = MODE_Insert;
11939 rc = shell_exec(p, sSelect.z, 0);
11940 if( (rc&0xff)==SQLITE_CORRUPT ){
11941 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
11942 toggleSelectOrder(p->db);
11943 shell_exec(p, sSelect.z, 0);
11944 toggleSelectOrder(p->db);
11946 p->zDestTable = savedDestTable;
11947 p->mode = savedMode;
11949 freeText(&sSelect);
11950 if( rc ) p->nErr++;
11956 ** Run zQuery. Use dump_callback() as the callback routine so that
11957 ** the contents of the query are output as SQL statements.
11959 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
11960 ** "ORDER BY rowid DESC" to the end.
11962 static int run_schema_dump_query(
11968 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
11969 if( rc==SQLITE_CORRUPT ){
11971 int len = strlen30(zQuery);
11972 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
11974 utf8_printf(p->out, "/****** %s ******/\n", zErr);
11975 sqlite3_free(zErr);
11978 zQ2 = malloc( len+100 );
11979 if( zQ2==0 ) return rc;
11980 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
11981 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
11983 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr);
11985 rc = SQLITE_CORRUPT;
11987 sqlite3_free(zErr);
11994 ** Text of help messages.
11996 ** The help text for each individual command begins with a line that starts
11997 ** with ".". Subsequent lines are supplimental information.
11999 ** There must be two or more spaces between the end of the command and the
12000 ** start of the description of what that command does.
12002 static const char *(azHelp[]) = {
12003 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
12004 ".archive ... Manage SQL archives",
12005 " Each command must have exactly one of the following options:",
12006 " -c, --create Create a new archive",
12007 " -u, --update Add files or update files with changed mtime",
12008 " -i, --insert Like -u but always add even if mtime unchanged",
12009 " -t, --list List contents of archive",
12010 " -x, --extract Extract files from archive",
12011 " Optional arguments:",
12012 " -v, --verbose Print each filename as it is processed",
12013 " -f FILE, --file FILE Operate on archive FILE (default is current db)",
12014 " -a FILE, --append FILE Operate on FILE opened using the apndvfs VFS",
12015 " -C DIR, --directory DIR Change to directory DIR to read/extract files",
12016 " -n, --dryrun Show the SQL that would have occurred",
12018 " .ar -cf archive.sar foo bar # Create archive.sar from files foo and bar",
12019 " .ar -tf archive.sar # List members of archive.sar",
12020 " .ar -xvf archive.sar # Verbosely extract files from archive.sar",
12022 " http://sqlite.org/cli.html#sqlar_archive_support",
12024 #ifndef SQLITE_OMIT_AUTHORIZATION
12025 ".auth ON|OFF Show authorizer callbacks",
12027 ".backup ?DB? FILE Backup DB (default \"main\") to FILE",
12028 " --append Use the appendvfs",
12029 " --async Write to FILE without a journal and without fsync()",
12030 ".bail on|off Stop after hitting an error. Default OFF",
12031 ".binary on|off Turn binary output on or off. Default OFF",
12032 ".cd DIRECTORY Change the working directory to DIRECTORY",
12033 ".changes on|off Show number of rows changed by SQL",
12034 ".check GLOB Fail if output since .testcase does not match",
12035 ".clone NEWDB Clone data into NEWDB from the existing database",
12036 ".databases List names and files of attached databases",
12037 ".dbconfig ?op? ?val? List or change sqlite3_db_config() options",
12038 ".dbinfo ?DB? Show status information about the database",
12039 ".dump ?TABLE? ... Render all database content as SQL",
12041 " --preserve-rowids Include ROWID values in the output",
12042 " --newlines Allow unescaped newline characters in output",
12043 " TABLE is a LIKE pattern for the tables to dump",
12044 ".echo on|off Turn command echo on or off",
12045 ".eqp on|off|full|... Enable or disable automatic EXPLAIN QUERY PLAN",
12047 #ifdef SQLITE_DEBUG
12048 " test Show raw EXPLAIN QUERY PLAN output",
12049 " trace Like \"full\" but also enable \"PRAGMA vdbe_trace\"",
12051 " trigger Like \"full\" but also show trigger bytecode",
12052 ".excel Display the output of next command in a spreadsheet",
12053 ".exit ?CODE? Exit this program with return-code CODE",
12054 ".expert EXPERIMENTAL. Suggest indexes for specified queries",
12055 /* Because explain mode comes on automatically now, the ".explain" mode
12056 ** is removed from the help screen. It is still supported for legacy, however */
12057 /*".explain ?on|off|auto? Turn EXPLAIN output mode on or off or to automatic",*/
12058 ".filectrl CMD ... Run various sqlite3_file_control() operations",
12059 " Run \".filectrl\" with no arguments for details",
12060 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables",
12061 ".headers on|off Turn display of headers on or off",
12062 ".help ?-all? ?PATTERN? Show help text for PATTERN",
12063 ".import FILE TABLE Import data from FILE into TABLE",
12064 #ifndef SQLITE_OMIT_TEST_CONTROL
12065 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX",
12067 ".indexes ?TABLE? Show names of indexes",
12068 " If TABLE is specified, only show indexes for",
12069 " tables matching TABLE using the LIKE operator.",
12070 #ifdef SQLITE_ENABLE_IOTRACE
12071 ".iotrace FILE Enable I/O diagnostic logging to FILE",
12073 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT",
12074 ".lint OPTIONS Report potential schema issues.",
12076 " fkey-indexes Find missing foreign key indexes",
12077 #ifndef SQLITE_OMIT_LOAD_EXTENSION
12078 ".load FILE ?ENTRY? Load an extension library",
12080 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout",
12081 ".mode MODE ?TABLE? Set output mode",
12082 " MODE is one of:",
12083 " ascii Columns/rows delimited by 0x1F and 0x1E",
12084 " csv Comma-separated values",
12085 " column Left-aligned columns. (See .width)",
12086 " html HTML <table> code",
12087 " insert SQL insert statements for TABLE",
12088 " line One value per line",
12089 " list Values delimited by \"|\"",
12090 " quote Escape answers as for SQL",
12091 " tabs Tab-separated values",
12092 " tcl TCL list elements",
12093 ".nullvalue STRING Use STRING in place of NULL values",
12094 ".once (-e|-x|FILE) Output for the next SQL command only to FILE",
12095 " If FILE begins with '|' then open as a pipe",
12097 " -e Invoke system text editor",
12098 " -x Open in a spreadsheet",
12099 ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE",
12101 " --append Use appendvfs to append database to the end of FILE",
12102 #ifdef SQLITE_ENABLE_DESERIALIZE
12103 " --deserialize Load into memory useing sqlite3_deserialize()",
12104 " --hexdb Load the output of \"dbtotxt\" as an in-memory database",
12105 " --maxsize N Maximum size for --hexdb or --deserialized database",
12107 " --new Initialize FILE to an empty database",
12108 " --readonly Open FILE readonly",
12109 " --zip FILE is a ZIP archive",
12110 ".output ?FILE? Send output to FILE or stdout if FILE is omitted",
12111 " If FILE begins with '|' then open it as a pipe.",
12112 ".parameter CMD ... Manage SQL parameter bindings",
12113 " clear Erase all bindings",
12114 " init Initialize the TEMP table that holds bindings",
12115 " list List the current parameter bindings",
12116 " set PARAMETER VALUE Given SQL parameter PARAMETER a value of VALUE",
12117 " PARAMETER should start with '$', ':', '@', or '?'",
12118 " unset PARAMETER Remove PARAMETER from the binding table",
12119 ".print STRING... Print literal STRING",
12120 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
12121 ".progress N Invoke progress handler after every N opcodes",
12122 " --limit N Interrupt after N progress callbacks",
12123 " --once Do no more than one progress interrupt",
12124 " --quiet|-q No output except at interrupts",
12125 " --reset Reset the count for each input and interrupt",
12127 ".prompt MAIN CONTINUE Replace the standard prompts",
12128 ".quit Exit this program",
12129 ".read FILE Read input from FILE",
12130 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
12131 ".recover Recover as much data as possible from corrupt db.",
12133 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE",
12134 ".save FILE Write in-memory database into FILE",
12135 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off",
12136 ".schema ?PATTERN? Show the CREATE statements matching PATTERN",
12138 " --indent Try to pretty-print the schema",
12139 ".selftest ?OPTIONS? Run tests defined in the SELFTEST table",
12141 " --init Create a new SELFTEST table",
12142 " -v Verbose output",
12143 ".separator COL ?ROW? Change the column and row separators",
12144 #if defined(SQLITE_ENABLE_SESSION)
12145 ".session ?NAME? CMD ... Create or control sessions",
12147 " attach TABLE Attach TABLE",
12148 " changeset FILE Write a changeset into FILE",
12149 " close Close one session",
12150 " enable ?BOOLEAN? Set or query the enable bit",
12151 " filter GLOB... Reject tables matching GLOBs",
12152 " indirect ?BOOLEAN? Mark or query the indirect status",
12153 " isempty Query whether the session is empty",
12154 " list List currently open session names",
12155 " open DB NAME Open a new session on DB",
12156 " patchset FILE Write a patchset into FILE",
12157 " If ?NAME? is omitted, the first defined session is used.",
12159 ".sha3sum ... Compute a SHA3 hash of database content",
12161 " --schema Also hash the sqlite_master table",
12162 " --sha3-224 Use the sha3-224 algorithm",
12163 " --sha3-256 Use the sha3-256 algorithm. This is the default.",
12164 " --sha3-384 Use the sha3-384 algorithm",
12165 " --sha3-512 Use the sha3-512 algorithm",
12166 " Any other argument is a LIKE pattern for tables to hash",
12167 #ifndef SQLITE_NOHAVE_SYSTEM
12168 ".shell CMD ARGS... Run CMD ARGS... in a system shell",
12170 ".show Show the current values for various settings",
12171 ".stats ?on|off? Show stats or turn stats on or off",
12172 #ifndef SQLITE_NOHAVE_SYSTEM
12173 ".system CMD ARGS... Run CMD ARGS... in a system shell",
12175 ".tables ?TABLE? List names of tables matching LIKE pattern TABLE",
12176 ".testcase NAME Begin redirecting output to 'testcase-out.txt'",
12177 ".testctrl CMD ... Run various sqlite3_test_control() operations",
12178 " Run \".testctrl\" with no arguments for details",
12179 ".timeout MS Try opening locked tables for MS milliseconds",
12180 ".timer on|off Turn SQL timer on or off",
12181 #ifndef SQLITE_OMIT_TRACE
12182 ".trace ?OPTIONS? Output each SQL statement as it is run",
12183 " FILE Send output to FILE",
12184 " stdout Send output to stdout",
12185 " stderr Send output to stderr",
12186 " off Disable tracing",
12187 " --expanded Expand query parameters",
12188 #ifdef SQLITE_ENABLE_NORMALIZE
12189 " --normalized Normal the SQL statements",
12191 " --plain Show SQL as it is input",
12192 " --stmt Trace statement execution (SQLITE_TRACE_STMT)",
12193 " --profile Profile statements (SQLITE_TRACE_PROFILE)",
12194 " --row Trace each row (SQLITE_TRACE_ROW)",
12195 " --close Trace connection close (SQLITE_TRACE_CLOSE)",
12196 #endif /* SQLITE_OMIT_TRACE */
12197 ".vfsinfo ?AUX? Information about the top-level VFS",
12198 ".vfslist List all available VFSes",
12199 ".vfsname ?AUX? Print the name of the VFS stack",
12200 ".width NUM1 NUM2 ... Set column widths for \"column\" mode",
12201 " Negative values right-justify",
12205 ** Output help text.
12207 ** zPattern describes the set of commands for which help text is provided.
12208 ** If zPattern is NULL, then show all commands, but only give a one-line
12209 ** description of each.
12211 ** Return the number of matches.
12213 static int showHelp(FILE *out, const char *zPattern){
12219 || zPattern[0]=='0'
12220 || strcmp(zPattern,"-a")==0
12221 || strcmp(zPattern,"-all")==0
12223 /* Show all commands, but only one line per command */
12224 if( zPattern==0 ) zPattern = "";
12225 for(i=0; i<ArraySize(azHelp); i++){
12226 if( azHelp[i][0]=='.' || zPattern[0] ){
12227 utf8_printf(out, "%s\n", azHelp[i]);
12232 /* Look for commands that for which zPattern is an exact prefix */
12233 zPat = sqlite3_mprintf(".%s*", zPattern);
12234 for(i=0; i<ArraySize(azHelp); i++){
12235 if( sqlite3_strglob(zPat, azHelp[i])==0 ){
12236 utf8_printf(out, "%s\n", azHelp[i]);
12241 sqlite3_free(zPat);
12244 /* when zPattern is a prefix of exactly one command, then include the
12245 ** details of that command, which should begin at offset j */
12246 while( j<ArraySize(azHelp)-1 && azHelp[j][0]!='.' ){
12247 utf8_printf(out, "%s\n", azHelp[j]);
12253 /* Look for commands that contain zPattern anywhere. Show the complete
12254 ** text of all commands that match. */
12255 zPat = sqlite3_mprintf("%%%s%%", zPattern);
12256 for(i=0; i<ArraySize(azHelp); i++){
12257 if( azHelp[i][0]=='.' ) j = i;
12258 if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){
12259 utf8_printf(out, "%s\n", azHelp[j]);
12260 while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]!='.' ){
12262 utf8_printf(out, "%s\n", azHelp[j]);
12268 sqlite3_free(zPat);
12273 /* Forward reference */
12274 static int process_input(ShellState *p);
12277 ** Read the content of file zName into memory obtained from sqlite3_malloc64()
12278 ** and return a pointer to the buffer. The caller is responsible for freeing
12281 ** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes
12284 ** For convenience, a nul-terminator byte is always appended to the data read
12285 ** from the file before the buffer is returned. This byte is not included in
12286 ** the final value of (*pnByte), if applicable.
12288 ** NULL is returned if any error is encountered. The final value of *pnByte
12289 ** is undefined in this case.
12291 static char *readFile(const char *zName, int *pnByte){
12292 FILE *in = fopen(zName, "rb");
12296 if( in==0 ) return 0;
12297 fseek(in, 0, SEEK_END);
12300 pBuf = sqlite3_malloc64( nIn+1 );
12301 if( pBuf==0 ){ fclose(in); return 0; }
12302 nRead = fread(pBuf, nIn, 1, in);
12305 sqlite3_free(pBuf);
12309 if( pnByte ) *pnByte = nIn;
12313 #if defined(SQLITE_ENABLE_SESSION)
12315 ** Close a single OpenSession object and release all of its associated
12318 static void session_close(OpenSession *pSession){
12320 sqlite3session_delete(pSession->p);
12321 sqlite3_free(pSession->zName);
12322 for(i=0; i<pSession->nFilter; i++){
12323 sqlite3_free(pSession->azFilter[i]);
12325 sqlite3_free(pSession->azFilter);
12326 memset(pSession, 0, sizeof(OpenSession));
12331 ** Close all OpenSession objects and release all associated resources.
12333 #if defined(SQLITE_ENABLE_SESSION)
12334 static void session_close_all(ShellState *p){
12336 for(i=0; i<p->nSession; i++){
12337 session_close(&p->aSession[i]);
12342 # define session_close_all(X)
12346 ** Implementation of the xFilter function for an open session. Omit
12347 ** any tables named by ".session filter" but let all other table through.
12349 #if defined(SQLITE_ENABLE_SESSION)
12350 static int session_filter(void *pCtx, const char *zTab){
12351 OpenSession *pSession = (OpenSession*)pCtx;
12353 for(i=0; i<pSession->nFilter; i++){
12354 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0;
12361 ** Try to deduce the type of file for zName based on its content. Return
12362 ** one of the SHELL_OPEN_* constants.
12364 ** If the file does not exist or is empty but its name looks like a ZIP
12365 ** archive and the dfltZip flag is true, then assume it is a ZIP archive.
12366 ** Otherwise, assume an ordinary database regardless of the filename if
12367 ** the type cannot be determined from content.
12369 int deduceDatabaseType(const char *zName, int dfltZip){
12370 FILE *f = fopen(zName, "rb");
12372 int rc = SHELL_OPEN_UNSPEC;
12375 if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
12376 return SHELL_OPEN_ZIPFILE;
12378 return SHELL_OPEN_NORMAL;
12381 n = fread(zBuf, 16, 1, f);
12382 if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){
12384 return SHELL_OPEN_NORMAL;
12386 fseek(f, -25, SEEK_END);
12387 n = fread(zBuf, 25, 1, f);
12388 if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){
12389 rc = SHELL_OPEN_APPENDVFS;
12391 fseek(f, -22, SEEK_END);
12392 n = fread(zBuf, 22, 1, f);
12393 if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05
12394 && zBuf[3]==0x06 ){
12395 rc = SHELL_OPEN_ZIPFILE;
12396 }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
12397 rc = SHELL_OPEN_ZIPFILE;
12404 #ifdef SQLITE_ENABLE_DESERIALIZE
12406 ** Reconstruct an in-memory database using the output from the "dbtotxt"
12407 ** program. Read content from the file in p->zDbFilename. If p->zDbFilename
12408 ** is 0, then read from standard input.
12410 static unsigned char *readHexDb(ShellState *p, int *pnData){
12411 unsigned char *a = 0;
12419 unsigned int x[16];
12421 if( p->zDbFilename ){
12422 in = fopen(p->zDbFilename, "r");
12424 utf8_printf(stderr, "cannot open \"%s\" for reading\n", p->zDbFilename);
12431 if( in==0 ) in = stdin;
12435 if( fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error;
12436 rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz);
12437 if( rc!=2 ) goto readHexDb_error;
12438 if( n<0 ) goto readHexDb_error;
12439 a = sqlite3_malloc( n ? n : 1 );
12441 utf8_printf(stderr, "Out of memory!\n");
12442 goto readHexDb_error;
12445 if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){
12446 utf8_printf(stderr, "invalid pagesize\n");
12447 goto readHexDb_error;
12449 for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){
12450 rc = sscanf(zLine, "| page %d offset %d", &j, &k);
12455 if( strncmp(zLine, "| end ", 6)==0 ){
12458 rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
12459 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7],
12460 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]);
12465 for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff;
12481 while( fgets(zLine, sizeof(zLine), p->in)!=0 ){
12483 if(strncmp(zLine, "| end ", 6)==0 ) break;
12488 utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine);
12491 #endif /* SQLITE_ENABLE_DESERIALIZE */
12494 ** Scalar function "shell_int32". The first argument to this function
12495 ** must be a blob. The second a non-negative integer. This function
12496 ** reads and returns a 32-bit big-endian integer from byte
12497 ** offset (4*<arg2>) of the blob.
12499 static void shellInt32(
12500 sqlite3_context *context,
12502 sqlite3_value **argv
12504 const unsigned char *pBlob;
12508 UNUSED_PARAMETER(argc);
12509 nBlob = sqlite3_value_bytes(argv[0]);
12510 pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]);
12511 iInt = sqlite3_value_int(argv[1]);
12513 if( iInt>=0 && (iInt+1)*4<=nBlob ){
12514 const unsigned char *a = &pBlob[iInt*4];
12515 sqlite3_int64 iVal = ((sqlite3_int64)a[0]<<24)
12516 + ((sqlite3_int64)a[1]<<16)
12517 + ((sqlite3_int64)a[2]<< 8)
12518 + ((sqlite3_int64)a[3]<< 0);
12519 sqlite3_result_int64(context, iVal);
12524 ** Scalar function "shell_escape_crnl" used by the .recover command.
12525 ** The argument passed to this function is the output of built-in
12526 ** function quote(). If the first character of the input is "'",
12527 ** indicating that the value passed to quote() was a text value,
12528 ** then this function searches the input for "\n" and "\r" characters
12529 ** and adds a wrapper similar to the following:
12531 ** replace(replace(<input>, '\n', char(10), '\r', char(13));
12533 ** Or, if the first character of the input is not "'", then a copy
12534 ** of the input is returned.
12536 static void shellEscapeCrnl(
12537 sqlite3_context *context,
12539 sqlite3_value **argv
12541 const char *zText = (const char*)sqlite3_value_text(argv[0]);
12542 UNUSED_PARAMETER(argc);
12543 if( zText[0]=='\'' ){
12544 int nText = sqlite3_value_bytes(argv[0]);
12548 const char *zNL = 0;
12549 const char *zCR = 0;
12553 for(i=0; zText[i]; i++){
12554 if( zNL==0 && zText[i]=='\n' ){
12555 zNL = unused_string(zText, "\\n", "\\012", zBuf1);
12556 nNL = (int)strlen(zNL);
12558 if( zCR==0 && zText[i]=='\r' ){
12559 zCR = unused_string(zText, "\\r", "\\015", zBuf2);
12560 nCR = (int)strlen(zCR);
12566 i64 nMax = (nNL > nCR) ? nNL : nCR;
12567 i64 nAlloc = nMax * nText + (nMax+64)*2;
12568 char *zOut = (char*)sqlite3_malloc64(nAlloc);
12570 sqlite3_result_error_nomem(context);
12575 memcpy(&zOut[iOut], "replace(replace(", 16);
12578 memcpy(&zOut[iOut], "replace(", 8);
12581 for(i=0; zText[i]; i++){
12582 if( zText[i]=='\n' ){
12583 memcpy(&zOut[iOut], zNL, nNL);
12585 }else if( zText[i]=='\r' ){
12586 memcpy(&zOut[iOut], zCR, nCR);
12589 zOut[iOut] = zText[i];
12595 memcpy(&zOut[iOut], ",'", 2); iOut += 2;
12596 memcpy(&zOut[iOut], zNL, nNL); iOut += nNL;
12597 memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12;
12600 memcpy(&zOut[iOut], ",'", 2); iOut += 2;
12601 memcpy(&zOut[iOut], zCR, nCR); iOut += nCR;
12602 memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12;
12605 sqlite3_result_text(context, zOut, iOut, SQLITE_TRANSIENT);
12606 sqlite3_free(zOut);
12611 sqlite3_result_value(context, argv[0]);
12614 /* Flags for open_db().
12616 ** The default behavior of open_db() is to exit(1) if the database fails to
12617 ** open. The OPEN_DB_KEEPALIVE flag changes that so that it prints an error
12618 ** but still returns without calling exit.
12620 ** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a
12621 ** ZIP archive if the file does not exist or is empty and its name matches
12622 ** the *.zip pattern.
12624 #define OPEN_DB_KEEPALIVE 0x001 /* Return after error if true */
12625 #define OPEN_DB_ZIPFILE 0x002 /* Open as ZIP if name matches *.zip */
12628 ** Make sure the database is open. If it is not, then open it. If
12629 ** the database fails to open, print an error message and exit.
12631 static void open_db(ShellState *p, int openFlags){
12633 if( p->openMode==SHELL_OPEN_UNSPEC ){
12634 if( p->zDbFilename==0 || p->zDbFilename[0]==0 ){
12635 p->openMode = SHELL_OPEN_NORMAL;
12637 p->openMode = (u8)deduceDatabaseType(p->zDbFilename,
12638 (openFlags & OPEN_DB_ZIPFILE)!=0);
12641 switch( p->openMode ){
12642 case SHELL_OPEN_APPENDVFS: {
12643 sqlite3_open_v2(p->zDbFilename, &p->db,
12644 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, "apndvfs");
12647 case SHELL_OPEN_HEXDB:
12648 case SHELL_OPEN_DESERIALIZE: {
12649 sqlite3_open(0, &p->db);
12652 case SHELL_OPEN_ZIPFILE: {
12653 sqlite3_open(":memory:", &p->db);
12656 case SHELL_OPEN_READONLY: {
12657 sqlite3_open_v2(p->zDbFilename, &p->db, SQLITE_OPEN_READONLY, 0);
12660 case SHELL_OPEN_UNSPEC:
12661 case SHELL_OPEN_NORMAL: {
12662 sqlite3_open(p->zDbFilename, &p->db);
12667 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
12668 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
12669 p->zDbFilename, sqlite3_errmsg(p->db));
12670 if( openFlags & OPEN_DB_KEEPALIVE ){
12671 sqlite3_open(":memory:", &p->db);
12676 #ifndef SQLITE_OMIT_LOAD_EXTENSION
12677 sqlite3_enable_load_extension(p->db, 1);
12679 sqlite3_fileio_init(p->db, 0, 0);
12680 sqlite3_shathree_init(p->db, 0, 0);
12681 sqlite3_completion_init(p->db, 0, 0);
12682 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
12683 sqlite3_dbdata_init(p->db, 0, 0);
12685 #ifdef SQLITE_HAVE_ZLIB
12686 sqlite3_zipfile_init(p->db, 0, 0);
12687 sqlite3_sqlar_init(p->db, 0, 0);
12689 sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0,
12690 shellAddSchemaName, 0, 0);
12691 sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, 0,
12692 shellModuleSchema, 0, 0);
12693 sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p,
12694 shellPutsFunc, 0, 0);
12695 sqlite3_create_function(p->db, "shell_escape_crnl", 1, SQLITE_UTF8, 0,
12696 shellEscapeCrnl, 0, 0);
12697 sqlite3_create_function(p->db, "shell_int32", 2, SQLITE_UTF8, 0,
12699 #ifndef SQLITE_NOHAVE_SYSTEM
12700 sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0,
12702 sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0,
12705 if( p->openMode==SHELL_OPEN_ZIPFILE ){
12706 char *zSql = sqlite3_mprintf(
12707 "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", p->zDbFilename);
12708 sqlite3_exec(p->db, zSql, 0, 0, 0);
12709 sqlite3_free(zSql);
12711 #ifdef SQLITE_ENABLE_DESERIALIZE
12713 if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){
12716 unsigned char *aData;
12717 if( p->openMode==SHELL_OPEN_DESERIALIZE ){
12718 aData = (unsigned char*)readFile(p->zDbFilename, &nData);
12720 aData = readHexDb(p, &nData);
12725 rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
12726 SQLITE_DESERIALIZE_RESIZEABLE |
12727 SQLITE_DESERIALIZE_FREEONCLOSE);
12729 utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc);
12732 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
12740 ** Attempt to close the databaes connection. Report errors.
12742 void close_db(sqlite3 *db){
12743 int rc = sqlite3_close(db);
12745 utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n",
12746 rc, sqlite3_errmsg(db));
12750 #if HAVE_READLINE || HAVE_EDITLINE
12752 ** Readline completion callbacks
12754 static char *readline_completion_generator(const char *text, int state){
12755 static sqlite3_stmt *pStmt = 0;
12759 sqlite3_finalize(pStmt);
12760 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
12761 " FROM completion(%Q) ORDER BY 1", text);
12762 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
12763 sqlite3_free(zSql);
12765 if( sqlite3_step(pStmt)==SQLITE_ROW ){
12766 zRet = strdup((const char*)sqlite3_column_text(pStmt, 0));
12768 sqlite3_finalize(pStmt);
12774 static char **readline_completion(const char *zText, int iStart, int iEnd){
12775 rl_attempted_completion_over = 1;
12776 return rl_completion_matches(zText, readline_completion_generator);
12779 #elif HAVE_LINENOISE
12781 ** Linenoise completion callback
12783 static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){
12784 int nLine = strlen30(zLine);
12786 sqlite3_stmt *pStmt = 0;
12790 if( nLine>sizeof(zBuf)-30 ) return;
12791 if( zLine[0]=='.' || zLine[0]=='#') return;
12792 for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){}
12793 if( i==nLine-1 ) return;
12795 memcpy(zBuf, zLine, iStart);
12796 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
12797 " FROM completion(%Q,%Q) ORDER BY 1",
12798 &zLine[iStart], zLine);
12799 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
12800 sqlite3_free(zSql);
12801 sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */
12802 while( sqlite3_step(pStmt)==SQLITE_ROW ){
12803 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0);
12804 int nCompletion = sqlite3_column_bytes(pStmt, 0);
12805 if( iStart+nCompletion < sizeof(zBuf)-1 ){
12806 memcpy(zBuf+iStart, zCompletion, nCompletion+1);
12807 linenoiseAddCompletion(lc, zBuf);
12810 sqlite3_finalize(pStmt);
12815 ** Do C-language style dequoting.
12821 ** \v -> vertical tab
12823 ** \r -> carriage return
12828 ** \NNN -> ascii character NNN in octal
12830 static void resolve_backslashes(char *z){
12833 while( *z && *z!='\\' ) z++;
12834 for(i=j=0; (c = z[i])!=0; i++, j++){
12835 if( c=='\\' && z[i+1]!=0 ){
12839 }else if( c=='b' ){
12841 }else if( c=='t' ){
12843 }else if( c=='n' ){
12845 }else if( c=='v' ){
12847 }else if( c=='f' ){
12849 }else if( c=='r' ){
12851 }else if( c=='"' ){
12853 }else if( c=='\'' ){
12855 }else if( c=='\\' ){
12857 }else if( c>='0' && c<='7' ){
12859 if( z[i+1]>='0' && z[i+1]<='7' ){
12861 c = (c<<3) + z[i] - '0';
12862 if( z[i+1]>='0' && z[i+1]<='7' ){
12864 c = (c<<3) + z[i] - '0';
12871 if( j<i ) z[j] = 0;
12875 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
12876 ** for TRUE and FALSE. Return the integer value if appropriate.
12878 static int booleanValue(const char *zArg){
12880 if( zArg[0]=='0' && zArg[1]=='x' ){
12881 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
12883 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
12885 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
12886 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
12889 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
12892 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
12898 ** Set or clear a shell flag according to a boolean value.
12900 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
12901 if( booleanValue(zArg) ){
12902 ShellSetFlag(p, mFlag);
12904 ShellClearFlag(p, mFlag);
12909 ** Close an output file, assuming it is not stderr or stdout
12911 static void output_file_close(FILE *f){
12912 if( f && f!=stdout && f!=stderr ) fclose(f);
12916 ** Try to open an output file. The names "stdout" and "stderr" are
12917 ** recognized and do the right thing. NULL is returned if the output
12918 ** filename is "off".
12920 static FILE *output_file_open(const char *zFile, int bTextMode){
12922 if( strcmp(zFile,"stdout")==0 ){
12924 }else if( strcmp(zFile, "stderr")==0 ){
12926 }else if( strcmp(zFile, "off")==0 ){
12929 f = fopen(zFile, bTextMode ? "w" : "wb");
12931 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
12937 #ifndef SQLITE_OMIT_TRACE
12939 ** A routine for handling output from sqlite3_trace().
12941 static int sql_trace_callback(
12942 unsigned mType, /* The trace type */
12943 void *pArg, /* The ShellState pointer */
12944 void *pP, /* Usually a pointer to sqlite_stmt */
12945 void *pX /* Auxiliary output */
12947 ShellState *p = (ShellState*)pArg;
12948 sqlite3_stmt *pStmt;
12951 if( p->traceOut==0 ) return 0;
12952 if( mType==SQLITE_TRACE_CLOSE ){
12953 utf8_printf(p->traceOut, "-- closing database connection\n");
12956 if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){
12957 zSql = (const char*)pX;
12959 pStmt = (sqlite3_stmt*)pP;
12960 switch( p->eTraceType ){
12961 case SHELL_TRACE_EXPANDED: {
12962 zSql = sqlite3_expanded_sql(pStmt);
12965 #ifdef SQLITE_ENABLE_NORMALIZE
12966 case SHELL_TRACE_NORMALIZED: {
12967 zSql = sqlite3_normalized_sql(pStmt);
12972 zSql = sqlite3_sql(pStmt);
12977 if( zSql==0 ) return 0;
12978 nSql = strlen30(zSql);
12979 while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
12981 case SQLITE_TRACE_ROW:
12982 case SQLITE_TRACE_STMT: {
12983 utf8_printf(p->traceOut, "%.*s;\n", nSql, zSql);
12986 case SQLITE_TRACE_PROFILE: {
12987 sqlite3_int64 nNanosec = *(sqlite3_int64*)pX;
12988 utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", nSql, zSql, nNanosec);
12997 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
12998 ** a useful spot to set a debugger breakpoint.
13000 static void test_breakpoint(void){
13001 static int nCall = 0;
13006 ** An object used to read a CSV and other files for import.
13008 typedef struct ImportCtx ImportCtx;
13010 const char *zFile; /* Name of the input file */
13011 FILE *in; /* Read the CSV text from this input stream */
13012 char *z; /* Accumulated text for a field */
13013 int n; /* Number of bytes in z */
13014 int nAlloc; /* Space allocated for z[] */
13015 int nLine; /* Current line number */
13016 int bNotFirst; /* True if one or more bytes already read */
13017 int cTerm; /* Character that terminated the most recent field */
13018 int cColSep; /* The column separator character. (Usually ",") */
13019 int cRowSep; /* The row separator character. (Usually "\n") */
13022 /* Append a single byte to z[] */
13023 static void import_append_char(ImportCtx *p, int c){
13024 if( p->n+1>=p->nAlloc ){
13025 p->nAlloc += p->nAlloc + 100;
13026 p->z = sqlite3_realloc64(p->z, p->nAlloc);
13027 if( p->z==0 ) shell_out_of_memory();
13029 p->z[p->n++] = (char)c;
13032 /* Read a single field of CSV text. Compatible with rfc4180 and extended
13033 ** with the option of having a separator other than ",".
13035 ** + Input comes from p->in.
13036 ** + Store results in p->z of length p->n. Space to hold p->z comes
13037 ** from sqlite3_malloc64().
13038 ** + Use p->cSep as the column separator. The default is ",".
13039 ** + Use p->rSep as the row separator. The default is "\n".
13040 ** + Keep track of the line number in p->nLine.
13041 ** + Store the character that terminates the field in p->cTerm. Store
13042 ** EOF on end-of-file.
13043 ** + Report syntax errors on stderr
13045 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
13047 int cSep = p->cColSep;
13048 int rSep = p->cRowSep;
13051 if( c==EOF || seenInterrupt ){
13057 int startLine = p->nLine;
13062 if( c==rSep ) p->nLine++;
13069 if( (c==cSep && pc==cQuote)
13070 || (c==rSep && pc==cQuote)
13071 || (c==rSep && pc=='\r' && ppc==cQuote)
13072 || (c==EOF && pc==cQuote)
13074 do{ p->n--; }while( p->z[p->n]!=cQuote );
13078 if( pc==cQuote && c!='\r' ){
13079 utf8_printf(stderr, "%s:%d: unescaped %c character\n",
13080 p->zFile, p->nLine, cQuote);
13083 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
13084 p->zFile, startLine, cQuote);
13088 import_append_char(p, c);
13093 /* If this is the first field being parsed and it begins with the
13094 ** UTF-8 BOM (0xEF BB BF) then skip the BOM */
13095 if( (c&0xff)==0xef && p->bNotFirst==0 ){
13096 import_append_char(p, c);
13098 if( (c&0xff)==0xbb ){
13099 import_append_char(p, c);
13101 if( (c&0xff)==0xbf ){
13104 return csv_read_one_field(p);
13108 while( c!=EOF && c!=cSep && c!=rSep ){
13109 import_append_char(p, c);
13114 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
13118 if( p->z ) p->z[p->n] = 0;
13123 /* Read a single field of ASCII delimited text.
13125 ** + Input comes from p->in.
13126 ** + Store results in p->z of length p->n. Space to hold p->z comes
13127 ** from sqlite3_malloc64().
13128 ** + Use p->cSep as the column separator. The default is "\x1F".
13129 ** + Use p->rSep as the row separator. The default is "\x1E".
13130 ** + Keep track of the row number in p->nLine.
13131 ** + Store the character that terminates the field in p->cTerm. Store
13132 ** EOF on end-of-file.
13133 ** + Report syntax errors on stderr
13135 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
13137 int cSep = p->cColSep;
13138 int rSep = p->cRowSep;
13141 if( c==EOF || seenInterrupt ){
13145 while( c!=EOF && c!=cSep && c!=rSep ){
13146 import_append_char(p, c);
13153 if( p->z ) p->z[p->n] = 0;
13158 ** Try to transfer data for table zTable. If an error is seen while
13159 ** moving forward, try to go backwards. The backwards movement won't
13160 ** work for WITHOUT ROWID tables.
13162 static void tryToCloneData(
13167 sqlite3_stmt *pQuery = 0;
13168 sqlite3_stmt *pInsert = 0;
13173 int nTable = strlen30(zTable);
13176 const int spinRate = 10000;
13178 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
13179 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13181 utf8_printf(stderr, "Error %d: %s on [%s]\n",
13182 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13184 goto end_data_xfer;
13186 n = sqlite3_column_count(pQuery);
13187 zInsert = sqlite3_malloc64(200 + nTable + n*3);
13188 if( zInsert==0 ) shell_out_of_memory();
13189 sqlite3_snprintf(200+nTable,zInsert,
13190 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
13191 i = strlen30(zInsert);
13192 for(j=1; j<n; j++){
13193 memcpy(zInsert+i, ",?", 2);
13196 memcpy(zInsert+i, ");", 3);
13197 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
13199 utf8_printf(stderr, "Error %d: %s on [%s]\n",
13200 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
13202 goto end_data_xfer;
13204 for(k=0; k<2; k++){
13205 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13206 for(i=0; i<n; i++){
13207 switch( sqlite3_column_type(pQuery, i) ){
13208 case SQLITE_NULL: {
13209 sqlite3_bind_null(pInsert, i+1);
13212 case SQLITE_INTEGER: {
13213 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
13216 case SQLITE_FLOAT: {
13217 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
13220 case SQLITE_TEXT: {
13221 sqlite3_bind_text(pInsert, i+1,
13222 (const char*)sqlite3_column_text(pQuery,i),
13223 -1, SQLITE_STATIC);
13226 case SQLITE_BLOB: {
13227 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
13228 sqlite3_column_bytes(pQuery,i),
13234 rc = sqlite3_step(pInsert);
13235 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
13236 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
13237 sqlite3_errmsg(newDb));
13239 sqlite3_reset(pInsert);
13241 if( (cnt%spinRate)==0 ){
13242 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
13246 if( rc==SQLITE_DONE ) break;
13247 sqlite3_finalize(pQuery);
13248 sqlite3_free(zQuery);
13249 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
13251 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13253 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
13256 } /* End for(k=0...) */
13259 sqlite3_finalize(pQuery);
13260 sqlite3_finalize(pInsert);
13261 sqlite3_free(zQuery);
13262 sqlite3_free(zInsert);
13267 ** Try to transfer all rows of the schema that match zWhere. For
13268 ** each row, invoke xForEach() on the object defined by that row.
13269 ** If an error is encountered while moving forward through the
13270 ** sqlite_master table, try again moving backwards.
13272 static void tryToCloneSchema(
13275 const char *zWhere,
13276 void (*xForEach)(ShellState*,sqlite3*,const char*)
13278 sqlite3_stmt *pQuery = 0;
13281 const unsigned char *zName;
13282 const unsigned char *zSql;
13285 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
13286 " WHERE %s", zWhere);
13287 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13289 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
13290 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13292 goto end_schema_xfer;
13294 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13295 zName = sqlite3_column_text(pQuery, 0);
13296 zSql = sqlite3_column_text(pQuery, 1);
13297 printf("%s... ", zName); fflush(stdout);
13298 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
13300 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
13301 sqlite3_free(zErrMsg);
13305 xForEach(p, newDb, (const char*)zName);
13309 if( rc!=SQLITE_DONE ){
13310 sqlite3_finalize(pQuery);
13311 sqlite3_free(zQuery);
13312 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
13313 " WHERE %s ORDER BY rowid DESC", zWhere);
13314 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13316 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
13317 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13319 goto end_schema_xfer;
13321 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13322 zName = sqlite3_column_text(pQuery, 0);
13323 zSql = sqlite3_column_text(pQuery, 1);
13324 printf("%s... ", zName); fflush(stdout);
13325 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
13327 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
13328 sqlite3_free(zErrMsg);
13332 xForEach(p, newDb, (const char*)zName);
13338 sqlite3_finalize(pQuery);
13339 sqlite3_free(zQuery);
13343 ** Open a new database file named "zNewDb". Try to recover as much information
13344 ** as possible out of the main database (which might be corrupt) and write it
13347 static void tryToClone(ShellState *p, const char *zNewDb){
13349 sqlite3 *newDb = 0;
13350 if( access(zNewDb,0)==0 ){
13351 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
13354 rc = sqlite3_open(zNewDb, &newDb);
13356 utf8_printf(stderr, "Cannot create output database: %s\n",
13357 sqlite3_errmsg(newDb));
13359 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
13360 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
13361 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
13362 tryToCloneSchema(p, newDb, "type!='table'", 0);
13363 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
13364 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
13370 ** Change the output file back to stdout.
13372 ** If the p->doXdgOpen flag is set, that means the output was being
13373 ** redirected to a temporary file named by p->zTempFile. In that case,
13374 ** launch start/open/xdg-open on that temporary file.
13376 static void output_reset(ShellState *p){
13377 if( p->outfile[0]=='|' ){
13378 #ifndef SQLITE_OMIT_POPEN
13382 output_file_close(p->out);
13383 #ifndef SQLITE_NOHAVE_SYSTEM
13384 if( p->doXdgOpen ){
13385 const char *zXdgOpenCmd =
13386 #if defined(_WIN32)
13388 #elif defined(__APPLE__)
13394 zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
13395 if( system(zCmd) ){
13396 utf8_printf(stderr, "Failed: [%s]\n", zCmd);
13398 sqlite3_free(zCmd);
13401 sqlite3_sleep(100);
13403 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
13410 ** Run an SQL command and return the single integer result.
13412 static int db_int(ShellState *p, const char *zSql){
13413 sqlite3_stmt *pStmt;
13415 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
13416 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
13417 res = sqlite3_column_int(pStmt,0);
13419 sqlite3_finalize(pStmt);
13424 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
13426 static unsigned int get2byteInt(unsigned char *a){
13427 return (a[0]<<8) + a[1];
13429 static unsigned int get4byteInt(unsigned char *a){
13430 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
13434 ** Implementation of the ".info" command.
13436 ** Return 1 on error, 2 to exit, and 0 otherwise.
13438 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
13439 static const struct { const char *zName; int ofst; } aField[] = {
13440 { "file change counter:", 24 },
13441 { "database page count:", 28 },
13442 { "freelist page count:", 36 },
13443 { "schema cookie:", 40 },
13444 { "schema format:", 44 },
13445 { "default cache size:", 48 },
13446 { "autovacuum top root:", 52 },
13447 { "incremental vacuum:", 64 },
13448 { "text encoding:", 56 },
13449 { "user version:", 60 },
13450 { "application id:", 68 },
13451 { "software version:", 96 },
13453 static const struct { const char *zName; const char *zSql; } aQuery[] = {
13454 { "number of tables:",
13455 "SELECT count(*) FROM %s WHERE type='table'" },
13456 { "number of indexes:",
13457 "SELECT count(*) FROM %s WHERE type='index'" },
13458 { "number of triggers:",
13459 "SELECT count(*) FROM %s WHERE type='trigger'" },
13460 { "number of views:",
13461 "SELECT count(*) FROM %s WHERE type='view'" },
13463 "SELECT total(length(sql)) FROM %s" },
13466 unsigned iDataVersion;
13468 char *zDb = nArg>=2 ? azArg[1] : "main";
13469 sqlite3_stmt *pStmt = 0;
13470 unsigned char aHdr[100];
13472 if( p->db==0 ) return 1;
13473 rc = sqlite3_prepare_v2(p->db,
13474 "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
13477 if( !sqlite3_compileoption_used("ENABLE_DBPAGE_VTAB") ){
13478 utf8_printf(stderr, "the \".dbinfo\" command requires the "
13479 "-DSQLITE_ENABLE_DBPAGE_VTAB compile-time options\n");
13481 utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db));
13483 sqlite3_finalize(pStmt);
13486 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
13487 if( sqlite3_step(pStmt)==SQLITE_ROW
13488 && sqlite3_column_bytes(pStmt,0)>100
13490 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100);
13491 sqlite3_finalize(pStmt);
13493 raw_printf(stderr, "unable to read database header\n");
13494 sqlite3_finalize(pStmt);
13497 i = get2byteInt(aHdr+16);
13498 if( i==1 ) i = 65536;
13499 utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
13500 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
13501 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
13502 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
13503 for(i=0; i<ArraySize(aField); i++){
13504 int ofst = aField[i].ofst;
13505 unsigned int val = get4byteInt(aHdr + ofst);
13506 utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
13509 if( val==1 ) raw_printf(p->out, " (utf8)");
13510 if( val==2 ) raw_printf(p->out, " (utf16le)");
13511 if( val==3 ) raw_printf(p->out, " (utf16be)");
13514 raw_printf(p->out, "\n");
13517 zSchemaTab = sqlite3_mprintf("main.sqlite_master");
13518 }else if( strcmp(zDb,"temp")==0 ){
13519 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
13521 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
13523 for(i=0; i<ArraySize(aQuery); i++){
13524 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
13525 int val = db_int(p, zSql);
13526 sqlite3_free(zSql);
13527 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
13529 sqlite3_free(zSchemaTab);
13530 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion);
13531 utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion);
13536 ** Print the current sqlite3_errmsg() value to stderr and return 1.
13538 static int shellDatabaseError(sqlite3 *db){
13539 const char *zErr = sqlite3_errmsg(db);
13540 utf8_printf(stderr, "Error: %s\n", zErr);
13545 ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
13546 ** if they match and FALSE (0) if they do not match.
13550 ** '*' Matches any sequence of zero or more characters.
13552 ** '?' Matches exactly one character.
13554 ** [...] Matches one character from the enclosed list of
13557 ** [^...] Matches one character not in the enclosed list.
13559 ** '#' Matches any sequence of one or more digits with an
13560 ** optional + or - sign in front
13562 ** ' ' Any span of whitespace matches any other span of
13565 ** Extra whitespace at the end of z[] is ignored.
13567 static int testcase_glob(const char *zGlob, const char *z){
13572 while( (c = (*(zGlob++)))!=0 ){
13574 if( !IsSpace(*z) ) return 0;
13575 while( IsSpace(*zGlob) ) zGlob++;
13576 while( IsSpace(*z) ) z++;
13577 }else if( c=='*' ){
13578 while( (c=(*(zGlob++))) == '*' || c=='?' ){
13579 if( c=='?' && (*(z++))==0 ) return 0;
13583 }else if( c=='[' ){
13584 while( *z && testcase_glob(zGlob-1,z)==0 ){
13589 while( (c2 = (*(z++)))!=0 ){
13592 if( c2==0 ) return 0;
13594 if( testcase_glob(zGlob,z) ) return 1;
13597 }else if( c=='?' ){
13598 if( (*(z++))==0 ) return 0;
13599 }else if( c=='[' ){
13604 if( c==0 ) return 0;
13611 if( c==']' ) seen = 1;
13614 while( c2 && c2!=']' ){
13615 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
13617 if( c>=prior_c && c<=c2 ) seen = 1;
13627 if( c2==0 || (seen ^ invert)==0 ) return 0;
13628 }else if( c=='#' ){
13629 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++;
13630 if( !IsDigit(z[0]) ) return 0;
13632 while( IsDigit(z[0]) ){ z++; }
13634 if( c!=(*(z++)) ) return 0;
13637 while( IsSpace(*z) ){ z++; }
13643 ** Compare the string as a command-line option with either one or two
13644 ** initial "-" characters.
13646 static int optionMatch(const char *zStr, const char *zOpt){
13647 if( zStr[0]!='-' ) return 0;
13649 if( zStr[0]=='-' ) zStr++;
13650 return strcmp(zStr, zOpt)==0;
13656 int shellDeleteFile(const char *zFilename){
13659 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename);
13663 rc = unlink(zFilename);
13669 ** Try to delete the temporary file (if there is one) and free the
13670 ** memory used to hold the name of the temp file.
13672 static void clearTempFile(ShellState *p){
13673 if( p->zTempFile==0 ) return;
13674 if( p->doXdgOpen ) return;
13675 if( shellDeleteFile(p->zTempFile) ) return;
13676 sqlite3_free(p->zTempFile);
13681 ** Create a new temp file name with the given suffix.
13683 static void newTempFile(ShellState *p, const char *zSuffix){
13685 sqlite3_free(p->zTempFile);
13688 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile);
13690 if( p->zTempFile==0 ){
13692 sqlite3_randomness(sizeof(r), &r);
13693 p->zTempFile = sqlite3_mprintf("temp%llx.%s", r, zSuffix);
13695 p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix);
13697 if( p->zTempFile==0 ){
13698 raw_printf(stderr, "out of memory\n");
13705 ** The implementation of SQL scalar function fkey_collate_clause(), used
13706 ** by the ".lint fkey-indexes" command. This scalar function is always
13707 ** called with four arguments - the parent table name, the parent column name,
13708 ** the child table name and the child column name.
13710 ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col')
13712 ** If either of the named tables or columns do not exist, this function
13713 ** returns an empty string. An empty string is also returned if both tables
13714 ** and columns exist but have the same default collation sequence. Or,
13715 ** if both exist but the default collation sequences are different, this
13716 ** function returns the string " COLLATE <parent-collation>", where
13717 ** <parent-collation> is the default collation sequence of the parent column.
13719 static void shellFkeyCollateClause(
13720 sqlite3_context *pCtx,
13722 sqlite3_value **apVal
13724 sqlite3 *db = sqlite3_context_db_handle(pCtx);
13725 const char *zParent;
13726 const char *zParentCol;
13727 const char *zParentSeq;
13728 const char *zChild;
13729 const char *zChildCol;
13730 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */
13734 zParent = (const char*)sqlite3_value_text(apVal[0]);
13735 zParentCol = (const char*)sqlite3_value_text(apVal[1]);
13736 zChild = (const char*)sqlite3_value_text(apVal[2]);
13737 zChildCol = (const char*)sqlite3_value_text(apVal[3]);
13739 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
13740 rc = sqlite3_table_column_metadata(
13741 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0
13743 if( rc==SQLITE_OK ){
13744 rc = sqlite3_table_column_metadata(
13745 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0
13749 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){
13750 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
13751 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
13758 ** The implementation of dot-command ".lint fkey-indexes".
13760 static int lintFkeyIndexes(
13761 ShellState *pState, /* Current shell tool state */
13762 char **azArg, /* Array of arguments passed to dot command */
13763 int nArg /* Number of entries in azArg[] */
13765 sqlite3 *db = pState->db; /* Database handle to query "main" db of */
13766 FILE *out = pState->out; /* Stream to write non-error output to */
13767 int bVerbose = 0; /* If -verbose is present */
13768 int bGroupByParent = 0; /* If -groupbyparent is present */
13769 int i; /* To iterate through azArg[] */
13770 const char *zIndent = ""; /* How much to indent CREATE INDEX by */
13771 int rc; /* Return code */
13772 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */
13775 ** This SELECT statement returns one row for each foreign key constraint
13776 ** in the schema of the main database. The column values are:
13778 ** 0. The text of an SQL statement similar to:
13780 ** "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?"
13782 ** This SELECT is similar to the one that the foreign keys implementation
13783 ** needs to run internally on child tables. If there is an index that can
13784 ** be used to optimize this query, then it can also be used by the FK
13785 ** implementation to optimize DELETE or UPDATE statements on the parent
13788 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
13789 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema
13790 ** contains an index that can be used to optimize the query.
13792 ** 2. Human readable text that describes the child table and columns. e.g.
13794 ** "child_table(child_key1, child_key2)"
13796 ** 3. Human readable text that describes the parent table and columns. e.g.
13798 ** "parent_table(parent_key1, parent_key2)"
13800 ** 4. A full CREATE INDEX statement for an index that could be used to
13801 ** optimize DELETE or UPDATE statements on the parent table. e.g.
13803 ** "CREATE INDEX child_table_child_key ON child_table(child_key)"
13805 ** 5. The name of the parent table.
13807 ** These six values are used by the C logic below to generate the report.
13811 " 'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '"
13812 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
13813 " || fkey_collate_clause("
13814 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
13816 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('"
13817 " || group_concat('*=?', ' AND ') || ')'"
13819 " s.name || '(' || group_concat(f.[from], ', ') || ')'"
13821 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
13823 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
13824 " || ' ON ' || quote(s.name) || '('"
13825 " || group_concat(quote(f.[from]) ||"
13826 " fkey_collate_clause("
13827 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
13831 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f "
13832 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
13833 "GROUP BY s.name, f.id "
13834 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
13836 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)";
13838 for(i=2; i<nArg; i++){
13839 int n = strlen30(azArg[i]);
13840 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){
13843 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
13844 bGroupByParent = 1;
13848 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
13851 return SQLITE_ERROR;
13855 /* Register the fkey_collate_clause() SQL function */
13856 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8,
13857 0, shellFkeyCollateClause, 0, 0
13861 if( rc==SQLITE_OK ){
13862 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
13864 if( rc==SQLITE_OK ){
13865 sqlite3_bind_int(pSql, 1, bGroupByParent);
13868 if( rc==SQLITE_OK ){
13871 while( SQLITE_ROW==sqlite3_step(pSql) ){
13873 sqlite3_stmt *pExplain = 0;
13874 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
13875 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
13876 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
13877 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
13878 const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
13879 const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
13881 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
13882 if( rc!=SQLITE_OK ) break;
13883 if( SQLITE_ROW==sqlite3_step(pExplain) ){
13884 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
13886 0==sqlite3_strglob(zGlob, zPlan)
13887 || 0==sqlite3_strglob(zGlobIPK, zPlan)
13890 rc = sqlite3_finalize(pExplain);
13891 if( rc!=SQLITE_OK ) break;
13894 raw_printf(stderr, "Error: internal error");
13898 && (bVerbose || res==0)
13899 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev))
13901 raw_printf(out, "-- Parent table %s\n", zParent);
13902 sqlite3_free(zPrev);
13903 zPrev = sqlite3_mprintf("%s", zParent);
13907 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
13908 }else if( bVerbose ){
13909 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n",
13910 zIndent, zFrom, zTarget
13915 sqlite3_free(zPrev);
13917 if( rc!=SQLITE_OK ){
13918 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13921 rc2 = sqlite3_finalize(pSql);
13922 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
13924 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13927 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13934 ** Implementation of ".lint" dot command.
13936 static int lintDotCommand(
13937 ShellState *pState, /* Current shell tool state */
13938 char **azArg, /* Array of arguments passed to dot command */
13939 int nArg /* Number of entries in azArg[] */
13942 n = (nArg>=2 ? strlen30(azArg[1]) : 0);
13943 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
13944 return lintFkeyIndexes(pState, azArg, nArg);
13947 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]);
13948 raw_printf(stderr, "Where sub-commands are:\n");
13949 raw_printf(stderr, " fkey-indexes\n");
13950 return SQLITE_ERROR;
13953 #if !defined SQLITE_OMIT_VIRTUALTABLE
13954 static void shellPrepare(
13958 sqlite3_stmt **ppStmt
13961 if( *pRc==SQLITE_OK ){
13962 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
13963 if( rc!=SQLITE_OK ){
13964 raw_printf(stderr, "sql error: %s (%d)\n",
13965 sqlite3_errmsg(db), sqlite3_errcode(db)
13973 ** Create a prepared statement using printf-style arguments for the SQL.
13975 ** This routine is could be marked "static". But it is not always used,
13976 ** depending on compile-time options. By omitting the "static", we avoid
13977 ** nuisance compiler warnings about "defined but not used".
13979 void shellPreparePrintf(
13982 sqlite3_stmt **ppStmt,
13987 if( *pRc==SQLITE_OK ){
13990 va_start(ap, zFmt);
13991 z = sqlite3_vmprintf(zFmt, ap);
13994 *pRc = SQLITE_NOMEM;
13996 shellPrepare(db, pRc, z, ppStmt);
14002 /* Finalize the prepared statement created using shellPreparePrintf().
14004 ** This routine is could be marked "static". But it is not always used,
14005 ** depending on compile-time options. By omitting the "static", we avoid
14006 ** nuisance compiler warnings about "defined but not used".
14008 void shellFinalize(
14010 sqlite3_stmt *pStmt
14013 sqlite3 *db = sqlite3_db_handle(pStmt);
14014 int rc = sqlite3_finalize(pStmt);
14015 if( *pRc==SQLITE_OK ){
14016 if( rc!=SQLITE_OK ){
14017 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
14024 /* Reset the prepared statement created using shellPreparePrintf().
14026 ** This routine is could be marked "static". But it is not always used,
14027 ** depending on compile-time options. By omitting the "static", we avoid
14028 ** nuisance compiler warnings about "defined but not used".
14032 sqlite3_stmt *pStmt
14034 int rc = sqlite3_reset(pStmt);
14035 if( *pRc==SQLITE_OK ){
14036 if( rc!=SQLITE_OK ){
14037 sqlite3 *db = sqlite3_db_handle(pStmt);
14038 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
14043 #endif /* !defined SQLITE_OMIT_VIRTUALTABLE */
14045 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
14046 /*********************************************************************************
14047 ** The ".archive" or ".ar" command.
14050 ** Structure representing a single ".ar" command.
14052 typedef struct ArCommand ArCommand;
14054 u8 eCmd; /* An AR_CMD_* value */
14055 u8 bVerbose; /* True if --verbose */
14056 u8 bZip; /* True if the archive is a ZIP */
14057 u8 bDryRun; /* True if --dry-run */
14058 u8 bAppend; /* True if --append */
14059 u8 fromCmdLine; /* Run from -A instead of .archive */
14060 int nArg; /* Number of command arguments */
14061 char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */
14062 const char *zFile; /* --file argument, or NULL */
14063 const char *zDir; /* --directory argument, or NULL */
14064 char **azArg; /* Array of command arguments */
14065 ShellState *p; /* Shell state */
14066 sqlite3 *db; /* Database containing the archive */
14070 ** Print a usage message for the .ar command to stderr and return SQLITE_ERROR.
14072 static int arUsage(FILE *f){
14073 showHelp(f,"archive");
14074 return SQLITE_ERROR;
14078 ** Print an error message for the .ar command to stderr and return
14081 static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){
14084 va_start(ap, zFmt);
14085 z = sqlite3_vmprintf(zFmt, ap);
14087 utf8_printf(stderr, "Error: %s\n", z);
14088 if( pAr->fromCmdLine ){
14089 utf8_printf(stderr, "Use \"-A\" for more help\n");
14091 utf8_printf(stderr, "Use \".archive --help\" for more help\n");
14094 return SQLITE_ERROR;
14098 ** Values for ArCommand.eCmd.
14100 #define AR_CMD_CREATE 1
14101 #define AR_CMD_UPDATE 2
14102 #define AR_CMD_INSERT 3
14103 #define AR_CMD_EXTRACT 4
14104 #define AR_CMD_LIST 5
14105 #define AR_CMD_HELP 6
14108 ** Other (non-command) switches.
14110 #define AR_SWITCH_VERBOSE 7
14111 #define AR_SWITCH_FILE 8
14112 #define AR_SWITCH_DIRECTORY 9
14113 #define AR_SWITCH_APPEND 10
14114 #define AR_SWITCH_DRYRUN 11
14116 static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){
14118 case AR_CMD_CREATE:
14119 case AR_CMD_EXTRACT:
14121 case AR_CMD_UPDATE:
14122 case AR_CMD_INSERT:
14125 return arErrorMsg(pAr, "multiple command options");
14127 pAr->eCmd = eSwitch;
14130 case AR_SWITCH_DRYRUN:
14133 case AR_SWITCH_VERBOSE:
14136 case AR_SWITCH_APPEND:
14138 /* Fall thru into --file */
14139 case AR_SWITCH_FILE:
14142 case AR_SWITCH_DIRECTORY:
14151 ** Parse the command line for an ".ar" command. The results are written into
14152 ** structure (*pAr). SQLITE_OK is returned if the command line is parsed
14153 ** successfully, otherwise an error message is written to stderr and
14154 ** SQLITE_ERROR returned.
14156 static int arParseCommand(
14157 char **azArg, /* Array of arguments passed to dot command */
14158 int nArg, /* Number of entries in azArg[] */
14159 ArCommand *pAr /* Populate this object */
14167 { "create", 'c', AR_CMD_CREATE, 0 },
14168 { "extract", 'x', AR_CMD_EXTRACT, 0 },
14169 { "insert", 'i', AR_CMD_INSERT, 0 },
14170 { "list", 't', AR_CMD_LIST, 0 },
14171 { "update", 'u', AR_CMD_UPDATE, 0 },
14172 { "help", 'h', AR_CMD_HELP, 0 },
14173 { "verbose", 'v', AR_SWITCH_VERBOSE, 0 },
14174 { "file", 'f', AR_SWITCH_FILE, 1 },
14175 { "append", 'a', AR_SWITCH_APPEND, 1 },
14176 { "directory", 'C', AR_SWITCH_DIRECTORY, 1 },
14177 { "dryrun", 'n', AR_SWITCH_DRYRUN, 0 },
14179 int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch);
14180 struct ArSwitch *pEnd = &aSwitch[nSwitch];
14183 utf8_printf(stderr, "Wrong number of arguments. Usage:\n");
14184 return arUsage(stderr);
14186 char *z = azArg[1];
14188 /* Traditional style [tar] invocation */
14191 for(i=0; z[i]; i++){
14192 const char *zArg = 0;
14193 struct ArSwitch *pOpt;
14194 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14195 if( z[i]==pOpt->cShort ) break;
14198 return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
14202 return arErrorMsg(pAr, "option requires an argument: %c",z[i]);
14204 zArg = azArg[iArg++];
14206 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
14208 pAr->nArg = nArg-iArg;
14210 pAr->azArg = &azArg[iArg];
14213 /* Non-traditional invocation */
14215 for(iArg=1; iArg<nArg; iArg++){
14219 /* All remaining command line words are command arguments. */
14220 pAr->azArg = &azArg[iArg];
14221 pAr->nArg = nArg-iArg;
14228 /* One or more short options */
14229 for(i=1; i<n; i++){
14230 const char *zArg = 0;
14231 struct ArSwitch *pOpt;
14232 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14233 if( z[i]==pOpt->cShort ) break;
14236 return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
14243 if( iArg>=(nArg-1) ){
14244 return arErrorMsg(pAr, "option requires an argument: %c",z[i]);
14246 zArg = azArg[++iArg];
14249 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
14251 }else if( z[2]=='\0' ){
14252 /* A -- option, indicating that all remaining command line words
14253 ** are command arguments. */
14254 pAr->azArg = &azArg[iArg+1];
14255 pAr->nArg = nArg-iArg-1;
14258 /* A long option */
14259 const char *zArg = 0; /* Argument for option, if any */
14260 struct ArSwitch *pMatch = 0; /* Matching option */
14261 struct ArSwitch *pOpt; /* Iterator */
14262 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14263 const char *zLong = pOpt->zLong;
14264 if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){
14266 return arErrorMsg(pAr, "ambiguous option: %s",z);
14274 return arErrorMsg(pAr, "unrecognized option: %s", z);
14276 if( pMatch->bArg ){
14277 if( iArg>=(nArg-1) ){
14278 return arErrorMsg(pAr, "option requires an argument: %s", z);
14280 zArg = azArg[++iArg];
14282 if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR;
14292 ** This function assumes that all arguments within the ArCommand.azArg[]
14293 ** array refer to archive members, as for the --extract or --list commands.
14294 ** It checks that each of them are present. If any specified file is not
14295 ** present in the archive, an error is printed to stderr and an error
14296 ** code returned. Otherwise, if all specified arguments are present in
14297 ** the archive, SQLITE_OK is returned.
14299 ** This function strips any trailing '/' characters from each argument.
14300 ** This is consistent with the way the [tar] command seems to work on
14303 static int arCheckEntries(ArCommand *pAr){
14304 int rc = SQLITE_OK;
14307 sqlite3_stmt *pTest = 0;
14309 shellPreparePrintf(pAr->db, &rc, &pTest,
14310 "SELECT name FROM %s WHERE name=$name",
14313 j = sqlite3_bind_parameter_index(pTest, "$name");
14314 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){
14315 char *z = pAr->azArg[i];
14316 int n = strlen30(z);
14318 while( n>0 && z[n-1]=='/' ) n--;
14320 sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC);
14321 if( SQLITE_ROW==sqlite3_step(pTest) ){
14324 shellReset(&rc, pTest);
14325 if( rc==SQLITE_OK && bOk==0 ){
14326 utf8_printf(stderr, "not found in archive: %s\n", z);
14330 shellFinalize(&rc, pTest);
14336 ** Format a WHERE clause that can be used against the "sqlar" table to
14337 ** identify all archive members that match the command arguments held
14338 ** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning.
14339 ** The caller is responsible for eventually calling sqlite3_free() on
14340 ** any non-NULL (*pzWhere) value.
14342 static void arWhereClause(
14345 char **pzWhere /* OUT: New WHERE clause */
14348 if( *pRc==SQLITE_OK ){
14349 if( pAr->nArg==0 ){
14350 zWhere = sqlite3_mprintf("1");
14353 const char *zSep = "";
14354 for(i=0; i<pAr->nArg; i++){
14355 const char *z = pAr->azArg[i];
14356 zWhere = sqlite3_mprintf(
14357 "%z%s name = '%q' OR substr(name,1,%d) = '%q/'",
14358 zWhere, zSep, z, strlen30(z)+1, z
14361 *pRc = SQLITE_NOMEM;
14372 ** Implementation of .ar "lisT" command.
14374 static int arListCommand(ArCommand *pAr){
14375 const char *zSql = "SELECT %s FROM %s WHERE %s";
14376 const char *azCols[] = {
14378 "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name"
14382 sqlite3_stmt *pSql = 0;
14385 rc = arCheckEntries(pAr);
14386 arWhereClause(&rc, pAr, &zWhere);
14388 shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose],
14389 pAr->zSrcTable, zWhere);
14390 if( pAr->bDryRun ){
14391 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
14393 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
14394 if( pAr->bVerbose ){
14395 utf8_printf(pAr->p->out, "%s % 10d %s %s\n",
14396 sqlite3_column_text(pSql, 0),
14397 sqlite3_column_int(pSql, 1),
14398 sqlite3_column_text(pSql, 2),
14399 sqlite3_column_text(pSql, 3)
14402 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
14406 shellFinalize(&rc, pSql);
14407 sqlite3_free(zWhere);
14413 ** Implementation of .ar "eXtract" command.
14415 static int arExtractCommand(ArCommand *pAr){
14416 const char *zSql1 =
14419 " writefile(($dir || name), %s, mode, mtime) "
14420 "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)"
14421 " AND name NOT GLOB '*..[/\\]*'";
14423 const char *azExtraArg[] = {
14424 "sqlar_uncompress(data, sz)",
14428 sqlite3_stmt *pSql = 0;
14429 int rc = SQLITE_OK;
14434 /* If arguments are specified, check that they actually exist within
14435 ** the archive before proceeding. And formulate a WHERE clause to
14437 rc = arCheckEntries(pAr);
14438 arWhereClause(&rc, pAr, &zWhere);
14440 if( rc==SQLITE_OK ){
14442 zDir = sqlite3_mprintf("%s/", pAr->zDir);
14444 zDir = sqlite3_mprintf("");
14446 if( zDir==0 ) rc = SQLITE_NOMEM;
14449 shellPreparePrintf(pAr->db, &rc, &pSql, zSql1,
14450 azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere
14453 if( rc==SQLITE_OK ){
14454 j = sqlite3_bind_parameter_index(pSql, "$dir");
14455 sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC);
14457 /* Run the SELECT statement twice. The first time, writefile() is called
14458 ** for all archive members that should be extracted. The second time,
14459 ** only for the directories. This is because the timestamps for
14460 ** extracted directories must be reset after they are populated (as
14461 ** populating them changes the timestamp). */
14462 for(i=0; i<2; i++){
14463 j = sqlite3_bind_parameter_index(pSql, "$dirOnly");
14464 sqlite3_bind_int(pSql, j, i);
14465 if( pAr->bDryRun ){
14466 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
14468 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
14469 if( i==0 && pAr->bVerbose ){
14470 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
14474 shellReset(&rc, pSql);
14476 shellFinalize(&rc, pSql);
14479 sqlite3_free(zDir);
14480 sqlite3_free(zWhere);
14485 ** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out.
14487 static int arExecSql(ArCommand *pAr, const char *zSql){
14489 if( pAr->bDryRun ){
14490 utf8_printf(pAr->p->out, "%s\n", zSql);
14494 rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
14496 utf8_printf(stdout, "ERROR: %s\n", zErr);
14497 sqlite3_free(zErr);
14505 ** Implementation of .ar "create", "insert", and "update" commands.
14507 ** create -> Create a new SQL archive
14508 ** insert -> Insert or reinsert all files listed
14509 ** update -> Insert files that have changed or that were not
14510 ** previously in the archive
14512 ** Create the "sqlar" table in the database if it does not already exist.
14513 ** Then add each file in the azFile[] array to the archive. Directories
14514 ** are added recursively. If argument bVerbose is non-zero, a message is
14515 ** printed on stdout for each file archived.
14517 ** The create command is the same as update, except that it drops
14518 ** any existing "sqlar" table before beginning. The "insert" command
14519 ** always overwrites every file named on the command-line, where as
14520 ** "update" only overwrites if the size or mtime or mode has changed.
14522 static int arCreateOrUpdateCommand(
14523 ArCommand *pAr, /* Command arguments and options */
14524 int bUpdate, /* true for a --create. */
14525 int bOnlyIfChanged /* Only update if file has changed */
14527 const char *zCreate =
14528 "CREATE TABLE IF NOT EXISTS sqlar(\n"
14529 " name TEXT PRIMARY KEY, -- name of the file\n"
14530 " mode INT, -- access permissions\n"
14531 " mtime INT, -- last modification time\n"
14532 " sz INT, -- original file size\n"
14533 " data BLOB -- compressed content\n"
14535 const char *zDrop = "DROP TABLE IF EXISTS sqlar";
14536 const char *zInsertFmt[2] = {
14537 "REPLACE INTO %s(name,mode,mtime,sz,data)\n"
14542 " CASE substr(lsmode(mode),1,1)\n"
14543 " WHEN '-' THEN length(data)\n"
14544 " WHEN 'd' THEN 0\n"
14546 " sqlar_compress(data)\n"
14547 " FROM fsdir(%Q,%Q) AS disk\n"
14548 " WHERE lsmode(mode) NOT LIKE '?%%'%s;"
14550 "REPLACE INTO %s(name,mode,mtime,data)\n"
14556 " FROM fsdir(%Q,%Q) AS disk\n"
14557 " WHERE lsmode(mode) NOT LIKE '?%%'%s;"
14559 int i; /* For iterating through azFile[] */
14560 int rc; /* Return code */
14561 const char *zTab = 0; /* SQL table into which to insert */
14566 arExecSql(pAr, "PRAGMA page_size=512");
14567 rc = arExecSql(pAr, "SAVEPOINT ar;");
14568 if( rc!=SQLITE_OK ) return rc;
14571 /* Initialize the zipfile virtual table, if necessary */
14574 sqlite3_randomness(sizeof(r),&r);
14575 sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r);
14577 zSql = sqlite3_mprintf(
14578 "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)",
14581 rc = arExecSql(pAr, zSql);
14582 sqlite3_free(zSql);
14587 /* Initialize the table for an SQLAR */
14590 rc = arExecSql(pAr, zDrop);
14591 if( rc!=SQLITE_OK ) goto end_ar_transaction;
14593 rc = arExecSql(pAr, zCreate);
14595 if( bOnlyIfChanged ){
14596 zExists = sqlite3_mprintf(
14598 "SELECT 1 FROM %s AS mem"
14599 " WHERE mem.name=disk.name"
14600 " AND mem.mtime=disk.mtime"
14601 " AND mem.mode=disk.mode)", zTab);
14603 zExists = sqlite3_mprintf("");
14605 if( zExists==0 ) rc = SQLITE_NOMEM;
14606 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){
14607 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab,
14608 pAr->bVerbose ? "shell_putsnl(name)" : "name",
14609 pAr->azArg[i], pAr->zDir, zExists);
14610 rc = arExecSql(pAr, zSql2);
14611 sqlite3_free(zSql2);
14613 end_ar_transaction:
14614 if( rc!=SQLITE_OK ){
14615 sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0);
14617 rc = arExecSql(pAr, "RELEASE ar;");
14618 if( pAr->bZip && pAr->zFile ){
14619 zSql = sqlite3_mprintf("DROP TABLE %s", zTemp);
14620 arExecSql(pAr, zSql);
14621 sqlite3_free(zSql);
14624 sqlite3_free(zExists);
14629 ** Implementation of ".ar" dot command.
14631 static int arDotCommand(
14632 ShellState *pState, /* Current shell tool state */
14633 int fromCmdLine, /* True if -A command-line option, not .ar cmd */
14634 char **azArg, /* Array of arguments passed to dot command */
14635 int nArg /* Number of entries in azArg[] */
14639 memset(&cmd, 0, sizeof(cmd));
14640 cmd.fromCmdLine = fromCmdLine;
14641 rc = arParseCommand(azArg, nArg, &cmd);
14642 if( rc==SQLITE_OK ){
14643 int eDbType = SHELL_OPEN_UNSPEC;
14645 cmd.db = pState->db;
14647 eDbType = deduceDatabaseType(cmd.zFile, 1);
14649 eDbType = pState->openMode;
14651 if( eDbType==SHELL_OPEN_ZIPFILE ){
14652 if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){
14653 if( cmd.zFile==0 ){
14654 cmd.zSrcTable = sqlite3_mprintf("zip");
14656 cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile);
14660 }else if( cmd.zFile ){
14662 if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS;
14663 if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT
14664 || cmd.eCmd==AR_CMD_UPDATE ){
14665 flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
14667 flags = SQLITE_OPEN_READONLY;
14671 utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile,
14672 eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
14674 rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags,
14675 eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0);
14676 if( rc!=SQLITE_OK ){
14677 utf8_printf(stderr, "cannot open file: %s (%s)\n",
14678 cmd.zFile, sqlite3_errmsg(cmd.db)
14680 goto end_ar_command;
14682 sqlite3_fileio_init(cmd.db, 0, 0);
14683 sqlite3_sqlar_init(cmd.db, 0, 0);
14684 sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p,
14685 shellPutsFunc, 0, 0);
14688 if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){
14689 if( cmd.eCmd!=AR_CMD_CREATE
14690 && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0)
14692 utf8_printf(stderr, "database does not contain an 'sqlar' table\n");
14694 goto end_ar_command;
14696 cmd.zSrcTable = sqlite3_mprintf("sqlar");
14699 switch( cmd.eCmd ){
14700 case AR_CMD_CREATE:
14701 rc = arCreateOrUpdateCommand(&cmd, 0, 0);
14704 case AR_CMD_EXTRACT:
14705 rc = arExtractCommand(&cmd);
14709 rc = arListCommand(&cmd);
14713 arUsage(pState->out);
14716 case AR_CMD_INSERT:
14717 rc = arCreateOrUpdateCommand(&cmd, 1, 0);
14721 assert( cmd.eCmd==AR_CMD_UPDATE );
14722 rc = arCreateOrUpdateCommand(&cmd, 1, 1);
14727 if( cmd.db!=pState->db ){
14730 sqlite3_free(cmd.zSrcTable);
14734 /* End of the ".archive" or ".ar" command logic
14735 **********************************************************************************/
14736 #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */
14738 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
14740 ** If (*pRc) is not SQLITE_OK when this function is called, it is a no-op.
14741 ** Otherwise, the SQL statement or statements in zSql are executed using
14742 ** database connection db and the error code written to *pRc before
14743 ** this function returns.
14745 static void shellExec(sqlite3 *db, int *pRc, const char *zSql){
14747 if( rc==SQLITE_OK ){
14749 rc = sqlite3_exec(db, zSql, 0, 0, &zErr);
14750 if( rc!=SQLITE_OK ){
14751 raw_printf(stderr, "SQL error: %s\n", zErr);
14758 ** Like shellExec(), except that zFmt is a printf() style format string.
14760 static void shellExecPrintf(sqlite3 *db, int *pRc, const char *zFmt, ...){
14762 if( *pRc==SQLITE_OK ){
14764 va_start(ap, zFmt);
14765 z = sqlite3_vmprintf(zFmt, ap);
14768 *pRc = SQLITE_NOMEM;
14770 shellExec(db, pRc, z);
14777 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
14778 ** Otherwise, an attempt is made to allocate, zero and return a pointer
14779 ** to a buffer nByte bytes in size. If an OOM error occurs, *pRc is set
14780 ** to SQLITE_NOMEM and NULL returned.
14782 static void *shellMalloc(int *pRc, sqlite3_int64 nByte){
14784 if( *pRc==SQLITE_OK ){
14785 pRet = sqlite3_malloc64(nByte);
14787 *pRc = SQLITE_NOMEM;
14789 memset(pRet, 0, nByte);
14796 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
14797 ** Otherwise, zFmt is treated as a printf() style string. The result of
14798 ** formatting it along with any trailing arguments is written into a
14799 ** buffer obtained from sqlite3_malloc(), and pointer to which is returned.
14800 ** It is the responsibility of the caller to eventually free this buffer
14801 ** using a call to sqlite3_free().
14803 ** If an OOM error occurs, (*pRc) is set to SQLITE_NOMEM and a NULL
14804 ** pointer returned.
14806 static char *shellMPrintf(int *pRc, const char *zFmt, ...){
14808 if( *pRc==SQLITE_OK ){
14810 va_start(ap, zFmt);
14811 z = sqlite3_vmprintf(zFmt, ap);
14814 *pRc = SQLITE_NOMEM;
14821 ** When running the ".recover" command, each output table, and the special
14822 ** orphaned row table if it is required, is represented by an instance
14823 ** of the following struct.
14825 typedef struct RecoverTable RecoverTable;
14826 struct RecoverTable {
14827 char *zQuoted; /* Quoted version of table name */
14828 int nCol; /* Number of columns in table */
14829 char **azlCol; /* Array of column lists */
14830 int iPk; /* Index of IPK column */
14834 ** Free a RecoverTable object allocated by recoverFindTable() or
14835 ** recoverOrphanTable().
14837 static void recoverFreeTable(RecoverTable *pTab){
14839 sqlite3_free(pTab->zQuoted);
14840 if( pTab->azlCol ){
14842 for(i=0; i<=pTab->nCol; i++){
14843 sqlite3_free(pTab->azlCol[i]);
14845 sqlite3_free(pTab->azlCol);
14847 sqlite3_free(pTab);
14852 ** This function is a no-op if (*pRc) is not SQLITE_OK when it is called.
14853 ** Otherwise, it allocates and returns a RecoverTable object based on the
14854 ** final four arguments passed to this function. It is the responsibility
14855 ** of the caller to eventually free the returned object using
14856 ** recoverFreeTable().
14858 static RecoverTable *recoverNewTable(
14859 int *pRc, /* IN/OUT: Error code */
14860 const char *zName, /* Name of table */
14861 const char *zSql, /* CREATE TABLE statement */
14865 sqlite3 *dbtmp = 0; /* sqlite3 handle for testing CREATE TABLE */
14867 RecoverTable *pTab = 0;
14869 pTab = (RecoverTable*)shellMalloc(&rc, sizeof(RecoverTable));
14870 if( rc==SQLITE_OK ){
14872 int bSqlIntkey = 0;
14873 sqlite3_stmt *pStmt = 0;
14875 rc = sqlite3_open("", &dbtmp);
14876 if( rc==SQLITE_OK ){
14877 rc = sqlite3_exec(dbtmp, "PRAGMA writable_schema = on", 0, 0, 0);
14879 if( rc==SQLITE_OK ){
14880 rc = sqlite3_exec(dbtmp, zSql, 0, 0, 0);
14881 if( rc==SQLITE_ERROR ){
14886 shellPreparePrintf(dbtmp, &rc, &pStmt,
14887 "SELECT count(*) FROM pragma_table_info(%Q)", zName
14889 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14890 nSqlCol = sqlite3_column_int(pStmt, 0);
14892 shellFinalize(&rc, pStmt);
14894 if( rc!=SQLITE_OK || nSqlCol<nCol ){
14898 shellPreparePrintf(dbtmp, &rc, &pStmt,
14900 " SELECT substr(data,1,1)==X'0D' FROM sqlite_dbpage WHERE pgno=rootpage"
14901 ") FROM sqlite_master WHERE name = %Q", zName
14903 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14904 bSqlIntkey = sqlite3_column_int(pStmt, 0);
14906 shellFinalize(&rc, pStmt);
14908 if( bIntkey==bSqlIntkey ){
14910 const char *zPk = "_rowid_";
14911 sqlite3_stmt *pPkFinder = 0;
14913 /* If this is an intkey table and there is an INTEGER PRIMARY KEY,
14914 ** set zPk to the name of the PK column, and pTab->iPk to the index
14915 ** of the column, where columns are 0-numbered from left to right.
14916 ** Or, if this is a WITHOUT ROWID table or if there is no IPK column,
14917 ** leave zPk as "_rowid_" and pTab->iPk at -2. */
14920 shellPreparePrintf(dbtmp, &rc, &pPkFinder,
14921 "SELECT cid, name FROM pragma_table_info(%Q) "
14922 " WHERE pk=1 AND type='integer' COLLATE nocase"
14923 " AND NOT EXISTS (SELECT cid FROM pragma_table_info(%Q) WHERE pk=2)"
14926 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPkFinder) ){
14927 pTab->iPk = sqlite3_column_int(pPkFinder, 0);
14928 zPk = (const char*)sqlite3_column_text(pPkFinder, 1);
14932 pTab->zQuoted = shellMPrintf(&rc, "%Q", zName);
14933 pTab->azlCol = (char**)shellMalloc(&rc, sizeof(char*) * (nSqlCol+1));
14934 pTab->nCol = nSqlCol;
14937 pTab->azlCol[0] = shellMPrintf(&rc, "%Q", zPk);
14939 pTab->azlCol[0] = shellMPrintf(&rc, "");
14942 shellPreparePrintf(dbtmp, &rc, &pStmt,
14943 "SELECT %Q || group_concat(name, ', ') "
14944 " FILTER (WHERE cid!=%d) OVER (ORDER BY %s cid) "
14945 "FROM pragma_table_info(%Q)",
14946 bIntkey ? ", " : "", pTab->iPk,
14947 bIntkey ? "" : "(CASE WHEN pk=0 THEN 1000000 ELSE pk END), ",
14950 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14951 const char *zText = (const char*)sqlite3_column_text(pStmt, 0);
14952 pTab->azlCol[i] = shellMPrintf(&rc, "%s%s", pTab->azlCol[0], zText);
14955 shellFinalize(&rc, pStmt);
14957 shellFinalize(&rc, pPkFinder);
14962 sqlite3_close(dbtmp);
14964 if( rc!=SQLITE_OK || (pTab && pTab->zQuoted==0) ){
14965 recoverFreeTable(pTab);
14972 ** This function is called to search the schema recovered from the
14973 ** sqlite_master table of the (possibly) corrupt database as part
14974 ** of a ".recover" command. Specifically, for a table with root page
14975 ** iRoot and at least nCol columns. Additionally, if bIntkey is 0, the
14976 ** table must be a WITHOUT ROWID table, or if non-zero, not one of
14979 ** If a table is found, a (RecoverTable*) object is returned. Or, if
14980 ** no such table is found, but bIntkey is false and iRoot is the
14981 ** root page of an index in the recovered schema, then (*pbNoop) is
14982 ** set to true and NULL returned. Or, if there is no such table or
14983 ** index, NULL is returned and (*pbNoop) set to 0, indicating that
14984 ** the caller should write data to the orphans table.
14986 static RecoverTable *recoverFindTable(
14987 ShellState *pState, /* Shell state object */
14988 int *pRc, /* IN/OUT: Error code */
14989 int iRoot, /* Root page of table */
14990 int bIntkey, /* True for an intkey table */
14991 int nCol, /* Number of columns in table */
14992 int *pbNoop /* OUT: True if iRoot is root of index */
14994 sqlite3_stmt *pStmt = 0;
14995 RecoverTable *pRet = 0;
14997 const char *zSql = 0;
14998 const char *zName = 0;
15000 /* Search the recovered schema for an object with root page iRoot. */
15001 shellPreparePrintf(pState->db, pRc, &pStmt,
15002 "SELECT type, name, sql FROM recovery.schema WHERE rootpage=%d", iRoot
15004 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15005 const char *zType = (const char*)sqlite3_column_text(pStmt, 0);
15006 if( bIntkey==0 && sqlite3_stricmp(zType, "index")==0 ){
15010 if( sqlite3_stricmp(zType, "table")==0 ){
15011 zName = (const char*)sqlite3_column_text(pStmt, 1);
15012 zSql = (const char*)sqlite3_column_text(pStmt, 2);
15013 pRet = recoverNewTable(pRc, zName, zSql, bIntkey, nCol);
15018 shellFinalize(pRc, pStmt);
15024 ** Return a RecoverTable object representing the orphans table.
15026 static RecoverTable *recoverOrphanTable(
15027 ShellState *pState, /* Shell state object */
15028 int *pRc, /* IN/OUT: Error code */
15029 const char *zLostAndFound, /* Base name for orphans table */
15030 int nCol /* Number of user data columns */
15032 RecoverTable *pTab = 0;
15033 if( nCol>=0 && *pRc==SQLITE_OK ){
15036 /* This block determines the name of the orphan table. The prefered
15037 ** name is zLostAndFound. But if that clashes with another name
15038 ** in the recovered schema, try zLostAndFound_0, zLostAndFound_1
15039 ** and so on until a non-clashing name is found. */
15041 char *zTab = shellMPrintf(pRc, "%s", zLostAndFound);
15042 sqlite3_stmt *pTest = 0;
15043 shellPrepare(pState->db, pRc,
15044 "SELECT 1 FROM recovery.schema WHERE name=?", &pTest
15046 if( pTest ) sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT);
15047 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pTest) ){
15048 shellReset(pRc, pTest);
15049 sqlite3_free(zTab);
15050 zTab = shellMPrintf(pRc, "%s_%d", zLostAndFound, iTab++);
15051 sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT);
15053 shellFinalize(pRc, pTest);
15055 pTab = (RecoverTable*)shellMalloc(pRc, sizeof(RecoverTable));
15057 pTab->zQuoted = shellMPrintf(pRc, "%Q", zTab);
15061 pTab->azlCol = (char**)shellMalloc(pRc, sizeof(char*) * (nCol+1));
15062 if( pTab->azlCol ){
15063 pTab->azlCol[nCol] = shellMPrintf(pRc, "");
15064 for(i=nCol-1; i>=0; i--){
15065 pTab->azlCol[i] = shellMPrintf(pRc, "%s, NULL", pTab->azlCol[i+1]);
15070 if( *pRc!=SQLITE_OK ){
15071 recoverFreeTable(pTab);
15074 raw_printf(pState->out,
15075 "CREATE TABLE %s(rootpgno INTEGER, "
15076 "pgno INTEGER, nfield INTEGER, id INTEGER", pTab->zQuoted
15078 for(i=0; i<nCol; i++){
15079 raw_printf(pState->out, ", c%d", i);
15081 raw_printf(pState->out, ");\n");
15084 sqlite3_free(zTab);
15090 ** This function is called to recover data from the database. A script
15091 ** to construct a new database containing all recovered data is output
15092 ** on stream pState->out.
15094 static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){
15095 int rc = SQLITE_OK;
15096 sqlite3_stmt *pLoop = 0; /* Loop through all root pages */
15097 sqlite3_stmt *pPages = 0; /* Loop through all pages in a group */
15098 sqlite3_stmt *pCells = 0; /* Loop through all cells in a page */
15099 const char *zRecoveryDb = ""; /* Name of "recovery" database */
15100 const char *zLostAndFound = "lost_and_found";
15103 RecoverTable *pOrphan = 0;
15105 int bFreelist = 1; /* 0 if --freelist-corrupt is specified */
15106 for(i=1; i<nArg; i++){
15107 char *z = azArg[i];
15109 if( z[0]=='-' && z[1]=='-' ) z++;
15111 if( n<=17 && memcmp("-freelist-corrupt", z, n)==0 ){
15114 if( n<=12 && memcmp("-recovery-db", z, n)==0 && i<(nArg-1) ){
15116 zRecoveryDb = azArg[i];
15118 if( n<=15 && memcmp("-lost-and-found", z, n)==0 && i<(nArg-1) ){
15120 zLostAndFound = azArg[i];
15123 raw_printf(stderr, "unexpected option: %s\n", azArg[i]);
15124 raw_printf(stderr, "options are:\n");
15125 raw_printf(stderr, " --freelist-corrupt\n");
15126 raw_printf(stderr, " --recovery-db DATABASE\n");
15127 raw_printf(stderr, " --lost-and-found TABLE-NAME\n");
15132 shellExecPrintf(pState->db, &rc,
15133 /* Attach an in-memory database named 'recovery'. Create an indexed
15134 ** cache of the sqlite_dbptr virtual table. */
15135 "ATTACH %Q AS recovery;"
15136 "DROP TABLE IF EXISTS recovery.dbptr;"
15137 "DROP TABLE IF EXISTS recovery.freelist;"
15138 "DROP TABLE IF EXISTS recovery.map;"
15139 "DROP TABLE IF EXISTS recovery.schema;"
15140 "CREATE TABLE recovery.freelist(pgno INTEGER PRIMARY KEY);", zRecoveryDb
15144 shellExec(pState->db, &rc,
15145 "WITH trunk(pgno) AS ("
15146 " SELECT shell_int32("
15147 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 8) AS x "
15150 " SELECT shell_int32("
15151 " (SELECT data FROM sqlite_dbpage WHERE pgno=trunk.pgno), 0) AS x "
15152 " FROM trunk WHERE x>0"
15154 "freelist(data, n, freepgno) AS ("
15155 " SELECT data, min(16384, shell_int32(data, 1)-1), t.pgno "
15156 " FROM trunk t, sqlite_dbpage s WHERE s.pgno=t.pgno"
15158 " SELECT data, n-1, shell_int32(data, 2+n) "
15159 " FROM freelist WHERE n>=0"
15161 "REPLACE INTO recovery.freelist SELECT freepgno FROM freelist;"
15165 shellExec(pState->db, &rc,
15166 "CREATE TABLE recovery.dbptr("
15167 " pgno, child, PRIMARY KEY(child, pgno)"
15169 "INSERT OR IGNORE INTO recovery.dbptr(pgno, child) "
15170 " SELECT * FROM sqlite_dbptr"
15171 " WHERE pgno NOT IN freelist AND child NOT IN freelist;"
15173 /* Delete any pointer to page 1. This ensures that page 1 is considered
15174 ** a root page, regardless of how corrupt the db is. */
15175 "DELETE FROM recovery.dbptr WHERE child = 1;"
15177 /* Delete all pointers to any pages that have more than one pointer
15178 ** to them. Such pages will be treated as root pages when recovering
15180 "DELETE FROM recovery.dbptr WHERE child IN ("
15181 " SELECT child FROM recovery.dbptr GROUP BY child HAVING count(*)>1"
15184 /* Create the "map" table that will (eventually) contain instructions
15185 ** for dealing with each page in the db that contains one or more
15187 "CREATE TABLE recovery.map("
15188 "pgno INTEGER PRIMARY KEY, maxlen INT, intkey, root INT"
15191 /* Populate table [map]. If there are circular loops of pages in the
15192 ** database, the following adds all pages in such a loop to the map
15193 ** as individual root pages. This could be handled better. */
15194 "WITH pages(i, maxlen) AS ("
15195 " SELECT page_count, ("
15196 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=page_count"
15197 " ) FROM pragma_page_count WHERE page_count>0"
15200 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=i-1"
15201 " ) FROM pages WHERE i>=2"
15203 "INSERT INTO recovery.map(pgno, maxlen, intkey, root) "
15204 " SELECT i, maxlen, NULL, ("
15205 " WITH p(orig, pgno, parent) AS ("
15206 " SELECT 0, i, (SELECT pgno FROM recovery.dbptr WHERE child=i)"
15208 " SELECT i, p.parent, "
15209 " (SELECT pgno FROM recovery.dbptr WHERE child=p.parent) FROM p"
15211 " SELECT pgno FROM p WHERE (parent IS NULL OR pgno = orig)"
15213 "FROM pages WHERE maxlen > 0 AND i NOT IN freelist;"
15214 "UPDATE recovery.map AS o SET intkey = ("
15215 " SELECT substr(data, 1, 1)==X'0D' FROM sqlite_dbpage WHERE pgno=o.pgno"
15218 /* Extract data from page 1 and any linked pages into table
15219 ** recovery.schema. With the same schema as an sqlite_master table. */
15220 "CREATE TABLE recovery.schema(type, name, tbl_name, rootpage, sql);"
15221 "INSERT INTO recovery.schema SELECT "
15222 " max(CASE WHEN field=0 THEN value ELSE NULL END),"
15223 " max(CASE WHEN field=1 THEN value ELSE NULL END),"
15224 " max(CASE WHEN field=2 THEN value ELSE NULL END),"
15225 " max(CASE WHEN field=3 THEN value ELSE NULL END),"
15226 " max(CASE WHEN field=4 THEN value ELSE NULL END)"
15227 "FROM sqlite_dbdata WHERE pgno IN ("
15228 " SELECT pgno FROM recovery.map WHERE root=1"
15230 "GROUP BY pgno, cell;"
15231 "CREATE INDEX recovery.schema_rootpage ON schema(rootpage);"
15234 /* Open a transaction, then print out all non-virtual, non-"sqlite_%"
15235 ** CREATE TABLE statements that extracted from the existing schema. */
15236 if( rc==SQLITE_OK ){
15237 sqlite3_stmt *pStmt = 0;
15238 raw_printf(pState->out, "BEGIN;\n");
15239 raw_printf(pState->out, "PRAGMA writable_schema = on;\n");
15240 shellPrepare(pState->db, &rc,
15241 "SELECT sql FROM recovery.schema "
15242 "WHERE type='table' AND sql LIKE 'create table%'", &pStmt
15244 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15245 const char *zCreateTable = (const char*)sqlite3_column_text(pStmt, 0);
15246 raw_printf(pState->out, "CREATE TABLE IF NOT EXISTS %s;\n",
15250 shellFinalize(&rc, pStmt);
15253 /* Figure out if an orphan table will be required. And if so, how many
15254 ** user columns it should contain */
15255 shellPrepare(pState->db, &rc,
15256 "SELECT coalesce(max(maxlen), -2) FROM recovery.map WHERE root>1"
15259 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){
15260 nOrphan = sqlite3_column_int(pLoop, 0);
15262 shellFinalize(&rc, pLoop);
15265 shellPrepare(pState->db, &rc,
15266 "SELECT pgno FROM recovery.map WHERE root=?", &pPages
15268 shellPrepare(pState->db, &rc,
15269 "SELECT max(field), group_concat(shell_escape_crnl(quote(value)), ', ')"
15270 "FROM sqlite_dbdata WHERE pgno = ? AND field != ?"
15271 "GROUP BY cell", &pCells
15274 /* Loop through each root page. */
15275 shellPrepare(pState->db, &rc,
15276 "SELECT root, intkey, max(maxlen) FROM recovery.map"
15277 " WHERE root>1 GROUP BY root, intkey ORDER BY root=("
15278 " SELECT rootpage FROM recovery.schema WHERE name='sqlite_sequence'"
15281 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){
15282 int iRoot = sqlite3_column_int(pLoop, 0);
15283 int bIntkey = sqlite3_column_int(pLoop, 1);
15284 int nCol = sqlite3_column_int(pLoop, 2);
15286 RecoverTable *pTab;
15288 pTab = recoverFindTable(pState, &rc, iRoot, bIntkey, nCol, &bNoop);
15289 if( bNoop || rc ) continue;
15292 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan);
15295 if( pTab==0 ) break;
15298 if( 0==sqlite3_stricmp(pTab->zQuoted, "'sqlite_sequence'") ){
15299 raw_printf(pState->out, "DELETE FROM sqlite_sequence;\n");
15301 sqlite3_bind_int(pPages, 1, iRoot);
15302 sqlite3_bind_int(pCells, 2, pTab->iPk);
15304 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPages) ){
15305 int iPgno = sqlite3_column_int(pPages, 0);
15306 sqlite3_bind_int(pCells, 1, iPgno);
15307 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pCells) ){
15308 int nField = sqlite3_column_int(pCells, 0);
15309 const char *zVal = (const char*)sqlite3_column_text(pCells, 1);
15312 if( pTab==pOrphan ){
15313 raw_printf(pState->out,
15314 "INSERT INTO %s VALUES(%d, %d, %d, %s%s%s);\n",
15315 pTab->zQuoted, iRoot, iPgno, nField,
15316 bIntkey ? "" : "NULL, ", zVal, pTab->azlCol[nField]
15319 raw_printf(pState->out, "INSERT INTO %s(%s) VALUES( %s );\n",
15320 pTab->zQuoted, pTab->azlCol[nField], zVal
15324 shellReset(&rc, pCells);
15326 shellReset(&rc, pPages);
15327 if( pTab!=pOrphan ) recoverFreeTable(pTab);
15329 shellFinalize(&rc, pLoop);
15330 shellFinalize(&rc, pPages);
15331 shellFinalize(&rc, pCells);
15332 recoverFreeTable(pOrphan);
15334 /* The rest of the schema */
15335 if( rc==SQLITE_OK ){
15336 sqlite3_stmt *pStmt = 0;
15337 shellPrepare(pState->db, &rc,
15338 "SELECT sql, name FROM recovery.schema "
15339 "WHERE sql NOT LIKE 'create table%'", &pStmt
15341 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15342 const char *zSql = (const char*)sqlite3_column_text(pStmt, 0);
15343 if( sqlite3_strnicmp(zSql, "create virt", 11)==0 ){
15344 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
15345 char *zPrint = shellMPrintf(&rc,
15346 "INSERT INTO sqlite_master VALUES('table', %Q, %Q, 0, %Q)",
15349 raw_printf(pState->out, "%s;\n", zPrint);
15350 sqlite3_free(zPrint);
15352 raw_printf(pState->out, "%s;\n", zSql);
15355 shellFinalize(&rc, pStmt);
15358 if( rc==SQLITE_OK ){
15359 raw_printf(pState->out, "PRAGMA writable_schema = off;\n");
15360 raw_printf(pState->out, "COMMIT;\n");
15362 sqlite3_exec(pState->db, "DETACH recovery", 0, 0, 0);
15365 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */
15369 ** If an input line begins with "." then invoke this routine to
15370 ** process that line.
15372 ** Return 1 on error, 2 to exit, and 0 otherwise.
15374 static int do_meta_command(char *zLine, ShellState *p){
15381 #ifndef SQLITE_OMIT_VIRTUALTABLE
15382 if( p->expert.pExpert ){
15383 expertFinish(p, 1, 0);
15387 /* Parse the input line into tokens.
15389 while( zLine[h] && nArg<ArraySize(azArg) ){
15390 while( IsSpace(zLine[h]) ){ h++; }
15391 if( zLine[h]==0 ) break;
15392 if( zLine[h]=='\'' || zLine[h]=='"' ){
15393 int delim = zLine[h++];
15394 azArg[nArg++] = &zLine[h];
15395 while( zLine[h] && zLine[h]!=delim ){
15396 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
15399 if( zLine[h]==delim ){
15402 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
15404 azArg[nArg++] = &zLine[h];
15405 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
15406 if( zLine[h] ) zLine[h++] = 0;
15407 resolve_backslashes(azArg[nArg-1]);
15411 /* Process the input line.
15413 if( nArg==0 ) return 0; /* no tokens, no error */
15414 n = strlen30(azArg[0]);
15418 #ifndef SQLITE_OMIT_AUTHORIZATION
15419 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){
15421 raw_printf(stderr, "Usage: .auth ON|OFF\n");
15423 goto meta_command_exit;
15426 if( booleanValue(azArg[1]) ){
15427 sqlite3_set_authorizer(p->db, shellAuth, p);
15429 sqlite3_set_authorizer(p->db, 0, 0);
15434 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
15435 if( c=='a' && strncmp(azArg[0], "archive", n)==0 ){
15437 rc = arDotCommand(p, 0, azArg, nArg);
15441 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
15442 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
15444 const char *zDestFile = 0;
15445 const char *zDb = 0;
15447 sqlite3_backup *pBackup;
15450 const char *zVfs = 0;
15451 for(j=1; j<nArg; j++){
15452 const char *z = azArg[j];
15454 if( z[1]=='-' ) z++;
15455 if( strcmp(z, "-append")==0 ){
15458 if( strcmp(z, "-async")==0 ){
15462 utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
15465 }else if( zDestFile==0 ){
15466 zDestFile = azArg[j];
15467 }else if( zDb==0 ){
15469 zDestFile = azArg[j];
15471 raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
15475 if( zDestFile==0 ){
15476 raw_printf(stderr, "missing FILENAME argument on .backup\n");
15479 if( zDb==0 ) zDb = "main";
15480 rc = sqlite3_open_v2(zDestFile, &pDest,
15481 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs);
15482 if( rc!=SQLITE_OK ){
15483 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
15488 sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
15492 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
15494 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
15498 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
15499 sqlite3_backup_finish(pBackup);
15500 if( rc==SQLITE_DONE ){
15503 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
15509 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
15511 bail_on_error = booleanValue(azArg[1]);
15513 raw_printf(stderr, "Usage: .bail on|off\n");
15518 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
15520 if( booleanValue(azArg[1]) ){
15521 setBinaryMode(p->out, 1);
15523 setTextMode(p->out, 1);
15526 raw_printf(stderr, "Usage: .binary on|off\n");
15531 if( c=='c' && strcmp(azArg[0],"cd")==0 ){
15533 #if defined(_WIN32) || defined(WIN32)
15534 wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]);
15535 rc = !SetCurrentDirectoryW(z);
15538 rc = chdir(azArg[1]);
15541 utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]);
15545 raw_printf(stderr, "Usage: .cd DIRECTORY\n");
15550 /* The undocumented ".breakpoint" command causes a call to the no-op
15551 ** routine named test_breakpoint().
15553 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
15557 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
15559 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
15561 raw_printf(stderr, "Usage: .changes on|off\n");
15566 /* Cancel output redirection, if it is currently set (by .testcase)
15567 ** Then read the content of the testcase-out.txt file and compare against
15568 ** azArg[1]. If there are differences, report an error and exit.
15570 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){
15574 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n");
15576 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
15577 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n");
15579 }else if( testcase_glob(azArg[1],zRes)==0 ){
15580 utf8_printf(stderr,
15581 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
15582 p->zTestcase, azArg[1], zRes);
15585 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase);
15588 sqlite3_free(zRes);
15591 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
15593 tryToClone(p, azArg[1]);
15595 raw_printf(stderr, "Usage: .clone FILENAME\n");
15600 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
15604 memcpy(&data, p, sizeof(data));
15605 data.showHeader = 0;
15606 data.cMode = data.mode = MODE_List;
15607 sqlite3_snprintf(sizeof(data.colSeparator),data.colSeparator,": ");
15609 sqlite3_exec(p->db, "SELECT name, file FROM pragma_database_list",
15610 callback, &data, &zErrMsg);
15612 utf8_printf(stderr,"Error: %s\n", zErrMsg);
15613 sqlite3_free(zErrMsg);
15618 if( c=='d' && n>=3 && strncmp(azArg[0], "dbconfig", n)==0 ){
15619 static const struct DbConfigChoices {
15623 { "enable_fkey", SQLITE_DBCONFIG_ENABLE_FKEY },
15624 { "enable_trigger", SQLITE_DBCONFIG_ENABLE_TRIGGER },
15625 { "fts3_tokenizer", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
15626 { "load_extension", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
15627 { "no_ckpt_on_close", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE },
15628 { "enable_qpsg", SQLITE_DBCONFIG_ENABLE_QPSG },
15629 { "trigger_eqp", SQLITE_DBCONFIG_TRIGGER_EQP },
15630 { "reset_database", SQLITE_DBCONFIG_RESET_DATABASE },
15631 { "defensive", SQLITE_DBCONFIG_DEFENSIVE },
15632 { "writable_schema", SQLITE_DBCONFIG_WRITABLE_SCHEMA },
15633 { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE },
15634 { "dqs_dml", SQLITE_DBCONFIG_DQS_DML },
15635 { "dqs_ddl", SQLITE_DBCONFIG_DQS_DDL },
15639 for(ii=0; ii<ArraySize(aDbConfig); ii++){
15640 if( nArg>1 && strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
15642 sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
15644 sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
15645 utf8_printf(p->out, "%18s %s\n", aDbConfig[ii].zName, v ? "on" : "off");
15646 if( nArg>1 ) break;
15648 if( nArg>1 && ii==ArraySize(aDbConfig) ){
15649 utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]);
15650 utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n");
15654 if( c=='d' && n>=3 && strncmp(azArg[0], "dbinfo", n)==0 ){
15655 rc = shell_dbinfo_command(p, nArg, azArg);
15658 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
15659 if( c=='r' && strncmp(azArg[0], "recover", n)==0 ){
15661 rc = recoverDatabaseCmd(p, nArg, azArg);
15663 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */
15665 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
15666 const char *zLike = 0;
15668 int savedShowHeader = p->showHeader;
15669 int savedShellFlags = p->shellFlgs;
15670 ShellClearFlag(p, SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo);
15671 for(i=1; i<nArg; i++){
15672 if( azArg[i][0]=='-' ){
15673 const char *z = azArg[i]+1;
15674 if( z[0]=='-' ) z++;
15675 if( strcmp(z,"preserve-rowids")==0 ){
15676 #ifdef SQLITE_OMIT_VIRTUALTABLE
15677 raw_printf(stderr, "The --preserve-rowids option is not compatible"
15678 " with SQLITE_OMIT_VIRTUALTABLE\n");
15680 goto meta_command_exit;
15682 ShellSetFlag(p, SHFLG_PreserveRowid);
15685 if( strcmp(z,"newlines")==0 ){
15686 ShellSetFlag(p, SHFLG_Newlines);
15689 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
15691 goto meta_command_exit;
15694 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? "
15695 "?--newlines? ?LIKE-PATTERN?\n");
15697 goto meta_command_exit;
15705 /* When playing back a "dump", the content might appear in an order
15706 ** which causes immediate foreign key constraints to be violated.
15707 ** So disable foreign-key constraint enforcement to prevent problems. */
15708 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
15709 raw_printf(p->out, "BEGIN TRANSACTION;\n");
15710 p->writableSchema = 0;
15712 /* Set writable_schema=ON since doing so forces SQLite to initialize
15713 ** as much of the schema as it can even if the sqlite_master table is
15715 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
15718 run_schema_dump_query(p,
15719 "SELECT name, type, sql FROM sqlite_master "
15720 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
15722 run_schema_dump_query(p,
15723 "SELECT name, type, sql FROM sqlite_master "
15724 "WHERE name=='sqlite_sequence'"
15726 run_table_dump_query(p,
15727 "SELECT sql FROM sqlite_master "
15728 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
15732 zSql = sqlite3_mprintf(
15733 "SELECT name, type, sql FROM sqlite_master "
15734 "WHERE tbl_name LIKE %Q AND type=='table'"
15735 " AND sql NOT NULL", zLike);
15736 run_schema_dump_query(p,zSql);
15737 sqlite3_free(zSql);
15738 zSql = sqlite3_mprintf(
15739 "SELECT sql FROM sqlite_master "
15740 "WHERE sql NOT NULL"
15741 " AND type IN ('index','trigger','view')"
15742 " AND tbl_name LIKE %Q", zLike);
15743 run_table_dump_query(p, zSql, 0);
15744 sqlite3_free(zSql);
15746 if( p->writableSchema ){
15747 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
15748 p->writableSchema = 0;
15750 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
15751 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
15752 raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n");
15753 p->showHeader = savedShowHeader;
15754 p->shellFlgs = savedShellFlags;
15757 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
15759 setOrClearFlag(p, SHFLG_Echo, azArg[1]);
15761 raw_printf(stderr, "Usage: .echo on|off\n");
15766 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
15768 p->autoEQPtest = 0;
15769 if( p->autoEQPtrace ){
15770 if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0);
15771 p->autoEQPtrace = 0;
15773 if( strcmp(azArg[1],"full")==0 ){
15774 p->autoEQP = AUTOEQP_full;
15775 }else if( strcmp(azArg[1],"trigger")==0 ){
15776 p->autoEQP = AUTOEQP_trigger;
15777 #ifdef SQLITE_DEBUG
15778 }else if( strcmp(azArg[1],"test")==0 ){
15779 p->autoEQP = AUTOEQP_on;
15780 p->autoEQPtest = 1;
15781 }else if( strcmp(azArg[1],"trace")==0 ){
15782 p->autoEQP = AUTOEQP_full;
15783 p->autoEQPtrace = 1;
15785 sqlite3_exec(p->db, "SELECT name FROM sqlite_master LIMIT 1", 0, 0, 0);
15786 sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0);
15789 p->autoEQP = (u8)booleanValue(azArg[1]);
15792 raw_printf(stderr, "Usage: .eqp off|on|trace|trigger|full\n");
15797 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
15798 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
15802 /* The ".explain" command is automatic now. It is largely pointless. It
15803 ** retained purely for backwards compatibility */
15804 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
15807 if( strcmp(azArg[1],"auto")==0 ){
15810 val = booleanValue(azArg[1]);
15813 if( val==1 && p->mode!=MODE_Explain ){
15814 p->normalMode = p->mode;
15815 p->mode = MODE_Explain;
15816 p->autoExplain = 0;
15817 }else if( val==0 ){
15818 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
15819 p->autoExplain = 0;
15820 }else if( val==99 ){
15821 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
15822 p->autoExplain = 1;
15826 #ifndef SQLITE_OMIT_VIRTUALTABLE
15827 if( c=='e' && strncmp(azArg[0], "expert", n)==0 ){
15829 expertDotCommand(p, azArg, nArg);
15833 if( c=='f' && strncmp(azArg[0], "filectrl", n)==0 ){
15834 static const struct {
15835 const char *zCtrlName; /* Name of a test-control option */
15836 int ctrlCode; /* Integer code for that option */
15837 const char *zUsage; /* Usage notes */
15839 { "size_limit", SQLITE_FCNTL_SIZE_LIMIT, "[LIMIT]" },
15840 { "chunk_size", SQLITE_FCNTL_CHUNK_SIZE, "SIZE" },
15841 /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY, "COUNT DELAY" },*/
15842 { "persist_wal", SQLITE_FCNTL_PERSIST_WAL, "[BOOLEAN]" },
15843 { "psow", SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]" },
15844 /* { "pragma", SQLITE_FCNTL_PRAGMA, "NAME ARG" },*/
15845 { "tempfilename", SQLITE_FCNTL_TEMPFILENAME, "" },
15846 { "has_moved", SQLITE_FCNTL_HAS_MOVED, "" },
15847 { "lock_timeout", SQLITE_FCNTL_LOCK_TIMEOUT, "MILLISEC" },
15851 sqlite3_int64 iRes = 0; /* Integer result to display if rc2==1 */
15852 int isOk = 0; /* 0: usage 1: %lld 2: no-result */
15854 const char *zCmd = 0;
15857 zCmd = nArg>=2 ? azArg[1] : "help";
15859 /* The argument can optionally begin with "-" or "--" */
15860 if( zCmd[0]=='-' && zCmd[1] ){
15862 if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
15865 /* --help lists all file-controls */
15866 if( strcmp(zCmd,"help")==0 ){
15867 utf8_printf(p->out, "Available file-controls:\n");
15868 for(i=0; i<ArraySize(aCtrl); i++){
15869 utf8_printf(p->out, " .filectrl %s %s\n",
15870 aCtrl[i].zCtrlName, aCtrl[i].zUsage);
15873 goto meta_command_exit;
15876 /* convert filectrl text option to value. allow any unique prefix
15877 ** of the option name, or a numerical value. */
15878 n2 = strlen30(zCmd);
15879 for(i=0; i<ArraySize(aCtrl); i++){
15880 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
15882 filectrl = aCtrl[i].ctrlCode;
15885 utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n"
15886 "Use \".filectrl --help\" for help\n", zCmd);
15888 goto meta_command_exit;
15893 utf8_printf(stderr,"Error: unknown file-control: %s\n"
15894 "Use \".filectrl --help\" for help\n", zCmd);
15897 case SQLITE_FCNTL_SIZE_LIMIT: {
15898 if( nArg!=2 && nArg!=3 ) break;
15899 iRes = nArg==3 ? integerValue(azArg[2]) : -1;
15900 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_SIZE_LIMIT, &iRes);
15904 case SQLITE_FCNTL_LOCK_TIMEOUT:
15905 case SQLITE_FCNTL_CHUNK_SIZE: {
15907 if( nArg!=3 ) break;
15908 x = (int)integerValue(azArg[2]);
15909 sqlite3_file_control(p->db, 0, filectrl, &x);
15913 case SQLITE_FCNTL_PERSIST_WAL:
15914 case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
15916 if( nArg!=2 && nArg!=3 ) break;
15917 x = nArg==3 ? booleanValue(azArg[2]) : -1;
15918 sqlite3_file_control(p->db, 0, filectrl, &x);
15923 case SQLITE_FCNTL_HAS_MOVED: {
15925 if( nArg!=2 ) break;
15926 sqlite3_file_control(p->db, 0, filectrl, &x);
15931 case SQLITE_FCNTL_TEMPFILENAME: {
15933 if( nArg!=2 ) break;
15934 sqlite3_file_control(p->db, 0, filectrl, &z);
15936 utf8_printf(p->out, "%s\n", z);
15944 if( isOk==0 && iCtrl>=0 ){
15945 utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
15947 }else if( isOk==1 ){
15949 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
15950 raw_printf(p->out, "%s\n", zBuf);
15954 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
15958 memcpy(&data, p, sizeof(data));
15959 data.showHeader = 0;
15960 data.cMode = data.mode = MODE_Semi;
15961 if( nArg==2 && optionMatch(azArg[1], "indent") ){
15962 data.cMode = data.mode = MODE_Pretty;
15966 raw_printf(stderr, "Usage: .fullschema ?--indent?\n");
15968 goto meta_command_exit;
15971 rc = sqlite3_exec(p->db,
15973 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
15974 " FROM sqlite_master UNION ALL"
15975 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
15976 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
15978 callback, &data, &zErrMsg
15980 if( rc==SQLITE_OK ){
15981 sqlite3_stmt *pStmt;
15982 rc = sqlite3_prepare_v2(p->db,
15983 "SELECT rowid FROM sqlite_master"
15984 " WHERE name GLOB 'sqlite_stat[134]'",
15986 doStats = sqlite3_step(pStmt)==SQLITE_ROW;
15987 sqlite3_finalize(pStmt);
15990 raw_printf(p->out, "/* No STAT tables available */\n");
15992 raw_printf(p->out, "ANALYZE sqlite_master;\n");
15993 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
15994 callback, &data, &zErrMsg);
15995 data.cMode = data.mode = MODE_Insert;
15996 data.zDestTable = "sqlite_stat1";
15997 shell_exec(&data, "SELECT * FROM sqlite_stat1", &zErrMsg);
15998 data.zDestTable = "sqlite_stat3";
15999 shell_exec(&data, "SELECT * FROM sqlite_stat3", &zErrMsg);
16000 data.zDestTable = "sqlite_stat4";
16001 shell_exec(&data, "SELECT * FROM sqlite_stat4", &zErrMsg);
16002 raw_printf(p->out, "ANALYZE sqlite_master;\n");
16006 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
16008 p->showHeader = booleanValue(azArg[1]);
16010 raw_printf(stderr, "Usage: .headers on|off\n");
16015 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
16017 n = showHelp(p->out, azArg[1]);
16019 utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]);
16022 showHelp(p->out, 0);
16026 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
16027 char *zTable; /* Insert data into this table */
16028 char *zFile; /* Name of file to extra content from */
16029 sqlite3_stmt *pStmt = NULL; /* A statement */
16030 int nCol; /* Number of columns in the table */
16031 int nByte; /* Number of bytes in an SQL string */
16032 int i, j; /* Loop counters */
16033 int needCommit; /* True to COMMIT or ROLLBACK at end */
16034 int nSep; /* Number of bytes in p->colSeparator[] */
16035 char *zSql; /* An SQL statement */
16036 ImportCtx sCtx; /* Reader context */
16037 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
16038 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
16041 raw_printf(stderr, "Usage: .import FILE TABLE\n");
16042 goto meta_command_exit;
16047 memset(&sCtx, 0, sizeof(sCtx));
16049 nSep = strlen30(p->colSeparator);
16052 "Error: non-null column separator required for import\n");
16056 raw_printf(stderr, "Error: multi-character column separators not allowed"
16060 nSep = strlen30(p->rowSeparator);
16062 raw_printf(stderr, "Error: non-null row separator required for import\n");
16065 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
16066 /* When importing CSV (only), if the row separator is set to the
16067 ** default output row separator, change it to the default input
16068 ** row separator. This avoids having to maintain different input
16069 ** and output row separators. */
16070 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16071 nSep = strlen30(p->rowSeparator);
16074 raw_printf(stderr, "Error: multi-character row separators not allowed"
16078 sCtx.zFile = zFile;
16080 if( sCtx.zFile[0]=='|' ){
16081 #ifdef SQLITE_OMIT_POPEN
16082 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
16085 sCtx.in = popen(sCtx.zFile+1, "r");
16086 sCtx.zFile = "<pipe>";
16090 sCtx.in = fopen(sCtx.zFile, "rb");
16093 if( p->mode==MODE_Ascii ){
16094 xRead = ascii_read_one_field;
16096 xRead = csv_read_one_field;
16099 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
16102 sCtx.cColSep = p->colSeparator[0];
16103 sCtx.cRowSep = p->rowSeparator[0];
16104 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
16107 shell_out_of_memory();
16109 nByte = strlen30(zSql);
16110 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16111 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
16112 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
16113 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
16115 while( xRead(&sCtx) ){
16116 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z);
16118 if( sCtx.cTerm!=sCtx.cColSep ) break;
16121 sqlite3_free(zCreate);
16122 sqlite3_free(sCtx.z);
16124 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
16127 zCreate = sqlite3_mprintf("%z\n)", zCreate);
16128 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
16129 sqlite3_free(zCreate);
16131 utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
16132 sqlite3_errmsg(p->db));
16133 sqlite3_free(sCtx.z);
16137 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16139 sqlite3_free(zSql);
16141 if (pStmt) sqlite3_finalize(pStmt);
16142 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
16146 nCol = sqlite3_column_count(pStmt);
16147 sqlite3_finalize(pStmt);
16149 if( nCol==0 ) return 0; /* no columns, no error */
16150 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
16153 shell_out_of_memory();
16155 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
16156 j = strlen30(zSql);
16157 for(i=1; i<nCol; i++){
16163 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16164 sqlite3_free(zSql);
16166 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16167 if (pStmt) sqlite3_finalize(pStmt);
16171 needCommit = sqlite3_get_autocommit(p->db);
16172 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
16174 int startLine = sCtx.nLine;
16175 for(i=0; i<nCol; i++){
16176 char *z = xRead(&sCtx);
16178 ** Did we reach end-of-file before finding any columns?
16179 ** If so, stop instead of NULL filling the remaining columns.
16181 if( z==0 && i==0 ) break;
16183 ** Did we reach end-of-file OR end-of-line before finding any
16184 ** columns in ASCII mode? If so, stop instead of NULL filling
16185 ** the remaining columns.
16187 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
16188 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
16189 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
16190 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
16191 "filling the rest with NULL\n",
16192 sCtx.zFile, startLine, nCol, i+1);
16194 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
16197 if( sCtx.cTerm==sCtx.cColSep ){
16201 }while( sCtx.cTerm==sCtx.cColSep );
16202 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
16203 "extras ignored\n",
16204 sCtx.zFile, startLine, nCol, i);
16207 sqlite3_step(pStmt);
16208 rc = sqlite3_reset(pStmt);
16209 if( rc!=SQLITE_OK ){
16210 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
16211 startLine, sqlite3_errmsg(p->db));
16214 }while( sCtx.cTerm!=EOF );
16217 sqlite3_free(sCtx.z);
16218 sqlite3_finalize(pStmt);
16219 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
16222 #ifndef SQLITE_UNTESTABLE
16223 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){
16225 char *zCollist = 0;
16226 sqlite3_stmt *pStmt;
16229 if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
16230 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n"
16231 " .imposter off\n");
16233 goto meta_command_exit;
16237 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1);
16238 goto meta_command_exit;
16240 zSql = sqlite3_mprintf("SELECT rootpage FROM sqlite_master"
16241 " WHERE name='%q' AND type='index'", azArg[1]);
16242 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16243 sqlite3_free(zSql);
16244 if( sqlite3_step(pStmt)==SQLITE_ROW ){
16245 tnum = sqlite3_column_int(pStmt, 0);
16247 sqlite3_finalize(pStmt);
16249 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]);
16251 goto meta_command_exit;
16253 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]);
16254 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16255 sqlite3_free(zSql);
16257 while( sqlite3_step(pStmt)==SQLITE_ROW ){
16259 const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
16262 if( sqlite3_column_int(pStmt,1)==-1 ){
16265 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i);
16270 zCollist = sqlite3_mprintf("\"%w\"", zCol);
16272 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
16275 sqlite3_finalize(pStmt);
16276 zSql = sqlite3_mprintf(
16277 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%s))WITHOUT ROWID",
16278 azArg[2], zCollist, zCollist);
16279 sqlite3_free(zCollist);
16280 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
16281 if( rc==SQLITE_OK ){
16282 rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
16283 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
16285 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
16287 utf8_printf(stdout, "%s;\n", zSql);
16289 "WARNING: writing to an imposter table will corrupt the index!\n"
16293 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
16296 sqlite3_free(zSql);
16298 #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
16300 #ifdef SQLITE_ENABLE_IOTRACE
16301 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
16302 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
16303 if( iotrace && iotrace!=stdout ) fclose(iotrace);
16306 sqlite3IoTrace = 0;
16307 }else if( strcmp(azArg[1], "-")==0 ){
16308 sqlite3IoTrace = iotracePrintf;
16311 iotrace = fopen(azArg[1], "w");
16313 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
16314 sqlite3IoTrace = 0;
16317 sqlite3IoTrace = iotracePrintf;
16323 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
16324 static const struct {
16325 const char *zLimitName; /* Name of a limit */
16326 int limitCode; /* Integer code for that limit */
16328 { "length", SQLITE_LIMIT_LENGTH },
16329 { "sql_length", SQLITE_LIMIT_SQL_LENGTH },
16330 { "column", SQLITE_LIMIT_COLUMN },
16331 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH },
16332 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT },
16333 { "vdbe_op", SQLITE_LIMIT_VDBE_OP },
16334 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG },
16335 { "attached", SQLITE_LIMIT_ATTACHED },
16336 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
16337 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER },
16338 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH },
16339 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS },
16344 for(i=0; i<ArraySize(aLimit); i++){
16345 printf("%20s %d\n", aLimit[i].zLimitName,
16346 sqlite3_limit(p->db, aLimit[i].limitCode, -1));
16348 }else if( nArg>3 ){
16349 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
16351 goto meta_command_exit;
16354 n2 = strlen30(azArg[1]);
16355 for(i=0; i<ArraySize(aLimit); i++){
16356 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
16360 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
16362 goto meta_command_exit;
16367 utf8_printf(stderr, "unknown limit: \"%s\"\n"
16368 "enter \".limits\" with no arguments for a list.\n",
16371 goto meta_command_exit;
16374 sqlite3_limit(p->db, aLimit[iLimit].limitCode,
16375 (int)integerValue(azArg[2]));
16377 printf("%20s %d\n", aLimit[iLimit].zLimitName,
16378 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
16382 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){
16384 lintDotCommand(p, azArg, nArg);
16387 #ifndef SQLITE_OMIT_LOAD_EXTENSION
16388 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
16389 const char *zFile, *zProc;
16392 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
16394 goto meta_command_exit;
16397 zProc = nArg>=3 ? azArg[2] : 0;
16399 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
16400 if( rc!=SQLITE_OK ){
16401 utf8_printf(stderr, "Error: %s\n", zErrMsg);
16402 sqlite3_free(zErrMsg);
16408 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
16410 raw_printf(stderr, "Usage: .log FILENAME\n");
16413 const char *zFile = azArg[1];
16414 output_file_close(p->pLog);
16415 p->pLog = output_file_open(zFile, 0);
16419 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
16420 const char *zMode = nArg>=2 ? azArg[1] : "";
16421 int n2 = strlen30(zMode);
16423 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
16424 p->mode = MODE_Line;
16425 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16426 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
16427 p->mode = MODE_Column;
16428 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16429 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
16430 p->mode = MODE_List;
16431 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column);
16432 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16433 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
16434 p->mode = MODE_Html;
16435 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
16436 p->mode = MODE_Tcl;
16437 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
16438 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16439 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
16440 p->mode = MODE_Csv;
16441 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
16442 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
16443 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
16444 p->mode = MODE_List;
16445 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
16446 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
16447 p->mode = MODE_Insert;
16448 set_table_name(p, nArg>=3 ? azArg[2] : "table");
16449 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){
16450 p->mode = MODE_Quote;
16451 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
16452 p->mode = MODE_Ascii;
16453 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
16454 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
16455 }else if( nArg==1 ){
16456 raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]);
16458 raw_printf(stderr, "Error: mode should be one of: "
16459 "ascii column csv html insert line list quote tabs tcl\n");
16462 p->cMode = p->mode;
16465 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
16467 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
16468 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
16470 raw_printf(stderr, "Usage: .nullvalue STRING\n");
16475 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
16476 char *zNewFilename; /* Name of the database file to open */
16477 int iName = 1; /* Index in azArg[] of the filename */
16478 int newFlag = 0; /* True to delete file before opening */
16479 /* Close the existing database */
16480 session_close_all(p);
16483 p->zDbFilename = 0;
16484 sqlite3_free(p->zFreeOnClose);
16485 p->zFreeOnClose = 0;
16486 p->openMode = SHELL_OPEN_UNSPEC;
16488 /* Check for command-line arguments */
16489 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){
16490 const char *z = azArg[iName];
16491 if( optionMatch(z,"new") ){
16493 #ifdef SQLITE_HAVE_ZLIB
16494 }else if( optionMatch(z, "zip") ){
16495 p->openMode = SHELL_OPEN_ZIPFILE;
16497 }else if( optionMatch(z, "append") ){
16498 p->openMode = SHELL_OPEN_APPENDVFS;
16499 }else if( optionMatch(z, "readonly") ){
16500 p->openMode = SHELL_OPEN_READONLY;
16501 #ifdef SQLITE_ENABLE_DESERIALIZE
16502 }else if( optionMatch(z, "deserialize") ){
16503 p->openMode = SHELL_OPEN_DESERIALIZE;
16504 }else if( optionMatch(z, "hexdb") ){
16505 p->openMode = SHELL_OPEN_HEXDB;
16506 }else if( optionMatch(z, "maxsize") && iName+1<nArg ){
16507 p->szMax = integerValue(azArg[++iName]);
16508 #endif /* SQLITE_ENABLE_DESERIALIZE */
16509 }else if( z[0]=='-' ){
16510 utf8_printf(stderr, "unknown option: %s\n", z);
16512 goto meta_command_exit;
16515 /* If a filename is specified, try to open it first */
16516 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0;
16517 if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){
16518 if( newFlag ) shellDeleteFile(zNewFilename);
16519 p->zDbFilename = zNewFilename;
16520 open_db(p, OPEN_DB_KEEPALIVE);
16522 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
16523 sqlite3_free(zNewFilename);
16525 p->zFreeOnClose = zNewFilename;
16529 /* As a fall-back open a TEMP database */
16530 p->zDbFilename = 0;
16536 && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0))
16537 || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0)
16539 const char *zFile = nArg>=2 ? azArg[1] : "stdout";
16541 if( azArg[0][0]=='e' ){
16542 /* Transform the ".excel" command into ".once -x" */
16545 zFile = azArg[1] = "-x";
16549 utf8_printf(stderr, "Usage: .%s [-e|-x|FILE]\n", azArg[0]);
16551 goto meta_command_exit;
16553 if( n>1 && strncmp(azArg[0], "once", n)==0 ){
16555 raw_printf(stderr, "Usage: .once (-e|-x|FILE)\n");
16557 goto meta_command_exit;
16564 if( zFile[0]=='-' && zFile[1]=='-' ) zFile++;
16565 #ifndef SQLITE_NOHAVE_SYSTEM
16566 if( strcmp(zFile, "-e")==0 || strcmp(zFile, "-x")==0 ){
16569 if( zFile[1]=='x' ){
16570 newTempFile(p, "csv");
16571 p->mode = MODE_Csv;
16572 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
16573 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
16575 newTempFile(p, "txt");
16578 zFile = p->zTempFile;
16580 #endif /* SQLITE_NOHAVE_SYSTEM */
16581 if( zFile[0]=='|' ){
16582 #ifdef SQLITE_OMIT_POPEN
16583 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
16587 p->out = popen(zFile + 1, "w");
16589 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
16593 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
16597 p->out = output_file_open(zFile, bTxtMode);
16599 if( strcmp(zFile,"off")!=0 ){
16600 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
16605 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
16610 if( c=='p' && n>=3 && strncmp(azArg[0], "parameter", n)==0 ){
16612 if( nArg<=1 ) goto parameter_syntax_error;
16614 /* .parameter clear
16615 ** Clear all bind parameters by dropping the TEMP table that holds them.
16617 if( nArg==2 && strcmp(azArg[1],"clear")==0 ){
16619 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema);
16620 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0);
16621 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;",
16623 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0);
16627 ** List all bind parameters.
16629 if( nArg==2 && strcmp(azArg[1],"list")==0 ){
16630 sqlite3_stmt *pStmt = 0;
16633 rx = sqlite3_prepare_v2(p->db,
16634 "SELECT max(length(key)) "
16635 "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
16636 if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
16637 len = sqlite3_column_int(pStmt, 0);
16638 if( len>40 ) len = 40;
16640 sqlite3_finalize(pStmt);
16643 rx = sqlite3_prepare_v2(p->db,
16644 "SELECT key, quote(value) "
16645 "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
16646 while( sqlite3_step(pStmt)==SQLITE_ROW ){
16647 utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
16648 sqlite3_column_text(pStmt,1));
16650 sqlite3_finalize(pStmt);
16655 ** Make sure the TEMP table used to hold bind parameters exists.
16656 ** Create it if necessary.
16658 if( nArg==2 && strcmp(azArg[1],"init")==0 ){
16659 bind_table_init(p);
16662 /* .parameter set NAME VALUE
16663 ** Set or reset a bind parameter. NAME should be the full parameter
16664 ** name exactly as it appears in the query. (ex: $abc, @def). The
16665 ** VALUE can be in either SQL literal notation, or if not it will be
16666 ** understood to be a text string.
16668 if( nArg==4 && strcmp(azArg[1],"set")==0 ){
16671 sqlite3_stmt *pStmt;
16672 const char *zKey = azArg[2];
16673 const char *zValue = azArg[3];
16674 bind_table_init(p);
16675 zSql = sqlite3_mprintf(
16676 "REPLACE INTO temp.sqlite_parameters(key,value)"
16677 "VALUES(%Q,%s);", zKey, zValue);
16678 if( zSql==0 ) shell_out_of_memory();
16680 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16681 sqlite3_free(zSql);
16682 if( rx!=SQLITE_OK ){
16683 sqlite3_finalize(pStmt);
16685 zSql = sqlite3_mprintf(
16686 "REPLACE INTO temp.sqlite_parameters(key,value)"
16687 "VALUES(%Q,%Q);", zKey, zValue);
16688 if( zSql==0 ) shell_out_of_memory();
16689 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16690 sqlite3_free(zSql);
16691 if( rx!=SQLITE_OK ){
16692 utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
16693 sqlite3_finalize(pStmt);
16698 sqlite3_step(pStmt);
16699 sqlite3_finalize(pStmt);
16702 /* .parameter unset NAME
16703 ** Remove the NAME binding from the parameter binding table, if it
16706 if( nArg==3 && strcmp(azArg[1],"unset")==0 ){
16707 char *zSql = sqlite3_mprintf(
16708 "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]);
16709 if( zSql==0 ) shell_out_of_memory();
16710 sqlite3_exec(p->db, zSql, 0, 0, 0);
16711 sqlite3_free(zSql);
16713 /* If no command name matches, show a syntax error */
16714 parameter_syntax_error:
16715 showHelp(p->out, "parameter");
16718 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
16720 for(i=1; i<nArg; i++){
16721 if( i>1 ) raw_printf(p->out, " ");
16722 utf8_printf(p->out, "%s", azArg[i]);
16724 raw_printf(p->out, "\n");
16727 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
16728 if( c=='p' && n>=3 && strncmp(azArg[0], "progress", n)==0 ){
16731 p->flgProgress = 0;
16734 for(i=1; i<nArg; i++){
16735 const char *z = azArg[i];
16738 if( z[0]=='-' ) z++;
16739 if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){
16740 p->flgProgress |= SHELL_PROGRESS_QUIET;
16743 if( strcmp(z,"reset")==0 ){
16744 p->flgProgress |= SHELL_PROGRESS_RESET;
16747 if( strcmp(z,"once")==0 ){
16748 p->flgProgress |= SHELL_PROGRESS_ONCE;
16751 if( strcmp(z,"limit")==0 ){
16753 utf8_printf(stderr, "Error: missing argument on --limit\n");
16755 goto meta_command_exit;
16757 p->mxProgress = (int)integerValue(azArg[++i]);
16761 utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]);
16763 goto meta_command_exit;
16765 nn = (int)integerValue(z);
16769 sqlite3_progress_handler(p->db, nn, progress_handler, p);
16771 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
16773 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
16775 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
16778 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
16782 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
16786 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
16787 FILE *inSaved = p->in;
16788 int savedLineno = p->lineno;
16790 raw_printf(stderr, "Usage: .read FILE\n");
16792 goto meta_command_exit;
16794 p->in = fopen(azArg[1], "rb");
16796 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
16799 rc = process_input(p);
16803 p->lineno = savedLineno;
16806 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
16807 const char *zSrcFile;
16810 sqlite3_backup *pBackup;
16814 zSrcFile = azArg[1];
16816 }else if( nArg==3 ){
16817 zSrcFile = azArg[2];
16820 raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
16822 goto meta_command_exit;
16824 rc = sqlite3_open(zSrcFile, &pSrc);
16825 if( rc!=SQLITE_OK ){
16826 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
16831 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
16833 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16837 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
16838 || rc==SQLITE_BUSY ){
16839 if( rc==SQLITE_BUSY ){
16840 if( nTimeout++ >= 3 ) break;
16841 sqlite3_sleep(100);
16844 sqlite3_backup_finish(pBackup);
16845 if( rc==SQLITE_DONE ){
16847 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
16848 raw_printf(stderr, "Error: source database is busy\n");
16851 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16857 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
16859 p->scanstatsOn = (u8)booleanValue(azArg[1]);
16860 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
16861 raw_printf(stderr, "Warning: .scanstats not available in this build.\n");
16864 raw_printf(stderr, "Usage: .scanstats on|off\n");
16869 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
16873 const char *zDiv = "(";
16874 const char *zName = 0;
16880 memcpy(&data, p, sizeof(data));
16881 data.showHeader = 0;
16882 data.cMode = data.mode = MODE_Semi;
16883 initText(&sSelect);
16884 for(ii=1; ii<nArg; ii++){
16885 if( optionMatch(azArg[ii],"indent") ){
16886 data.cMode = data.mode = MODE_Pretty;
16887 }else if( optionMatch(azArg[ii],"debug") ){
16889 }else if( zName==0 ){
16892 raw_printf(stderr, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n");
16894 goto meta_command_exit;
16898 int isMaster = sqlite3_strlike(zName, "sqlite_master", '\\')==0;
16899 if( isMaster || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0 ){
16900 char *new_argv[2], *new_colv[2];
16901 new_argv[0] = sqlite3_mprintf(
16902 "CREATE TABLE %s (\n"
16905 " tbl_name text,\n"
16906 " rootpage integer,\n"
16908 ")", isMaster ? "sqlite_master" : "sqlite_temp_master");
16910 new_colv[0] = "sql";
16912 callback(&data, 1, new_argv, new_colv);
16913 sqlite3_free(new_argv[0]);
16917 sqlite3_stmt *pStmt = 0;
16918 rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
16921 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16922 sqlite3_finalize(pStmt);
16924 goto meta_command_exit;
16926 appendText(&sSelect, "SELECT sql FROM", 0);
16928 while( sqlite3_step(pStmt)==SQLITE_ROW ){
16929 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0);
16931 sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema);
16932 appendText(&sSelect, zDiv, 0);
16933 zDiv = " UNION ALL ";
16934 appendText(&sSelect, "SELECT shell_add_schema(sql,", 0);
16935 if( sqlite3_stricmp(zDb, "main")!=0 ){
16936 appendText(&sSelect, zDb, '"');
16938 appendText(&sSelect, "NULL", 0);
16940 appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0);
16941 appendText(&sSelect, zScNum, 0);
16942 appendText(&sSelect, " AS snum, ", 0);
16943 appendText(&sSelect, zDb, '\'');
16944 appendText(&sSelect, " AS sname FROM ", 0);
16945 appendText(&sSelect, zDb, '"');
16946 appendText(&sSelect, ".sqlite_master", 0);
16948 sqlite3_finalize(pStmt);
16949 #ifdef SQLITE_INTROSPECTION_PRAGMAS
16951 appendText(&sSelect,
16952 " UNION ALL SELECT shell_module_schema(name),"
16953 " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list", 0);
16956 appendText(&sSelect, ") WHERE ", 0);
16958 char *zQarg = sqlite3_mprintf("%Q", zName);
16959 int bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 ||
16960 strchr(zName, '[') != 0;
16961 if( strchr(zName, '.') ){
16962 appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0);
16964 appendText(&sSelect, "lower(tbl_name)", 0);
16966 appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0);
16967 appendText(&sSelect, zQarg, 0);
16969 appendText(&sSelect, " ESCAPE '\\' ", 0);
16971 appendText(&sSelect, " AND ", 0);
16972 sqlite3_free(zQarg);
16974 appendText(&sSelect, "type!='meta' AND sql IS NOT NULL"
16975 " ORDER BY snum, rowid", 0);
16977 utf8_printf(p->out, "SQL: %s;\n", sSelect.z);
16979 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
16981 freeText(&sSelect);
16984 utf8_printf(stderr,"Error: %s\n", zErrMsg);
16985 sqlite3_free(zErrMsg);
16987 }else if( rc != SQLITE_OK ){
16988 raw_printf(stderr,"Error: querying schema information\n");
16995 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
16996 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
16997 sqlite3SelectTrace = (int)integerValue(azArg[1]);
17001 #if defined(SQLITE_ENABLE_SESSION)
17002 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){
17003 OpenSession *pSession = &p->aSession[0];
17004 char **azCmd = &azArg[1];
17006 int nCmd = nArg - 1;
17008 if( nArg<=1 ) goto session_syntax_error;
17011 for(iSes=0; iSes<p->nSession; iSes++){
17012 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break;
17014 if( iSes<p->nSession ){
17015 pSession = &p->aSession[iSes];
17019 pSession = &p->aSession[0];
17024 /* .session attach TABLE
17025 ** Invoke the sqlite3session_attach() interface to attach a particular
17026 ** table so that it is never filtered.
17028 if( strcmp(azCmd[0],"attach")==0 ){
17029 if( nCmd!=2 ) goto session_syntax_error;
17030 if( pSession->p==0 ){
17032 raw_printf(stderr, "ERROR: No sessions are open\n");
17034 rc = sqlite3session_attach(pSession->p, azCmd[1]);
17036 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc);
17042 /* .session changeset FILE
17043 ** .session patchset FILE
17044 ** Write a changeset or patchset into a file. The file is overwritten.
17046 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){
17048 if( nCmd!=2 ) goto session_syntax_error;
17049 if( pSession->p==0 ) goto session_not_open;
17050 out = fopen(azCmd[1], "wb");
17052 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n", azCmd[1]);
17056 if( azCmd[0][0]=='c' ){
17057 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
17059 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
17062 printf("Error: error code %d\n", rc);
17066 && fwrite(pChng, szChng, 1, out)!=1 ){
17067 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n",
17070 sqlite3_free(pChng);
17076 ** Close the identified session
17078 if( strcmp(azCmd[0], "close")==0 ){
17079 if( nCmd!=1 ) goto session_syntax_error;
17081 session_close(pSession);
17082 p->aSession[iSes] = p->aSession[--p->nSession];
17086 /* .session enable ?BOOLEAN?
17087 ** Query or set the enable flag
17089 if( strcmp(azCmd[0], "enable")==0 ){
17091 if( nCmd>2 ) goto session_syntax_error;
17092 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
17094 ii = sqlite3session_enable(pSession->p, ii);
17095 utf8_printf(p->out, "session %s enable flag = %d\n",
17096 pSession->zName, ii);
17100 /* .session filter GLOB ....
17101 ** Set a list of GLOB patterns of table names to be excluded.
17103 if( strcmp(azCmd[0], "filter")==0 ){
17105 if( nCmd<2 ) goto session_syntax_error;
17107 for(ii=0; ii<pSession->nFilter; ii++){
17108 sqlite3_free(pSession->azFilter[ii]);
17110 sqlite3_free(pSession->azFilter);
17111 nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
17112 pSession->azFilter = sqlite3_malloc( nByte );
17113 if( pSession->azFilter==0 ){
17114 raw_printf(stderr, "Error: out or memory\n");
17117 for(ii=1; ii<nCmd; ii++){
17118 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
17120 pSession->nFilter = ii-1;
17124 /* .session indirect ?BOOLEAN?
17125 ** Query or set the indirect flag
17127 if( strcmp(azCmd[0], "indirect")==0 ){
17129 if( nCmd>2 ) goto session_syntax_error;
17130 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
17132 ii = sqlite3session_indirect(pSession->p, ii);
17133 utf8_printf(p->out, "session %s indirect flag = %d\n",
17134 pSession->zName, ii);
17138 /* .session isempty
17139 ** Determine if the session is empty
17141 if( strcmp(azCmd[0], "isempty")==0 ){
17143 if( nCmd!=1 ) goto session_syntax_error;
17145 ii = sqlite3session_isempty(pSession->p);
17146 utf8_printf(p->out, "session %s isempty flag = %d\n",
17147 pSession->zName, ii);
17152 ** List all currently open sessions
17154 if( strcmp(azCmd[0],"list")==0 ){
17155 for(i=0; i<p->nSession; i++){
17156 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName);
17160 /* .session open DB NAME
17161 ** Open a new session called NAME on the attached database DB.
17162 ** DB is normally "main".
17164 if( strcmp(azCmd[0],"open")==0 ){
17166 if( nCmd!=3 ) goto session_syntax_error;
17168 if( zName[0]==0 ) goto session_syntax_error;
17169 for(i=0; i<p->nSession; i++){
17170 if( strcmp(p->aSession[i].zName,zName)==0 ){
17171 utf8_printf(stderr, "Session \"%s\" already exists\n", zName);
17172 goto meta_command_exit;
17175 if( p->nSession>=ArraySize(p->aSession) ){
17176 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession));
17177 goto meta_command_exit;
17179 pSession = &p->aSession[p->nSession];
17180 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
17182 raw_printf(stderr, "Cannot open session: error code=%d\n", rc);
17184 goto meta_command_exit;
17186 pSession->nFilter = 0;
17187 sqlite3session_table_filter(pSession->p, session_filter, pSession);
17189 pSession->zName = sqlite3_mprintf("%s", zName);
17191 /* If no command name matches, show a syntax error */
17192 session_syntax_error:
17193 showHelp(p->out, "session");
17197 #ifdef SQLITE_DEBUG
17198 /* Undocumented commands for internal testing. Subject to change
17199 ** without notice. */
17200 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
17201 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
17203 for(i=1; i<nArg; i++){
17204 v = booleanValue(azArg[i]);
17205 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
17208 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
17209 int i; sqlite3_int64 v;
17210 for(i=1; i<nArg; i++){
17212 v = integerValue(azArg[i]);
17213 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
17214 utf8_printf(p->out, "%s", zBuf);
17220 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
17221 int bIsInit = 0; /* True to initialize the SELFTEST table */
17222 int bVerbose = 0; /* Verbose output */
17223 int bSelftestExists; /* True if SELFTEST already exists */
17224 int i, k; /* Loop counters */
17225 int nTest = 0; /* Number of tests runs */
17226 int nErr = 0; /* Number of errors seen */
17227 ShellText str; /* Answer for a query */
17228 sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */
17231 for(i=1; i<nArg; i++){
17232 const char *z = azArg[i];
17233 if( z[0]=='-' && z[1]=='-' ) z++;
17234 if( strcmp(z,"-init")==0 ){
17237 if( strcmp(z,"-v")==0 ){
17241 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
17242 azArg[i], azArg[0]);
17243 raw_printf(stderr, "Should be one of: --init -v\n");
17245 goto meta_command_exit;
17248 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
17250 bSelftestExists = 0;
17252 bSelftestExists = 1;
17255 createSelftestTable(p);
17256 bSelftestExists = 1;
17259 appendText(&str, "x", 0);
17260 for(k=bSelftestExists; k>=0; k--){
17262 rc = sqlite3_prepare_v2(p->db,
17263 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
17266 rc = sqlite3_prepare_v2(p->db,
17267 "VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
17268 " (1,'run','PRAGMA integrity_check','ok')",
17272 raw_printf(stderr, "Error querying the selftest table\n");
17274 sqlite3_finalize(pStmt);
17275 goto meta_command_exit;
17277 for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
17278 int tno = sqlite3_column_int(pStmt, 0);
17279 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1);
17280 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2);
17281 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3);
17285 char *zQuote = sqlite3_mprintf("%q", zSql);
17286 printf("%d: %s %s\n", tno, zOp, zSql);
17287 sqlite3_free(zQuote);
17289 if( strcmp(zOp,"memo")==0 ){
17290 utf8_printf(p->out, "%s\n", zSql);
17292 if( strcmp(zOp,"run")==0 ){
17296 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
17299 utf8_printf(p->out, "Result: %s\n", str.z);
17301 if( rc || zErrMsg ){
17304 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
17305 sqlite3_free(zErrMsg);
17306 }else if( strcmp(zAns,str.z)!=0 ){
17309 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
17310 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
17314 utf8_printf(stderr,
17315 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
17319 } /* End loop over rows of content from SELFTEST */
17320 sqlite3_finalize(pStmt);
17321 } /* End loop over k */
17323 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
17326 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
17327 if( nArg<2 || nArg>3 ){
17328 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
17332 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
17333 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
17336 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
17337 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
17341 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
17342 const char *zLike = 0; /* Which table to checksum. 0 means everything */
17343 int i; /* Loop counter */
17344 int bSchema = 0; /* Also hash the schema */
17345 int bSeparate = 0; /* Hash each table separately */
17346 int iSize = 224; /* Hash algorithm to use */
17347 int bDebug = 0; /* Only show the query that would have run */
17348 sqlite3_stmt *pStmt; /* For querying tables names */
17349 char *zSql; /* SQL to be run */
17350 char *zSep; /* Separator */
17351 ShellText sSql; /* Complete SQL for the query to run the hash */
17352 ShellText sQuery; /* Set of queries used to read all content */
17354 for(i=1; i<nArg; i++){
17355 const char *z = azArg[i];
17358 if( z[0]=='-' ) z++;
17359 if( strcmp(z,"schema")==0 ){
17362 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
17363 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
17365 iSize = atoi(&z[5]);
17367 if( strcmp(z,"debug")==0 ){
17371 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
17372 azArg[i], azArg[0]);
17373 raw_printf(stderr, "Should be one of: --schema"
17374 " --sha3-224 --sha3-256 --sha3-384 --sha3-512\n");
17376 goto meta_command_exit;
17379 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
17381 goto meta_command_exit;
17385 if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1;
17389 zSql = "SELECT lower(name) FROM sqlite_master"
17390 " WHERE type='table' AND coalesce(rootpage,0)>1"
17391 " UNION ALL SELECT 'sqlite_master'"
17392 " ORDER BY 1 collate nocase";
17394 zSql = "SELECT lower(name) FROM sqlite_master"
17395 " WHERE type='table' AND coalesce(rootpage,0)>1"
17396 " AND name NOT LIKE 'sqlite_%'"
17397 " ORDER BY 1 collate nocase";
17399 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
17402 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
17404 while( SQLITE_ROW==sqlite3_step(pStmt) ){
17405 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
17406 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
17407 if( strncmp(zTab, "sqlite_",7)!=0 ){
17408 appendText(&sQuery,"SELECT * FROM ", 0);
17409 appendText(&sQuery,zTab,'"');
17410 appendText(&sQuery," NOT INDEXED;", 0);
17411 }else if( strcmp(zTab, "sqlite_master")==0 ){
17412 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
17413 " ORDER BY name;", 0);
17414 }else if( strcmp(zTab, "sqlite_sequence")==0 ){
17415 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
17416 " ORDER BY name;", 0);
17417 }else if( strcmp(zTab, "sqlite_stat1")==0 ){
17418 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
17419 " ORDER BY tbl,idx;", 0);
17420 }else if( strcmp(zTab, "sqlite_stat3")==0
17421 || strcmp(zTab, "sqlite_stat4")==0 ){
17422 appendText(&sQuery, "SELECT * FROM ", 0);
17423 appendText(&sQuery, zTab, 0);
17424 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
17426 appendText(&sSql, zSep, 0);
17427 appendText(&sSql, sQuery.z, '\'');
17429 appendText(&sSql, ",", 0);
17430 appendText(&sSql, zTab, '\'');
17433 sqlite3_finalize(pStmt);
17435 zSql = sqlite3_mprintf(
17437 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
17438 " FROM [sha3sum$query]",
17441 zSql = sqlite3_mprintf(
17443 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
17444 " FROM [sha3sum$query]",
17450 utf8_printf(p->out, "%s\n", zSql);
17452 shell_exec(p, zSql, 0);
17454 sqlite3_free(zSql);
17457 #ifndef SQLITE_NOHAVE_SYSTEM
17459 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
17464 raw_printf(stderr, "Usage: .system COMMAND\n");
17466 goto meta_command_exit;
17468 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
17469 for(i=2; i<nArg; i++){
17470 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
17474 sqlite3_free(zCmd);
17475 if( x ) raw_printf(stderr, "System command returns %d\n", x);
17477 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
17479 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
17480 static const char *azBool[] = { "off", "on", "trigger", "full"};
17483 raw_printf(stderr, "Usage: .show\n");
17485 goto meta_command_exit;
17487 utf8_printf(p->out, "%12.12s: %s\n","echo",
17488 azBool[ShellHasFlag(p, SHFLG_Echo)]);
17489 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
17490 utf8_printf(p->out, "%12.12s: %s\n","explain",
17491 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
17492 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
17493 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
17494 utf8_printf(p->out, "%12.12s: ", "nullvalue");
17495 output_c_string(p->out, p->nullValue);
17496 raw_printf(p->out, "\n");
17497 utf8_printf(p->out,"%12.12s: %s\n","output",
17498 strlen30(p->outfile) ? p->outfile : "stdout");
17499 utf8_printf(p->out,"%12.12s: ", "colseparator");
17500 output_c_string(p->out, p->colSeparator);
17501 raw_printf(p->out, "\n");
17502 utf8_printf(p->out,"%12.12s: ", "rowseparator");
17503 output_c_string(p->out, p->rowSeparator);
17504 raw_printf(p->out, "\n");
17505 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]);
17506 utf8_printf(p->out, "%12.12s: ", "width");
17507 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
17508 raw_printf(p->out, "%d ", p->colWidth[i]);
17510 raw_printf(p->out, "\n");
17511 utf8_printf(p->out, "%12.12s: %s\n", "filename",
17512 p->zDbFilename ? p->zDbFilename : "");
17515 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
17517 p->statsOn = (u8)booleanValue(azArg[1]);
17518 }else if( nArg==1 ){
17519 display_stats(p->db, p, 0);
17521 raw_printf(stderr, "Usage: .stats ?on|off?\n");
17526 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0)
17527 || (c=='i' && (strncmp(azArg[0], "indices", n)==0
17528 || strncmp(azArg[0], "indexes", n)==0) )
17530 sqlite3_stmt *pStmt;
17537 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
17539 sqlite3_finalize(pStmt);
17540 return shellDatabaseError(p->db);
17543 if( nArg>2 && c=='i' ){
17544 /* It is an historical accident that the .indexes command shows an error
17545 ** when called with the wrong number of arguments whereas the .tables
17546 ** command does not. */
17547 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
17549 sqlite3_finalize(pStmt);
17550 goto meta_command_exit;
17552 for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
17553 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
17554 if( zDbName==0 ) continue;
17555 if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0);
17556 if( sqlite3_stricmp(zDbName, "main")==0 ){
17557 appendText(&s, "SELECT name FROM ", 0);
17559 appendText(&s, "SELECT ", 0);
17560 appendText(&s, zDbName, '\'');
17561 appendText(&s, "||'.'||name FROM ", 0);
17563 appendText(&s, zDbName, '"');
17564 appendText(&s, ".sqlite_master ", 0);
17566 appendText(&s," WHERE type IN ('table','view')"
17567 " AND name NOT LIKE 'sqlite_%'"
17568 " AND name LIKE ?1", 0);
17570 appendText(&s," WHERE type='index'"
17571 " AND tbl_name LIKE ?1", 0);
17574 rc = sqlite3_finalize(pStmt);
17575 appendText(&s, " ORDER BY 1", 0);
17576 rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0);
17578 if( rc ) return shellDatabaseError(p->db);
17580 /* Run the SQL statement prepared by the above block. Store the results
17581 ** as an array of nul-terminated strings in azResult[]. */
17585 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
17587 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
17589 while( sqlite3_step(pStmt)==SQLITE_ROW ){
17590 if( nRow>=nAlloc ){
17592 int n2 = nAlloc*2 + 10;
17593 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
17594 if( azNew==0 ) shell_out_of_memory();
17598 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
17599 if( 0==azResult[nRow] ) shell_out_of_memory();
17602 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
17603 rc = shellDatabaseError(p->db);
17606 /* Pretty-print the contents of array azResult[] to the output */
17607 if( rc==0 && nRow>0 ){
17608 int len, maxlen = 0;
17610 int nPrintCol, nPrintRow;
17611 for(i=0; i<nRow; i++){
17612 len = strlen30(azResult[i]);
17613 if( len>maxlen ) maxlen = len;
17615 nPrintCol = 80/(maxlen+2);
17616 if( nPrintCol<1 ) nPrintCol = 1;
17617 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
17618 for(i=0; i<nPrintRow; i++){
17619 for(j=i; j<nRow; j+=nPrintRow){
17620 char *zSp = j<nPrintRow ? "" : " ";
17621 utf8_printf(p->out, "%s%-*s", zSp, maxlen,
17622 azResult[j] ? azResult[j]:"");
17624 raw_printf(p->out, "\n");
17628 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
17629 sqlite3_free(azResult);
17632 /* Begin redirecting output to the file "testcase-out.txt" */
17633 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){
17635 p->out = output_file_open("testcase-out.txt", 0);
17637 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n");
17640 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
17642 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
17646 #ifndef SQLITE_UNTESTABLE
17647 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 ){
17648 static const struct {
17649 const char *zCtrlName; /* Name of a test-control option */
17650 int ctrlCode; /* Integer code for that option */
17651 const char *zUsage; /* Usage notes */
17653 { "always", SQLITE_TESTCTRL_ALWAYS, "BOOLEAN" },
17654 { "assert", SQLITE_TESTCTRL_ASSERT, "BOOLEAN" },
17655 /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, "" },*/
17656 /*{ "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST, "" },*/
17657 { "byteorder", SQLITE_TESTCTRL_BYTEORDER, "" },
17658 /*{ "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL, "" }, */
17659 { "imposter", SQLITE_TESTCTRL_IMPOSTER, "SCHEMA ON/OFF ROOTPAGE"},
17660 { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "BOOLEAN" },
17661 { "localtime_fault", SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN" },
17662 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN" },
17663 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK" },
17665 { "parser_coverage", SQLITE_TESTCTRL_PARSER_COVERAGE, "" },
17667 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE, "OFFSET " },
17668 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET, "" },
17669 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE, "" },
17670 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE, "" },
17671 { "reserve", SQLITE_TESTCTRL_RESERVE, "BYTES-OF-RESERVE" },
17675 int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */
17678 const char *zCmd = 0;
17681 zCmd = nArg>=2 ? azArg[1] : "help";
17683 /* The argument can optionally begin with "-" or "--" */
17684 if( zCmd[0]=='-' && zCmd[1] ){
17686 if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
17689 /* --help lists all test-controls */
17690 if( strcmp(zCmd,"help")==0 ){
17691 utf8_printf(p->out, "Available test-controls:\n");
17692 for(i=0; i<ArraySize(aCtrl); i++){
17693 utf8_printf(p->out, " .testctrl %s %s\n",
17694 aCtrl[i].zCtrlName, aCtrl[i].zUsage);
17697 goto meta_command_exit;
17700 /* convert testctrl text option to value. allow any unique prefix
17701 ** of the option name, or a numerical value. */
17702 n2 = strlen30(zCmd);
17703 for(i=0; i<ArraySize(aCtrl); i++){
17704 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
17706 testctrl = aCtrl[i].ctrlCode;
17709 utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n"
17710 "Use \".testctrl --help\" for help\n", zCmd);
17712 goto meta_command_exit;
17717 utf8_printf(stderr,"Error: unknown test-control: %s\n"
17718 "Use \".testctrl --help\" for help\n", zCmd);
17722 /* sqlite3_test_control(int, db, int) */
17723 case SQLITE_TESTCTRL_OPTIMIZATIONS:
17724 case SQLITE_TESTCTRL_RESERVE:
17726 int opt = (int)strtol(azArg[2], 0, 0);
17727 rc2 = sqlite3_test_control(testctrl, p->db, opt);
17732 /* sqlite3_test_control(int) */
17733 case SQLITE_TESTCTRL_PRNG_SAVE:
17734 case SQLITE_TESTCTRL_PRNG_RESTORE:
17735 case SQLITE_TESTCTRL_PRNG_RESET:
17736 case SQLITE_TESTCTRL_BYTEORDER:
17738 rc2 = sqlite3_test_control(testctrl);
17739 isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3;
17743 /* sqlite3_test_control(int, uint) */
17744 case SQLITE_TESTCTRL_PENDING_BYTE:
17746 unsigned int opt = (unsigned int)integerValue(azArg[2]);
17747 rc2 = sqlite3_test_control(testctrl, opt);
17752 /* sqlite3_test_control(int, int) */
17753 case SQLITE_TESTCTRL_ASSERT:
17754 case SQLITE_TESTCTRL_ALWAYS:
17755 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS:
17757 int opt = booleanValue(azArg[2]);
17758 rc2 = sqlite3_test_control(testctrl, opt);
17763 /* sqlite3_test_control(int, int) */
17764 case SQLITE_TESTCTRL_LOCALTIME_FAULT:
17765 case SQLITE_TESTCTRL_NEVER_CORRUPT:
17767 int opt = booleanValue(azArg[2]);
17768 rc2 = sqlite3_test_control(testctrl, opt);
17773 case SQLITE_TESTCTRL_IMPOSTER:
17775 rc2 = sqlite3_test_control(testctrl, p->db,
17777 integerValue(azArg[3]),
17778 integerValue(azArg[4]));
17784 case SQLITE_TESTCTRL_PARSER_COVERAGE:
17786 sqlite3_test_control(testctrl, p->out);
17792 if( isOk==0 && iCtrl>=0 ){
17793 utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd, aCtrl[iCtrl].zUsage);
17795 }else if( isOk==1 ){
17796 raw_printf(p->out, "%d\n", rc2);
17797 }else if( isOk==2 ){
17798 raw_printf(p->out, "0x%08x\n", rc2);
17801 #endif /* !defined(SQLITE_UNTESTABLE) */
17803 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
17805 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
17808 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
17810 enableTimer = booleanValue(azArg[1]);
17811 if( enableTimer && !HAS_TIMER ){
17812 raw_printf(stderr, "Error: timer not available on this system.\n");
17816 raw_printf(stderr, "Usage: .timer on|off\n");
17821 #ifndef SQLITE_OMIT_TRACE
17822 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
17826 for(jj=1; jj<nArg; jj++){
17827 const char *z = azArg[jj];
17829 if( optionMatch(z, "expanded") ){
17830 p->eTraceType = SHELL_TRACE_EXPANDED;
17832 #ifdef SQLITE_ENABLE_NORMALIZE
17833 else if( optionMatch(z, "normalized") ){
17834 p->eTraceType = SHELL_TRACE_NORMALIZED;
17837 else if( optionMatch(z, "plain") ){
17838 p->eTraceType = SHELL_TRACE_PLAIN;
17840 else if( optionMatch(z, "profile") ){
17841 mType |= SQLITE_TRACE_PROFILE;
17843 else if( optionMatch(z, "row") ){
17844 mType |= SQLITE_TRACE_ROW;
17846 else if( optionMatch(z, "stmt") ){
17847 mType |= SQLITE_TRACE_STMT;
17849 else if( optionMatch(z, "close") ){
17850 mType |= SQLITE_TRACE_CLOSE;
17853 raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z);
17855 goto meta_command_exit;
17858 output_file_close(p->traceOut);
17859 p->traceOut = output_file_open(azArg[1], 0);
17862 if( p->traceOut==0 ){
17863 sqlite3_trace_v2(p->db, 0, 0, 0);
17865 if( mType==0 ) mType = SQLITE_TRACE_STMT;
17866 sqlite3_trace_v2(p->db, mType, sql_trace_callback, p);
17869 #endif /* !defined(SQLITE_OMIT_TRACE) */
17871 #if SQLITE_USER_AUTHENTICATION
17872 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
17874 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
17876 goto meta_command_exit;
17879 if( strcmp(azArg[1],"login")==0 ){
17881 raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
17883 goto meta_command_exit;
17885 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3], strlen30(azArg[3]));
17887 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
17890 }else if( strcmp(azArg[1],"add")==0 ){
17892 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
17894 goto meta_command_exit;
17896 rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
17897 booleanValue(azArg[4]));
17899 raw_printf(stderr, "User-Add failed: %d\n", rc);
17902 }else if( strcmp(azArg[1],"edit")==0 ){
17904 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
17906 goto meta_command_exit;
17908 rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
17909 booleanValue(azArg[4]));
17911 raw_printf(stderr, "User-Edit failed: %d\n", rc);
17914 }else if( strcmp(azArg[1],"delete")==0 ){
17916 raw_printf(stderr, "Usage: .user delete USER\n");
17918 goto meta_command_exit;
17920 rc = sqlite3_user_delete(p->db, azArg[2]);
17922 raw_printf(stderr, "User-Delete failed: %d\n", rc);
17926 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n");
17928 goto meta_command_exit;
17931 #endif /* SQLITE_USER_AUTHENTICATION */
17933 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
17934 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
17935 sqlite3_libversion(), sqlite3_sourceid());
17936 #if SQLITE_HAVE_ZLIB
17937 utf8_printf(p->out, "zlib version %s\n", zlibVersion());
17939 #define CTIMEOPT_VAL_(opt) #opt
17940 #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
17941 #if defined(__clang__) && defined(__clang_major__)
17942 utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "."
17943 CTIMEOPT_VAL(__clang_minor__) "."
17944 CTIMEOPT_VAL(__clang_patchlevel__) "\n");
17945 #elif defined(_MSC_VER)
17946 utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) "\n");
17947 #elif defined(__GNUC__) && defined(__VERSION__)
17948 utf8_printf(p->out, "gcc-" __VERSION__ "\n");
17952 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){
17953 const char *zDbName = nArg==2 ? azArg[1] : "main";
17954 sqlite3_vfs *pVfs = 0;
17956 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
17958 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName);
17959 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
17960 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
17961 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
17966 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){
17968 sqlite3_vfs *pCurrent = 0;
17970 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
17972 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
17973 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName,
17974 pVfs==pCurrent ? " <--- CURRENT" : "");
17975 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
17976 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
17977 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
17979 raw_printf(p->out, "-----------------------------------\n");
17984 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
17985 const char *zDbName = nArg==2 ? azArg[1] : "main";
17986 char *zVfsName = 0;
17988 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
17990 utf8_printf(p->out, "%s\n", zVfsName);
17991 sqlite3_free(zVfsName);
17996 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
17997 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
17998 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
18002 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
18004 assert( nArg<=ArraySize(azArg) );
18005 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
18006 p->colWidth[j-1] = (int)integerValue(azArg[j]);
18011 utf8_printf(stderr, "Error: unknown command or invalid arguments: "
18012 " \"%s\". Enter \".help\" for help\n", azArg[0]);
18019 if( p->outCount==0 ) output_reset(p);
18025 ** Return TRUE if a semicolon occurs anywhere in the first N characters
18028 static int line_contains_semicolon(const char *z, int N){
18030 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
18035 ** Test to see if a line consists entirely of whitespace.
18037 static int _all_whitespace(const char *z){
18039 if( IsSpace(z[0]) ) continue;
18040 if( *z=='/' && z[1]=='*' ){
18042 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
18043 if( *z==0 ) return 0;
18047 if( *z=='-' && z[1]=='-' ){
18049 while( *z && *z!='\n' ){ z++; }
18050 if( *z==0 ) return 1;
18059 ** Return TRUE if the line typed in is an SQL command terminator other
18060 ** than a semi-colon. The SQL Server style "go" command is understood
18061 ** as is the Oracle "/".
18063 static int line_is_command_terminator(const char *zLine){
18064 while( IsSpace(zLine[0]) ){ zLine++; };
18065 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
18066 return 1; /* Oracle */
18068 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
18069 && _all_whitespace(&zLine[2]) ){
18070 return 1; /* SQL Server */
18076 ** We need a default sqlite3_complete() implementation to use in case
18077 ** the shell is compiled with SQLITE_OMIT_COMPLETE. The default assumes
18078 ** any arbitrary text is a complete SQL statement. This is not very
18079 ** user-friendly, but it does seem to work.
18081 #ifdef SQLITE_OMIT_COMPLETE
18082 #define sqlite3_complete(x) 1
18086 ** Return true if zSql is a complete SQL statement. Return false if it
18087 ** ends in the middle of a string literal or C-style comment.
18089 static int line_is_complete(char *zSql, int nSql){
18091 if( zSql==0 ) return 1;
18094 rc = sqlite3_complete(zSql);
18100 ** Run a single line of SQL. Return the number of errors.
18102 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
18107 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
18108 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
18110 rc = shell_exec(p, zSql, &zErrMsg);
18112 if( rc || zErrMsg ){
18114 if( in!=0 || !stdin_is_interactive ){
18115 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
18116 "Error: near line %d:", startline);
18118 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
18121 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg);
18122 sqlite3_free(zErrMsg);
18125 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
18128 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
18129 raw_printf(p->out, "changes: %3d total_changes: %d\n",
18130 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
18137 ** Read input from *in and process it. If *in==0 then input
18138 ** is interactive - the user is typing it it. Otherwise, input
18139 ** is coming from a file or device. A prompt is issued and history
18140 ** is saved only if input is interactive. An interrupt signal will
18141 ** cause this routine to exit immediately, unless input is interactive.
18143 ** Return the number of errors.
18145 static int process_input(ShellState *p){
18146 char *zLine = 0; /* A single input line */
18147 char *zSql = 0; /* Accumulated SQL text */
18148 int nLine; /* Length of current line */
18149 int nSql = 0; /* Bytes of zSql[] used */
18150 int nAlloc = 0; /* Allocated zSql[] space */
18151 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
18152 int rc; /* Error code */
18153 int errCnt = 0; /* Number of errors seen */
18154 int startline = 0; /* Line number for start of current input */
18157 while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){
18159 zLine = one_input_line(p->in, zLine, nSql>0);
18162 if( p->in==0 && stdin_is_interactive ) printf("\n");
18165 if( seenInterrupt ){
18166 if( p->in!=0 ) break;
18170 if( nSql==0 && _all_whitespace(zLine) ){
18171 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
18174 if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){
18175 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
18176 if( zLine[0]=='.' ){
18177 rc = do_meta_command(zLine, p);
18178 if( rc==2 ){ /* exit requested */
18186 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
18187 memcpy(zLine,";",2);
18189 nLine = strlen30(zLine);
18190 if( nSql+nLine+2>=nAlloc ){
18191 nAlloc = nSql+nLine+100;
18192 zSql = realloc(zSql, nAlloc);
18193 if( zSql==0 ) shell_out_of_memory();
18198 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
18199 assert( nAlloc>0 && zSql!=0 );
18200 memcpy(zSql, zLine+i, nLine+1-i);
18201 startline = p->lineno;
18204 zSql[nSql++] = '\n';
18205 memcpy(zSql+nSql, zLine, nLine+1);
18208 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
18209 && sqlite3_complete(zSql) ){
18210 errCnt += runOneSqlLine(p, zSql, p->in, startline);
18218 }else if( nSql && _all_whitespace(zSql) ){
18219 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
18223 if( nSql && !_all_whitespace(zSql) ){
18224 errCnt += runOneSqlLine(p, zSql, p->in, startline);
18232 ** Return a pathname which is the user's home directory. A
18233 ** 0 return indicates an error of some kind.
18235 static char *find_home_dir(int clearFlag){
18236 static char *home_dir = NULL;
18242 if( home_dir ) return home_dir;
18244 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
18245 && !defined(__RTP__) && !defined(_WRS_KERNEL)
18247 struct passwd *pwent;
18248 uid_t uid = getuid();
18249 if( (pwent=getpwuid(uid)) != NULL) {
18250 home_dir = pwent->pw_dir;
18255 #if defined(_WIN32_WCE)
18256 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
18261 #if defined(_WIN32) || defined(WIN32)
18263 home_dir = getenv("USERPROFILE");
18268 home_dir = getenv("HOME");
18271 #if defined(_WIN32) || defined(WIN32)
18273 char *zDrive, *zPath;
18275 zDrive = getenv("HOMEDRIVE");
18276 zPath = getenv("HOMEPATH");
18277 if( zDrive && zPath ){
18278 n = strlen30(zDrive) + strlen30(zPath) + 1;
18279 home_dir = malloc( n );
18280 if( home_dir==0 ) return 0;
18281 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
18288 #endif /* !_WIN32_WCE */
18291 int n = strlen30(home_dir) + 1;
18292 char *z = malloc( n );
18293 if( z ) memcpy(z, home_dir, n);
18301 ** Read input from the file given by sqliterc_override. Or if that
18302 ** parameter is NULL, take input from ~/.sqliterc
18304 ** Returns the number of errors.
18306 static void process_sqliterc(
18307 ShellState *p, /* Configuration data */
18308 const char *sqliterc_override /* Name of config file. NULL to use default */
18310 char *home_dir = NULL;
18311 const char *sqliterc = sqliterc_override;
18313 FILE *inSaved = p->in;
18314 int savedLineno = p->lineno;
18316 if (sqliterc == NULL) {
18317 home_dir = find_home_dir(0);
18319 raw_printf(stderr, "-- warning: cannot find home directory;"
18320 " cannot read ~/.sqliterc\n");
18323 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
18326 p->in = fopen(sqliterc,"rb");
18328 if( stdin_is_interactive ){
18329 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
18335 p->lineno = savedLineno;
18336 sqlite3_free(zBuf);
18340 ** Show available command line options
18342 static const char zOptions[] =
18343 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
18344 " -A ARGS... run \".archive ARGS\" and exit\n"
18346 " -append append the database to the end of the file\n"
18347 " -ascii set output mode to 'ascii'\n"
18348 " -bail stop after hitting an error\n"
18349 " -batch force batch I/O\n"
18350 " -column set output mode to 'column'\n"
18351 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
18352 " -csv set output mode to 'csv'\n"
18353 #if defined(SQLITE_ENABLE_DESERIALIZE)
18354 " -deserialize open the database using sqlite3_deserialize()\n"
18356 " -echo print commands before execution\n"
18357 " -init FILENAME read/process named file\n"
18358 " -[no]header turn headers on or off\n"
18359 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
18360 " -heap SIZE Size of heap for memsys3 or memsys5\n"
18362 " -help show this message\n"
18363 " -html set output mode to HTML\n"
18364 " -interactive force interactive I/O\n"
18365 " -line set output mode to 'line'\n"
18366 " -list set output mode to 'list'\n"
18367 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
18368 #if defined(SQLITE_ENABLE_DESERIALIZE)
18369 " -maxsize N maximum size for a --deserialize database\n"
18371 " -memtrace trace all memory allocations and deallocations\n"
18372 " -mmap N default mmap size set to N\n"
18373 #ifdef SQLITE_ENABLE_MULTIPLEX
18374 " -multiplex enable the multiplexor VFS\n"
18376 " -newline SEP set output row separator. Default: '\\n'\n"
18377 " -nullvalue TEXT set text string for NULL values. Default ''\n"
18378 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
18379 " -quote set output mode to 'quote'\n"
18380 " -readonly open the database read-only\n"
18381 " -separator SEP set output column separator. Default: '|'\n"
18382 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18383 " -sorterref SIZE sorter references threshold size\n"
18385 " -stats print memory stats before each finalize\n"
18386 " -version show SQLite version\n"
18387 " -vfs NAME use NAME as the default VFS\n"
18388 #ifdef SQLITE_ENABLE_VFSTRACE
18389 " -vfstrace enable tracing of all VFS calls\n"
18391 #ifdef SQLITE_HAVE_ZLIB
18392 " -zip open the file as a ZIP Archive\n"
18395 static void usage(int showDetail){
18396 utf8_printf(stderr,
18397 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
18398 "FILENAME is the name of an SQLite database. A new database is created\n"
18399 "if the file does not previously exist.\n", Argv0);
18401 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
18403 raw_printf(stderr, "Use the -help option for additional information\n");
18409 ** Internal check: Verify that the SQLite is uninitialized. Print a
18410 ** error message if it is initialized.
18412 static void verify_uninitialized(void){
18413 if( sqlite3_config(-1)==SQLITE_MISUSE ){
18414 utf8_printf(stdout, "WARNING: attempt to configure SQLite after"
18415 " initialization.\n");
18420 ** Initialize the state information in data
18422 static void main_init(ShellState *data) {
18423 memset(data, 0, sizeof(*data));
18424 data->normalMode = data->cMode = data->mode = MODE_List;
18425 data->autoExplain = 1;
18426 memcpy(data->colSeparator,SEP_Column, 2);
18427 memcpy(data->rowSeparator,SEP_Row, 2);
18428 data->showHeader = 0;
18429 data->shellFlgs = SHFLG_Lookaside;
18430 verify_uninitialized();
18431 sqlite3_config(SQLITE_CONFIG_URI, 1);
18432 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
18433 sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
18434 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
18435 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
18439 ** Output text to the console in a font that attracts extra attention.
18442 static void printBold(const char *zText){
18443 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
18444 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
18445 GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
18446 SetConsoleTextAttribute(out,
18447 FOREGROUND_RED|FOREGROUND_INTENSITY
18449 printf("%s", zText);
18450 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
18453 static void printBold(const char *zText){
18454 printf("\033[1m%s\033[0m", zText);
18459 ** Get the argument to an --option. Throw an error and die if no argument
18462 static char *cmdline_option_value(int argc, char **argv, int i){
18464 utf8_printf(stderr, "%s: Error: missing argument to %s\n",
18465 argv[0], argv[argc-1]);
18471 #ifndef SQLITE_SHELL_IS_UTF8
18472 # if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
18473 # define SQLITE_SHELL_IS_UTF8 (0)
18475 # define SQLITE_SHELL_IS_UTF8 (1)
18479 #if SQLITE_SHELL_IS_UTF8
18480 int SQLITE_CDECL main(int argc, char **argv){
18482 int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
18487 const char *zInitFile = 0;
18490 int warnInmemoryDb = 0;
18494 const char *zVfs = 0; /* Value of -vfs command-line option */
18495 #if !SQLITE_SHELL_IS_UTF8
18496 char **argvToFree = 0;
18497 int argcToFree = 0;
18500 setBinaryMode(stdin, 0);
18501 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
18502 stdin_is_interactive = isatty(0);
18503 stdout_is_console = isatty(1);
18505 #if !defined(_WIN32_WCE)
18506 if( getenv("SQLITE_DEBUG_BREAK") ){
18507 if( isatty(0) && isatty(2) ){
18509 "attach debugger to process %d and press any key to continue.\n",
18513 #if defined(_WIN32) || defined(WIN32)
18515 #elif defined(SIGTRAP)
18522 #if USE_SYSTEM_SQLITE+0!=1
18523 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
18524 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
18525 sqlite3_sourceid(), SQLITE_SOURCE_ID);
18531 /* On Windows, we must translate command-line arguments into UTF-8.
18532 ** The SQLite memory allocator subsystem has to be enabled in order to
18533 ** do this. But we want to run an sqlite3_shutdown() afterwards so that
18534 ** subsequent sqlite3_config() calls will work. So copy all results into
18535 ** memory that does not come from the SQLite memory allocator.
18537 #if !SQLITE_SHELL_IS_UTF8
18538 sqlite3_initialize();
18539 argvToFree = malloc(sizeof(argv[0])*argc*2);
18541 argv = argvToFree + argc;
18542 if( argv==0 ) shell_out_of_memory();
18543 for(i=0; i<argc; i++){
18544 char *z = sqlite3_win32_unicode_to_utf8(wargv[i]);
18546 if( z==0 ) shell_out_of_memory();
18547 n = (int)strlen(z);
18548 argv[i] = malloc( n+1 );
18549 if( argv[i]==0 ) shell_out_of_memory();
18550 memcpy(argv[i], z, n+1);
18551 argvToFree[i] = argv[i];
18554 sqlite3_shutdown();
18557 assert( argc>=1 && argv && argv[0] );
18560 /* Make sure we have a valid signal handler early, before anything
18564 signal(SIGINT, interrupt_handler);
18565 #elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE)
18566 SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
18569 #ifdef SQLITE_SHELL_DBNAME_PROC
18571 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
18572 ** of a C-function that will provide the name of the database file. Use
18573 ** this compile-time option to embed this shell program in larger
18574 ** applications. */
18575 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
18576 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
18577 warnInmemoryDb = 0;
18581 /* Do an initial pass through the command-line argument to locate
18582 ** the name of the database file, the name of the initialization file,
18583 ** the size of the alternative malloc heap,
18584 ** and the first command to execute.
18586 verify_uninitialized();
18587 for(i=1; i<argc; i++){
18591 if( data.zDbFilename==0 ){
18592 data.zDbFilename = z;
18594 /* Excesss arguments are interpreted as SQL (or dot-commands) and
18595 ** mean that nothing is read from stdin */
18598 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
18599 if( azCmd==0 ) shell_out_of_memory();
18603 if( z[1]=='-' ) z++;
18604 if( strcmp(z,"-separator")==0
18605 || strcmp(z,"-nullvalue")==0
18606 || strcmp(z,"-newline")==0
18607 || strcmp(z,"-cmd")==0
18609 (void)cmdline_option_value(argc, argv, ++i);
18610 }else if( strcmp(z,"-init")==0 ){
18611 zInitFile = cmdline_option_value(argc, argv, ++i);
18612 }else if( strcmp(z,"-batch")==0 ){
18613 /* Need to check for batch mode here to so we can avoid printing
18614 ** informational messages (like from process_sqliterc) before
18615 ** we do the actual processing of arguments later in a second pass.
18617 stdin_is_interactive = 0;
18618 }else if( strcmp(z,"-heap")==0 ){
18619 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
18621 sqlite3_int64 szHeap;
18623 zSize = cmdline_option_value(argc, argv, ++i);
18624 szHeap = integerValue(zSize);
18625 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
18626 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
18628 (void)cmdline_option_value(argc, argv, ++i);
18630 }else if( strcmp(z,"-pagecache")==0 ){
18632 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
18633 if( sz>70000 ) sz = 70000;
18635 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
18636 sqlite3_config(SQLITE_CONFIG_PAGECACHE,
18637 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
18638 data.shellFlgs |= SHFLG_Pagecache;
18639 }else if( strcmp(z,"-lookaside")==0 ){
18641 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
18643 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
18645 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
18646 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
18647 #ifdef SQLITE_ENABLE_VFSTRACE
18648 }else if( strcmp(z,"-vfstrace")==0 ){
18649 extern int vfstrace_register(
18650 const char *zTraceName,
18651 const char *zOldVfsName,
18652 int (*xOut)(const char*,void*),
18656 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
18658 #ifdef SQLITE_ENABLE_MULTIPLEX
18659 }else if( strcmp(z,"-multiplex")==0 ){
18660 extern int sqlite3_multiple_initialize(const char*,int);
18661 sqlite3_multiplex_initialize(0, 1);
18663 }else if( strcmp(z,"-mmap")==0 ){
18664 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
18665 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
18666 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18667 }else if( strcmp(z,"-sorterref")==0 ){
18668 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
18669 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz);
18671 }else if( strcmp(z,"-vfs")==0 ){
18672 zVfs = cmdline_option_value(argc, argv, ++i);
18673 #ifdef SQLITE_HAVE_ZLIB
18674 }else if( strcmp(z,"-zip")==0 ){
18675 data.openMode = SHELL_OPEN_ZIPFILE;
18677 }else if( strcmp(z,"-append")==0 ){
18678 data.openMode = SHELL_OPEN_APPENDVFS;
18679 #ifdef SQLITE_ENABLE_DESERIALIZE
18680 }else if( strcmp(z,"-deserialize")==0 ){
18681 data.openMode = SHELL_OPEN_DESERIALIZE;
18682 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){
18683 data.szMax = integerValue(argv[++i]);
18685 }else if( strcmp(z,"-readonly")==0 ){
18686 data.openMode = SHELL_OPEN_READONLY;
18687 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
18688 }else if( strncmp(z, "-A",2)==0 ){
18689 /* All remaining command-line arguments are passed to the ".archive"
18690 ** command, so ignore them */
18693 }else if( strcmp(z, "-memtrace")==0 ){
18694 sqlite3MemTraceActivate(stderr);
18697 verify_uninitialized();
18700 #ifdef SQLITE_SHELL_INIT_PROC
18702 /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name
18703 ** of a C-function that will perform initialization actions on SQLite that
18704 ** occur just before or after sqlite3_initialize(). Use this compile-time
18705 ** option to embed this shell program in larger applications. */
18706 extern void SQLITE_SHELL_INIT_PROC(void);
18707 SQLITE_SHELL_INIT_PROC();
18710 /* All the sqlite3_config() calls have now been made. So it is safe
18711 ** to call sqlite3_initialize() and process any command line -vfs option. */
18712 sqlite3_initialize();
18716 sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
18718 sqlite3_vfs_register(pVfs, 1);
18720 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]);
18725 if( data.zDbFilename==0 ){
18726 #ifndef SQLITE_OMIT_MEMORYDB
18727 data.zDbFilename = ":memory:";
18728 warnInmemoryDb = argc==1;
18730 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
18735 sqlite3_appendvfs_init(0,0,0);
18737 /* Go ahead and open the database file if it already exists. If the
18738 ** file does not exist, delay opening it. This prevents empty database
18739 ** files from being created if a user mistypes the database name argument
18740 ** to the sqlite command-line tool.
18742 if( access(data.zDbFilename, 0)==0 ){
18746 /* Process the initialization file if there is one. If no -init option
18747 ** is given on the command line, look for a file named ~/.sqliterc and
18748 ** try to process it.
18750 process_sqliterc(&data,zInitFile);
18752 /* Make a second pass through the command-line argument and set
18753 ** options. This second pass is delayed until after the initialization
18754 ** file is processed so that the command-line arguments will override
18755 ** settings in the initialization file.
18757 for(i=1; i<argc; i++){
18759 if( z[0]!='-' ) continue;
18760 if( z[1]=='-' ){ z++; }
18761 if( strcmp(z,"-init")==0 ){
18763 }else if( strcmp(z,"-html")==0 ){
18764 data.mode = MODE_Html;
18765 }else if( strcmp(z,"-list")==0 ){
18766 data.mode = MODE_List;
18767 }else if( strcmp(z,"-quote")==0 ){
18768 data.mode = MODE_Quote;
18769 }else if( strcmp(z,"-line")==0 ){
18770 data.mode = MODE_Line;
18771 }else if( strcmp(z,"-column")==0 ){
18772 data.mode = MODE_Column;
18773 }else if( strcmp(z,"-csv")==0 ){
18774 data.mode = MODE_Csv;
18775 memcpy(data.colSeparator,",",2);
18776 #ifdef SQLITE_HAVE_ZLIB
18777 }else if( strcmp(z,"-zip")==0 ){
18778 data.openMode = SHELL_OPEN_ZIPFILE;
18780 }else if( strcmp(z,"-append")==0 ){
18781 data.openMode = SHELL_OPEN_APPENDVFS;
18782 #ifdef SQLITE_ENABLE_DESERIALIZE
18783 }else if( strcmp(z,"-deserialize")==0 ){
18784 data.openMode = SHELL_OPEN_DESERIALIZE;
18785 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){
18786 data.szMax = integerValue(argv[++i]);
18788 }else if( strcmp(z,"-readonly")==0 ){
18789 data.openMode = SHELL_OPEN_READONLY;
18790 }else if( strcmp(z,"-ascii")==0 ){
18791 data.mode = MODE_Ascii;
18792 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
18794 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
18796 }else if( strcmp(z,"-separator")==0 ){
18797 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
18798 "%s",cmdline_option_value(argc,argv,++i));
18799 }else if( strcmp(z,"-newline")==0 ){
18800 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
18801 "%s",cmdline_option_value(argc,argv,++i));
18802 }else if( strcmp(z,"-nullvalue")==0 ){
18803 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
18804 "%s",cmdline_option_value(argc,argv,++i));
18805 }else if( strcmp(z,"-header")==0 ){
18806 data.showHeader = 1;
18807 }else if( strcmp(z,"-noheader")==0 ){
18808 data.showHeader = 0;
18809 }else if( strcmp(z,"-echo")==0 ){
18810 ShellSetFlag(&data, SHFLG_Echo);
18811 }else if( strcmp(z,"-eqp")==0 ){
18812 data.autoEQP = AUTOEQP_on;
18813 }else if( strcmp(z,"-eqpfull")==0 ){
18814 data.autoEQP = AUTOEQP_full;
18815 }else if( strcmp(z,"-stats")==0 ){
18817 }else if( strcmp(z,"-scanstats")==0 ){
18818 data.scanstatsOn = 1;
18819 }else if( strcmp(z,"-backslash")==0 ){
18820 /* Undocumented command-line option: -backslash
18821 ** Causes C-style backslash escapes to be evaluated in SQL statements
18822 ** prior to sending the SQL into SQLite. Useful for injecting
18823 ** crazy bytes in the middle of SQL statements for testing and debugging.
18825 ShellSetFlag(&data, SHFLG_Backslash);
18826 }else if( strcmp(z,"-bail")==0 ){
18828 }else if( strcmp(z,"-version")==0 ){
18829 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
18831 }else if( strcmp(z,"-interactive")==0 ){
18832 stdin_is_interactive = 1;
18833 }else if( strcmp(z,"-batch")==0 ){
18834 stdin_is_interactive = 0;
18835 }else if( strcmp(z,"-heap")==0 ){
18837 }else if( strcmp(z,"-pagecache")==0 ){
18839 }else if( strcmp(z,"-lookaside")==0 ){
18841 }else if( strcmp(z,"-mmap")==0 ){
18843 }else if( strcmp(z,"-memtrace")==0 ){
18845 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18846 }else if( strcmp(z,"-sorterref")==0 ){
18849 }else if( strcmp(z,"-vfs")==0 ){
18851 #ifdef SQLITE_ENABLE_VFSTRACE
18852 }else if( strcmp(z,"-vfstrace")==0 ){
18855 #ifdef SQLITE_ENABLE_MULTIPLEX
18856 }else if( strcmp(z,"-multiplex")==0 ){
18859 }else if( strcmp(z,"-help")==0 ){
18861 }else if( strcmp(z,"-cmd")==0 ){
18862 /* Run commands that follow -cmd first and separately from commands
18863 ** that simply appear on the command-line. This seems goofy. It would
18864 ** be better if all commands ran in the order that they appear. But
18865 ** we retain the goofy behavior for historical compatibility. */
18866 if( i==argc-1 ) break;
18867 z = cmdline_option_value(argc,argv,++i);
18869 rc = do_meta_command(z, &data);
18870 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
18873 rc = shell_exec(&data, z, &zErrMsg);
18875 utf8_printf(stderr,"Error: %s\n", zErrMsg);
18876 if( bail_on_error ) return rc!=0 ? rc : 1;
18878 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
18879 if( bail_on_error ) return rc;
18882 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
18883 }else if( strncmp(z, "-A", 2)==0 ){
18885 utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands"
18886 " with \"%s\"\n", z);
18889 open_db(&data, OPEN_DB_ZIPFILE);
18892 arDotCommand(&data, 1, argv+(i-1), argc-(i-1));
18894 arDotCommand(&data, 1, argv+i, argc-i);
18900 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
18901 raw_printf(stderr,"Use -help for a list of options.\n");
18904 data.cMode = data.mode;
18908 /* Run all arguments that do not begin with '-' as if they were separate
18909 ** command-line inputs, except for the argToSkip argument which contains
18910 ** the database filename.
18912 for(i=0; i<nCmd; i++){
18913 if( azCmd[i][0]=='.' ){
18914 rc = do_meta_command(azCmd[i], &data);
18915 if( rc ) return rc==2 ? 0 : rc;
18918 rc = shell_exec(&data, azCmd[i], &zErrMsg);
18920 utf8_printf(stderr,"Error: %s\n", zErrMsg);
18921 return rc!=0 ? rc : 1;
18923 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
18930 /* Run commands received from standard input
18932 if( stdin_is_interactive ){
18937 "SQLite version %s %.19s\n" /*extra-version-info*/
18938 "Enter \".help\" for usage hints.\n",
18939 sqlite3_libversion(), sqlite3_sourceid()
18941 if( warnInmemoryDb ){
18942 printf("Connected to a ");
18943 printBold("transient in-memory database");
18944 printf(".\nUse \".open FILENAME\" to reopen on a "
18945 "persistent database.\n");
18947 zHistory = getenv("SQLITE_HISTORY");
18949 zHistory = strdup(zHistory);
18950 }else if( (zHome = find_home_dir(0))!=0 ){
18951 nHistory = strlen30(zHome) + 20;
18952 if( (zHistory = malloc(nHistory))!=0 ){
18953 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
18956 if( zHistory ){ shell_read_history(zHistory); }
18957 #if HAVE_READLINE || HAVE_EDITLINE
18958 rl_attempted_completion_function = readline_completion;
18959 #elif HAVE_LINENOISE
18960 linenoiseSetCompletionCallback(linenoise_completion);
18963 rc = process_input(&data);
18965 shell_stifle_history(2000);
18966 shell_write_history(zHistory);
18971 rc = process_input(&data);
18974 set_table_name(&data, 0);
18976 session_close_all(&data);
18979 sqlite3_free(data.zFreeOnClose);
18981 output_reset(&data);
18982 data.doXdgOpen = 0;
18983 clearTempFile(&data);
18984 #if !SQLITE_SHELL_IS_UTF8
18985 for(i=0; i<argcToFree; i++) free(argvToFree[i]);
18988 /* Clear the global data structure so that valgrind will detect memory
18990 memset(&data, 0, sizeof(data));