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, (size_t)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, (size_t)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+1 );
9839 sqlite3_result_error_nomem(context);
9842 x = fread(p, 1, (size_t)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,
10315 pNext ? "|--" : "`--", z);
10316 if( n<(int)sizeof(p->sGraph.zPrefix)-7 ){
10317 memcpy(&p->sGraph.zPrefix[n], pNext ? "| " : " ", 4);
10318 eqp_render_level(p, pRow->iEqpId);
10319 p->sGraph.zPrefix[n] = 0;
10325 ** Display and reset the EXPLAIN QUERY PLAN data
10327 static void eqp_render(ShellState *p){
10328 EQPGraphRow *pRow = p->sGraph.pRow;
10330 if( pRow->zText[0]=='-' ){
10331 if( pRow->pNext==0 ){
10335 utf8_printf(p->out, "%s\n", pRow->zText+3);
10336 p->sGraph.pRow = pRow->pNext;
10337 sqlite3_free(pRow);
10339 utf8_printf(p->out, "QUERY PLAN\n");
10341 p->sGraph.zPrefix[0] = 0;
10342 eqp_render_level(p, 0);
10347 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
10349 ** Progress handler callback.
10351 static int progress_handler(void *pClientData) {
10352 ShellState *p = (ShellState*)pClientData;
10354 if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){
10355 raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress);
10356 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
10357 if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0;
10360 if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){
10361 raw_printf(p->out, "Progress %u\n", p->nProgress);
10365 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
10368 ** This is the callback routine that the shell
10369 ** invokes for each row of a query result.
10371 static int shell_callback(
10373 int nArg, /* Number of result columns */
10374 char **azArg, /* Text of each result column */
10375 char **azCol, /* Column names */
10376 int *aiType /* Column types */
10379 ShellState *p = (ShellState*)pArg;
10381 if( azArg==0 ) return 0;
10382 switch( p->cMode ){
10385 if( azArg==0 ) break;
10386 for(i=0; i<nArg; i++){
10387 int len = strlen30(azCol[i] ? azCol[i] : "");
10388 if( len>w ) w = len;
10390 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
10391 for(i=0; i<nArg; i++){
10392 utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
10393 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
10398 case MODE_Column: {
10399 static const int aExplainWidths[] = {4, 13, 4, 4, 4, 13, 2, 13};
10400 const int *colWidth;
10403 if( p->cMode==MODE_Column ){
10404 colWidth = p->colWidth;
10405 showHdr = p->showHeader;
10406 rowSep = p->rowSeparator;
10408 colWidth = aExplainWidths;
10413 for(i=0; i<nArg; i++){
10415 if( i<ArraySize(p->colWidth) ){
10421 w = strlenChar(azCol[i] ? azCol[i] : "");
10423 n = strlenChar(azArg && azArg[i] ? azArg[i] : p->nullValue);
10426 if( i<ArraySize(p->actualWidth) ){
10427 p->actualWidth[i] = w;
10430 utf8_width_print(p->out, w, azCol[i]);
10431 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
10435 for(i=0; i<nArg; i++){
10437 if( i<ArraySize(p->actualWidth) ){
10438 w = p->actualWidth[i];
10443 utf8_printf(p->out,"%-*.*s%s",w,w,
10444 "----------------------------------------------------------"
10445 "----------------------------------------------------------",
10446 i==nArg-1 ? rowSep : " ");
10450 if( azArg==0 ) break;
10451 for(i=0; i<nArg; i++){
10453 if( i<ArraySize(p->actualWidth) ){
10454 w = p->actualWidth[i];
10458 if( p->cMode==MODE_Explain && azArg[i] && strlenChar(azArg[i])>w ){
10459 w = strlenChar(azArg[i]);
10461 if( i==1 && p->aiIndent && p->pStmt ){
10462 if( p->iIndent<p->nIndent ){
10463 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
10467 utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue);
10468 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
10472 case MODE_Semi: { /* .schema and .fullschema output */
10473 printSchemaLine(p->out, azArg[0], ";\n");
10476 case MODE_Pretty: { /* .schema and .fullschema with --indent */
10484 if( azArg[0]==0 ) break;
10485 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
10486 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
10488 utf8_printf(p->out, "%s;\n", azArg[0]);
10491 z = sqlite3_mprintf("%s", azArg[0]);
10493 for(i=0; IsSpace(z[i]); i++){}
10494 for(; (c = z[i])!=0; i++){
10496 if( z[j-1]=='\r' ) z[j-1] = '\n';
10497 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue;
10498 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){
10503 while( j>0 && IsSpace(z[j-1]) ){ j--; }
10505 if( strlen30(z)>=79 ){
10506 for(i=j=0; (c = z[i])!=0; i++){ /* Copy from z[i] back to z[j] */
10509 }else if( c=='"' || c=='\'' || c=='`' ){
10511 }else if( c=='[' ){
10513 }else if( c=='-' && z[i+1]=='-' ){
10515 }else if( c=='(' ){
10517 }else if( c==')' ){
10519 if( nLine>0 && nParen==0 && j>0 ){
10520 printSchemaLineN(p->out, z, j, "\n");
10525 if( nParen==1 && cEnd==0
10526 && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1)))
10529 printSchemaLineN(p->out, z, j, "\n ");
10532 while( IsSpace(z[i+1]) ){ i++; }
10537 printSchemaLine(p->out, z, ";\n");
10542 if( p->cnt++==0 && p->showHeader ){
10543 for(i=0; i<nArg; i++){
10544 utf8_printf(p->out,"%s%s",azCol[i],
10545 i==nArg-1 ? p->rowSeparator : p->colSeparator);
10548 if( azArg==0 ) break;
10549 for(i=0; i<nArg; i++){
10550 char *z = azArg[i];
10551 if( z==0 ) z = p->nullValue;
10552 utf8_printf(p->out, "%s", z);
10554 utf8_printf(p->out, "%s", p->colSeparator);
10556 utf8_printf(p->out, "%s", p->rowSeparator);
10562 if( p->cnt++==0 && p->showHeader ){
10563 raw_printf(p->out,"<TR>");
10564 for(i=0; i<nArg; i++){
10565 raw_printf(p->out,"<TH>");
10566 output_html_string(p->out, azCol[i]);
10567 raw_printf(p->out,"</TH>\n");
10569 raw_printf(p->out,"</TR>\n");
10571 if( azArg==0 ) break;
10572 raw_printf(p->out,"<TR>");
10573 for(i=0; i<nArg; i++){
10574 raw_printf(p->out,"<TD>");
10575 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
10576 raw_printf(p->out,"</TD>\n");
10578 raw_printf(p->out,"</TR>\n");
10582 if( p->cnt++==0 && p->showHeader ){
10583 for(i=0; i<nArg; i++){
10584 output_c_string(p->out,azCol[i] ? azCol[i] : "");
10585 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
10587 utf8_printf(p->out, "%s", p->rowSeparator);
10589 if( azArg==0 ) break;
10590 for(i=0; i<nArg; i++){
10591 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
10592 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
10594 utf8_printf(p->out, "%s", p->rowSeparator);
10598 setBinaryMode(p->out, 1);
10599 if( p->cnt++==0 && p->showHeader ){
10600 for(i=0; i<nArg; i++){
10601 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
10603 utf8_printf(p->out, "%s", p->rowSeparator);
10606 for(i=0; i<nArg; i++){
10607 output_csv(p, azArg[i], i<nArg-1);
10609 utf8_printf(p->out, "%s", p->rowSeparator);
10611 setTextMode(p->out, 1);
10614 case MODE_Insert: {
10615 if( azArg==0 ) break;
10616 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
10617 if( p->showHeader ){
10618 raw_printf(p->out,"(");
10619 for(i=0; i<nArg; i++){
10620 if( i>0 ) raw_printf(p->out, ",");
10621 if( quoteChar(azCol[i]) ){
10622 char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
10623 utf8_printf(p->out, "%s", z);
10626 raw_printf(p->out, "%s", azCol[i]);
10629 raw_printf(p->out,")");
10632 for(i=0; i<nArg; i++){
10633 raw_printf(p->out, i>0 ? "," : " VALUES(");
10634 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
10635 utf8_printf(p->out,"NULL");
10636 }else if( aiType && aiType[i]==SQLITE_TEXT ){
10637 if( ShellHasFlag(p, SHFLG_Newlines) ){
10638 output_quoted_string(p->out, azArg[i]);
10640 output_quoted_escaped_string(p->out, azArg[i]);
10642 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
10643 utf8_printf(p->out,"%s", azArg[i]);
10644 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
10646 double r = sqlite3_column_double(p->pStmt, i);
10648 memcpy(&ur,&r,sizeof(r));
10649 if( ur==0x7ff0000000000000LL ){
10650 raw_printf(p->out, "1e999");
10651 }else if( ur==0xfff0000000000000LL ){
10652 raw_printf(p->out, "-1e999");
10654 sqlite3_snprintf(50,z,"%!.20g", r);
10655 raw_printf(p->out, "%s", z);
10657 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
10658 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
10659 int nBlob = sqlite3_column_bytes(p->pStmt, i);
10660 output_hex_blob(p->out, pBlob, nBlob);
10661 }else if( isNumber(azArg[i], 0) ){
10662 utf8_printf(p->out,"%s", azArg[i]);
10663 }else if( ShellHasFlag(p, SHFLG_Newlines) ){
10664 output_quoted_string(p->out, azArg[i]);
10666 output_quoted_escaped_string(p->out, azArg[i]);
10669 raw_printf(p->out,");\n");
10673 if( azArg==0 ) break;
10674 if( p->cnt==0 && p->showHeader ){
10675 for(i=0; i<nArg; i++){
10676 if( i>0 ) raw_printf(p->out, ",");
10677 output_quoted_string(p->out, azCol[i]);
10679 raw_printf(p->out,"\n");
10682 for(i=0; i<nArg; i++){
10683 if( i>0 ) raw_printf(p->out, ",");
10684 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
10685 utf8_printf(p->out,"NULL");
10686 }else if( aiType && aiType[i]==SQLITE_TEXT ){
10687 output_quoted_string(p->out, azArg[i]);
10688 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
10689 utf8_printf(p->out,"%s", azArg[i]);
10690 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
10692 double r = sqlite3_column_double(p->pStmt, i);
10693 sqlite3_snprintf(50,z,"%!.20g", r);
10694 raw_printf(p->out, "%s", z);
10695 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
10696 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
10697 int nBlob = sqlite3_column_bytes(p->pStmt, i);
10698 output_hex_blob(p->out, pBlob, nBlob);
10699 }else if( isNumber(azArg[i], 0) ){
10700 utf8_printf(p->out,"%s", azArg[i]);
10702 output_quoted_string(p->out, azArg[i]);
10705 raw_printf(p->out,"\n");
10709 if( p->cnt++==0 && p->showHeader ){
10710 for(i=0; i<nArg; i++){
10711 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
10712 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
10714 utf8_printf(p->out, "%s", p->rowSeparator);
10716 if( azArg==0 ) break;
10717 for(i=0; i<nArg; i++){
10718 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
10719 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
10721 utf8_printf(p->out, "%s", p->rowSeparator);
10725 eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]);
10733 ** This is the callback routine that the SQLite library
10734 ** invokes for each row of a query result.
10736 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
10737 /* since we don't have type info, call the shell_callback with a NULL value */
10738 return shell_callback(pArg, nArg, azArg, azCol, NULL);
10742 ** This is the callback routine from sqlite3_exec() that appends all
10743 ** output onto the end of a ShellText object.
10745 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
10746 ShellText *p = (ShellText*)pArg;
10748 UNUSED_PARAMETER(az);
10749 if( azArg==0 ) return 0;
10750 if( p->n ) appendText(p, "|", 0);
10751 for(i=0; i<nArg; i++){
10752 if( i ) appendText(p, ",", 0);
10753 if( azArg[i] ) appendText(p, azArg[i], 0);
10759 ** Generate an appropriate SELFTEST table in the main database.
10761 static void createSelftestTable(ShellState *p){
10763 sqlite3_exec(p->db,
10764 "SAVEPOINT selftest_init;\n"
10765 "CREATE TABLE IF NOT EXISTS selftest(\n"
10766 " tno INTEGER PRIMARY KEY,\n" /* Test number */
10767 " op TEXT,\n" /* Operator: memo run */
10768 " cmd TEXT,\n" /* Command text */
10769 " ans TEXT\n" /* Desired answer */
10771 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
10772 "INSERT INTO [_shell$self](rowid,op,cmd)\n"
10773 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
10774 " 'memo','Tests generated by --init');\n"
10775 "INSERT INTO [_shell$self]\n"
10777 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
10778 "FROM sqlite_master ORDER BY 2'',224))',\n"
10779 " hex(sha3_query('SELECT type,name,tbl_name,sql "
10780 "FROM sqlite_master ORDER BY 2',224));\n"
10781 "INSERT INTO [_shell$self]\n"
10783 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
10784 " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
10785 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
10787 " SELECT name FROM sqlite_master\n"
10788 " WHERE type='table'\n"
10789 " AND name<>'selftest'\n"
10790 " AND coalesce(rootpage,0)>0\n"
10792 " ORDER BY name;\n"
10793 "INSERT INTO [_shell$self]\n"
10794 " VALUES('run','PRAGMA integrity_check','ok');\n"
10795 "INSERT INTO selftest(tno,op,cmd,ans)"
10796 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
10797 "DROP TABLE [_shell$self];"
10800 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
10801 sqlite3_free(zErrMsg);
10803 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
10808 ** Set the destination table field of the ShellState structure to
10809 ** the name of the table given. Escape any quote characters in the
10812 static void set_table_name(ShellState *p, const char *zName){
10817 if( p->zDestTable ){
10818 free(p->zDestTable);
10821 if( zName==0 ) return;
10822 cQuote = quoteChar(zName);
10823 n = strlen30(zName);
10824 if( cQuote ) n += n+2;
10825 z = p->zDestTable = malloc( n+1 );
10826 if( z==0 ) shell_out_of_memory();
10828 if( cQuote ) z[n++] = cQuote;
10829 for(i=0; zName[i]; i++){
10831 if( zName[i]==cQuote ) z[n++] = cQuote;
10833 if( cQuote ) z[n++] = cQuote;
10839 ** Execute a query statement that will generate SQL output. Print
10840 ** the result columns, comma-separated, on a line and then add a
10841 ** semicolon terminator to the end of that line.
10843 ** If the number of columns is 1 and that column contains text "--"
10844 ** then write the semicolon on a separate line. That way, if a
10845 ** "--" comment occurs at the end of the statement, the comment
10846 ** won't consume the semicolon terminator.
10848 static int run_table_dump_query(
10849 ShellState *p, /* Query context */
10850 const char *zSelect, /* SELECT statement to extract content */
10851 const char *zFirstRow /* Print before first row, if not NULL */
10853 sqlite3_stmt *pSelect;
10858 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
10859 if( rc!=SQLITE_OK || !pSelect ){
10860 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
10861 sqlite3_errmsg(p->db));
10862 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
10865 rc = sqlite3_step(pSelect);
10866 nResult = sqlite3_column_count(pSelect);
10867 while( rc==SQLITE_ROW ){
10869 utf8_printf(p->out, "%s", zFirstRow);
10872 z = (const char*)sqlite3_column_text(pSelect, 0);
10873 utf8_printf(p->out, "%s", z);
10874 for(i=1; i<nResult; i++){
10875 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
10878 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
10880 raw_printf(p->out, "\n;\n");
10882 raw_printf(p->out, ";\n");
10884 rc = sqlite3_step(pSelect);
10886 rc = sqlite3_finalize(pSelect);
10887 if( rc!=SQLITE_OK ){
10888 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
10889 sqlite3_errmsg(p->db));
10890 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
10896 ** Allocate space and save off current error string.
10898 static char *save_err_msg(
10899 sqlite3 *db /* Database to query */
10901 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
10902 char *zErrMsg = sqlite3_malloc64(nErrMsg);
10904 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
10911 ** Attempt to display I/O stats on Linux using /proc/PID/io
10913 static void displayLinuxIoStats(FILE *out){
10916 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
10917 in = fopen(z, "rb");
10918 if( in==0 ) return;
10919 while( fgets(z, sizeof(z), in)!=0 ){
10920 static const struct {
10921 const char *zPattern;
10924 { "rchar: ", "Bytes received by read():" },
10925 { "wchar: ", "Bytes sent to write():" },
10926 { "syscr: ", "Read() system calls:" },
10927 { "syscw: ", "Write() system calls:" },
10928 { "read_bytes: ", "Bytes read from storage:" },
10929 { "write_bytes: ", "Bytes written to storage:" },
10930 { "cancelled_write_bytes: ", "Cancelled write bytes:" },
10933 for(i=0; i<ArraySize(aTrans); i++){
10934 int n = strlen30(aTrans[i].zPattern);
10935 if( strncmp(aTrans[i].zPattern, z, n)==0 ){
10936 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
10946 ** Display a single line of status using 64-bit values.
10948 static void displayStatLine(
10949 ShellState *p, /* The shell context */
10950 char *zLabel, /* Label for this one line */
10951 char *zFormat, /* Format for the result */
10952 int iStatusCtrl, /* Which status to display */
10953 int bReset /* True to reset the stats */
10955 sqlite3_int64 iCur = -1;
10956 sqlite3_int64 iHiwtr = -1;
10959 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
10960 for(i=0, nPercent=0; zFormat[i]; i++){
10961 if( zFormat[i]=='%' ) nPercent++;
10964 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
10966 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
10968 raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
10972 ** Display memory stats.
10974 static int display_stats(
10975 sqlite3 *db, /* Database to query */
10976 ShellState *pArg, /* Pointer to ShellState */
10977 int bReset /* True to reset the stats */
10982 if( pArg==0 || pArg->out==0 ) return 0;
10985 if( pArg->pStmt && (pArg->statsOn & 2) ){
10987 sqlite3_stmt *pStmt = pArg->pStmt;
10989 nCol = sqlite3_column_count(pStmt);
10990 raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol);
10991 for(i=0; i<nCol; i++){
10992 sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x);
10993 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i));
10994 #ifndef SQLITE_OMIT_DECLTYPE
10995 sqlite3_snprintf(30, z+x, "declared type:");
10996 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
10998 #ifdef SQLITE_ENABLE_COLUMN_METADATA
10999 sqlite3_snprintf(30, z+x, "database name:");
11000 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i));
11001 sqlite3_snprintf(30, z+x, "table name:");
11002 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
11003 sqlite3_snprintf(30, z+x, "origin name:");
11004 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i));
11009 displayStatLine(pArg, "Memory Used:",
11010 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
11011 displayStatLine(pArg, "Number of Outstanding Allocations:",
11012 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
11013 if( pArg->shellFlgs & SHFLG_Pagecache ){
11014 displayStatLine(pArg, "Number of Pcache Pages Used:",
11015 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
11017 displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
11018 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
11019 displayStatLine(pArg, "Largest Allocation:",
11020 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
11021 displayStatLine(pArg, "Largest Pcache Allocation:",
11022 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
11023 #ifdef YYTRACKMAXSTACKDEPTH
11024 displayStatLine(pArg, "Deepest Parser Stack:",
11025 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
11029 if( pArg->shellFlgs & SHFLG_Lookaside ){
11030 iHiwtr = iCur = -1;
11031 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
11032 &iCur, &iHiwtr, bReset);
11033 raw_printf(pArg->out,
11034 "Lookaside Slots Used: %d (max %d)\n",
11036 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
11037 &iCur, &iHiwtr, bReset);
11038 raw_printf(pArg->out, "Successful lookaside attempts: %d\n",
11040 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
11041 &iCur, &iHiwtr, bReset);
11042 raw_printf(pArg->out, "Lookaside failures due to size: %d\n",
11044 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
11045 &iCur, &iHiwtr, bReset);
11046 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n",
11049 iHiwtr = iCur = -1;
11050 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
11051 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n",
11053 iHiwtr = iCur = -1;
11054 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
11055 raw_printf(pArg->out, "Page cache hits: %d\n", iCur);
11056 iHiwtr = iCur = -1;
11057 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
11058 raw_printf(pArg->out, "Page cache misses: %d\n", iCur);
11059 iHiwtr = iCur = -1;
11060 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
11061 raw_printf(pArg->out, "Page cache writes: %d\n", iCur);
11062 iHiwtr = iCur = -1;
11063 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1);
11064 raw_printf(pArg->out, "Page cache spills: %d\n", iCur);
11065 iHiwtr = iCur = -1;
11066 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
11067 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n",
11069 iHiwtr = iCur = -1;
11070 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
11071 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",
11076 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
11078 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur);
11079 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
11080 raw_printf(pArg->out, "Sort Operations: %d\n", iCur);
11081 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
11082 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur);
11083 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
11084 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
11085 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset);
11086 raw_printf(pArg->out, "Reprepare operations: %d\n", iCur);
11087 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset);
11088 raw_printf(pArg->out, "Number of times run: %d\n", iCur);
11089 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset);
11090 raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur);
11094 displayLinuxIoStats(pArg->out);
11097 /* Do not remove this machine readable comment: extra-stats-output-here */
11103 ** Display scan stats.
11105 static void display_scanstats(
11106 sqlite3 *db, /* Database to query */
11107 ShellState *pArg /* Pointer to ShellState */
11109 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
11110 UNUSED_PARAMETER(db);
11111 UNUSED_PARAMETER(pArg);
11114 raw_printf(pArg->out, "-------- scanstats --------\n");
11116 for(k=0; k<=mx; k++){
11117 double rEstLoop = 1.0;
11118 for(i=n=0; 1; i++){
11119 sqlite3_stmt *p = pArg->pStmt;
11120 sqlite3_int64 nLoop, nVisit;
11123 const char *zExplain;
11124 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
11127 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
11128 if( iSid>mx ) mx = iSid;
11129 if( iSid!=k ) continue;
11131 rEstLoop = (double)nLoop;
11132 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k);
11135 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
11136 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
11137 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
11138 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain);
11140 raw_printf(pArg->out,
11141 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
11142 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
11146 raw_printf(pArg->out, "---------------------------\n");
11151 ** Parameter azArray points to a zero-terminated array of strings. zStr
11152 ** points to a single nul-terminated string. Return non-zero if zStr
11153 ** is equal, according to strcmp(), to any of the strings in the array.
11154 ** Otherwise, return zero.
11156 static int str_in_array(const char *zStr, const char **azArray){
11158 for(i=0; azArray[i]; i++){
11159 if( 0==strcmp(zStr, azArray[i]) ) return 1;
11165 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
11166 ** and populate the ShellState.aiIndent[] array with the number of
11167 ** spaces each opcode should be indented before it is output.
11169 ** The indenting rules are:
11171 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
11172 ** all opcodes that occur between the p2 jump destination and the opcode
11173 ** itself by 2 spaces.
11175 ** * For each "Goto", if the jump destination is earlier in the program
11176 ** and ends on one of:
11177 ** Yield SeekGt SeekLt RowSetRead Rewind
11178 ** or if the P1 parameter is one instead of zero,
11179 ** then indent all opcodes between the earlier instruction
11180 ** and "Goto" by 2 spaces.
11182 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
11183 const char *zSql; /* The text of the SQL statement */
11184 const char *z; /* Used to check if this is an EXPLAIN */
11185 int *abYield = 0; /* True if op is an OP_Yield */
11186 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
11187 int iOp; /* Index of operation in p->aiIndent[] */
11189 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 };
11190 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
11192 const char *azGoto[] = { "Goto", 0 };
11194 /* Try to figure out if this is really an EXPLAIN statement. If this
11195 ** cannot be verified, return early. */
11196 if( sqlite3_column_count(pSql)!=8 ){
11197 p->cMode = p->mode;
11200 zSql = sqlite3_sql(pSql);
11201 if( zSql==0 ) return;
11202 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
11203 if( sqlite3_strnicmp(z, "explain", 7) ){
11204 p->cMode = p->mode;
11208 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
11210 int iAddr = sqlite3_column_int(pSql, 0);
11211 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
11213 /* Set p2 to the P2 field of the current opcode. Then, assuming that
11214 ** p2 is an instruction address, set variable p2op to the index of that
11215 ** instruction in the aiIndent[] array. p2 and p2op may be different if
11216 ** the current instruction is part of a sub-program generated by an
11217 ** SQL trigger or foreign key. */
11218 int p2 = sqlite3_column_int(pSql, 3);
11219 int p2op = (p2 + (iOp-iAddr));
11221 /* Grow the p->aiIndent array as required */
11224 /* Do further verfication that this is explain output. Abort if
11226 static const char *explainCols[] = {
11227 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" };
11229 for(jj=0; jj<ArraySize(explainCols); jj++){
11230 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){
11231 p->cMode = p->mode;
11232 sqlite3_reset(pSql);
11238 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
11239 if( p->aiIndent==0 ) shell_out_of_memory();
11240 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
11241 if( abYield==0 ) shell_out_of_memory();
11243 abYield[iOp] = str_in_array(zOp, azYield);
11244 p->aiIndent[iOp] = 0;
11245 p->nIndent = iOp+1;
11247 if( str_in_array(zOp, azNext) ){
11248 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
11250 if( str_in_array(zOp, azGoto) && p2op<p->nIndent
11251 && (abYield[p2op] || sqlite3_column_int(pSql, 2))
11253 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
11258 sqlite3_free(abYield);
11259 sqlite3_reset(pSql);
11263 ** Free the array allocated by explain_data_prepare().
11265 static void explain_data_delete(ShellState *p){
11266 sqlite3_free(p->aiIndent);
11273 ** Disable and restore .wheretrace and .selecttrace settings.
11275 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11276 extern int sqlite3SelectTrace;
11277 static int savedSelectTrace;
11279 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11280 extern int sqlite3WhereTrace;
11281 static int savedWhereTrace;
11283 static void disable_debug_trace_modes(void){
11284 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11285 savedSelectTrace = sqlite3SelectTrace;
11286 sqlite3SelectTrace = 0;
11288 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11289 savedWhereTrace = sqlite3WhereTrace;
11290 sqlite3WhereTrace = 0;
11293 static void restore_debug_trace_modes(void){
11294 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11295 sqlite3SelectTrace = savedSelectTrace;
11297 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11298 sqlite3WhereTrace = savedWhereTrace;
11302 /* Create the TEMP table used to store parameter bindings */
11303 static void bind_table_init(ShellState *p){
11305 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema);
11306 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0);
11307 sqlite3_exec(p->db,
11308 "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n"
11309 " key TEXT PRIMARY KEY,\n"
11311 ") WITHOUT ROWID;",
11313 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0);
11317 ** Bind parameters on a prepared statement.
11319 ** Parameter bindings are taken from a TEMP table of the form:
11321 ** CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value)
11324 ** No bindings occur if this table does not exist. The special character '$'
11325 ** is included in the table name to help prevent collisions with actual tables.
11326 ** The table must be in the TEMP schema.
11328 static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){
11332 sqlite3_stmt *pQ = 0;
11334 nVar = sqlite3_bind_parameter_count(pStmt);
11335 if( nVar==0 ) return; /* Nothing to do */
11336 if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters",
11337 "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){
11338 return; /* Parameter table does not exist */
11340 rc = sqlite3_prepare_v2(pArg->db,
11341 "SELECT value FROM temp.sqlite_parameters"
11342 " WHERE key=?1", -1, &pQ, 0);
11343 if( rc || pQ==0 ) return;
11344 for(i=1; i<=nVar; i++){
11346 const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
11348 sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i);
11351 sqlite3_bind_text(pQ, 1, zVar, -1, SQLITE_STATIC);
11352 if( sqlite3_step(pQ)==SQLITE_ROW ){
11353 sqlite3_bind_value(pStmt, i, sqlite3_column_value(pQ, 0));
11355 sqlite3_bind_null(pStmt, i);
11359 sqlite3_finalize(pQ);
11363 ** Run a prepared statement
11365 static void exec_prepared_stmt(
11366 ShellState *pArg, /* Pointer to ShellState */
11367 sqlite3_stmt *pStmt /* Statment to run */
11371 /* perform the first step. this will tell us if we
11372 ** have a result set or not and how wide it is.
11374 rc = sqlite3_step(pStmt);
11375 /* if we have a result set... */
11376 if( SQLITE_ROW == rc ){
11377 /* allocate space for col name ptr, value ptr, and type */
11378 int nCol = sqlite3_column_count(pStmt);
11379 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
11383 char **azCols = (char **)pData; /* Names of result columns */
11384 char **azVals = &azCols[nCol]; /* Results */
11385 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
11387 assert(sizeof(int) <= sizeof(char *));
11388 /* save off ptrs to column names */
11389 for(i=0; i<nCol; i++){
11390 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
11393 /* extract the data and data types */
11394 for(i=0; i<nCol; i++){
11395 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
11396 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){
11399 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
11401 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
11403 break; /* from for */
11407 /* if data and types extracted successfully... */
11408 if( SQLITE_ROW == rc ){
11409 /* call the supplied callback with the result row data */
11410 if( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){
11413 rc = sqlite3_step(pStmt);
11416 } while( SQLITE_ROW == rc );
11417 sqlite3_free(pData);
11422 #ifndef SQLITE_OMIT_VIRTUALTABLE
11424 ** This function is called to process SQL if the previous shell command
11425 ** was ".expert". It passes the SQL in the second argument directly to
11426 ** the sqlite3expert object.
11428 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error
11429 ** code. In this case, (*pzErr) may be set to point to a buffer containing
11430 ** an English language error message. It is the responsibility of the
11431 ** caller to eventually free this buffer using sqlite3_free().
11433 static int expertHandleSQL(
11434 ShellState *pState,
11438 assert( pState->expert.pExpert );
11439 assert( pzErr==0 || *pzErr==0 );
11440 return sqlite3_expert_sql(pState->expert.pExpert, zSql, pzErr);
11444 ** This function is called either to silently clean up the object
11445 ** created by the ".expert" command (if bCancel==1), or to generate a
11446 ** report from it and then clean it up (if bCancel==0).
11448 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error
11449 ** code. In this case, (*pzErr) may be set to point to a buffer containing
11450 ** an English language error message. It is the responsibility of the
11451 ** caller to eventually free this buffer using sqlite3_free().
11453 static int expertFinish(
11454 ShellState *pState,
11458 int rc = SQLITE_OK;
11459 sqlite3expert *p = pState->expert.pExpert;
11461 assert( bCancel || pzErr==0 || *pzErr==0 );
11463 FILE *out = pState->out;
11464 int bVerbose = pState->expert.bVerbose;
11466 rc = sqlite3_expert_analyze(p, pzErr);
11467 if( rc==SQLITE_OK ){
11468 int nQuery = sqlite3_expert_count(p);
11472 const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
11473 raw_printf(out, "-- Candidates -----------------------------\n");
11474 raw_printf(out, "%s\n", zCand);
11476 for(i=0; i<nQuery; i++){
11477 const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
11478 const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
11479 const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
11480 if( zIdx==0 ) zIdx = "(no new indexes)\n";
11482 raw_printf(out, "-- Query %d --------------------------------\n",i+1);
11483 raw_printf(out, "%s\n\n", zSql);
11485 raw_printf(out, "%s\n", zIdx);
11486 raw_printf(out, "%s\n", zEQP);
11490 sqlite3_expert_destroy(p);
11491 pState->expert.pExpert = 0;
11496 ** Implementation of ".expert" dot command.
11498 static int expertDotCommand(
11499 ShellState *pState, /* Current shell tool state */
11500 char **azArg, /* Array of arguments passed to dot command */
11501 int nArg /* Number of entries in azArg[] */
11503 int rc = SQLITE_OK;
11508 assert( pState->expert.pExpert==0 );
11509 memset(&pState->expert, 0, sizeof(ExpertInfo));
11511 for(i=1; rc==SQLITE_OK && i<nArg; i++){
11512 char *z = azArg[i];
11514 if( z[0]=='-' && z[1]=='-' ) z++;
11516 if( n>=2 && 0==strncmp(z, "-verbose", n) ){
11517 pState->expert.bVerbose = 1;
11519 else if( n>=2 && 0==strncmp(z, "-sample", n) ){
11521 raw_printf(stderr, "option requires an argument: %s\n", z);
11524 iSample = (int)integerValue(azArg[++i]);
11525 if( iSample<0 || iSample>100 ){
11526 raw_printf(stderr, "value out of range: %s\n", azArg[i]);
11532 raw_printf(stderr, "unknown option: %s\n", z);
11537 if( rc==SQLITE_OK ){
11538 pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr);
11539 if( pState->expert.pExpert==0 ){
11540 raw_printf(stderr, "sqlite3_expert_new: %s\n", zErr);
11543 sqlite3_expert_config(
11544 pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample
11551 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
11554 ** Execute a statement or set of statements. Print
11555 ** any result rows/columns depending on the current mode
11556 ** set via the supplied callback.
11558 ** This is very similar to SQLite's built-in sqlite3_exec()
11559 ** function except it takes a slightly different callback
11560 ** and callback data argument.
11562 static int shell_exec(
11563 ShellState *pArg, /* Pointer to ShellState */
11564 const char *zSql, /* SQL to be evaluated */
11565 char **pzErrMsg /* Error msg written here */
11567 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
11568 int rc = SQLITE_OK; /* Return Code */
11570 const char *zLeftover; /* Tail of unprocessed SQL */
11571 sqlite3 *db = pArg->db;
11577 #ifndef SQLITE_OMIT_VIRTUALTABLE
11578 if( pArg->expert.pExpert ){
11579 rc = expertHandleSQL(pArg, zSql, pzErrMsg);
11580 return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg);
11584 while( zSql[0] && (SQLITE_OK == rc) ){
11585 static const char *zStmtSql;
11586 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
11587 if( SQLITE_OK != rc ){
11589 *pzErrMsg = save_err_msg(db);
11593 /* this happens for a comment or white-space */
11595 while( IsSpace(zSql[0]) ) zSql++;
11598 zStmtSql = sqlite3_sql(pStmt);
11599 if( zStmtSql==0 ) zStmtSql = "";
11600 while( IsSpace(zStmtSql[0]) ) zStmtSql++;
11602 /* save off the prepared statment handle and reset row count */
11604 pArg->pStmt = pStmt;
11608 /* echo the sql statement if echo on */
11609 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
11610 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
11613 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
11614 if( pArg && pArg->autoEQP && sqlite3_stmt_isexplain(pStmt)==0 ){
11615 sqlite3_stmt *pExplain;
11617 int triggerEQP = 0;
11618 disable_debug_trace_modes();
11619 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP);
11620 if( pArg->autoEQP>=AUTOEQP_trigger ){
11621 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0);
11623 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql);
11624 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
11625 if( rc==SQLITE_OK ){
11626 while( sqlite3_step(pExplain)==SQLITE_ROW ){
11627 const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3);
11628 int iEqpId = sqlite3_column_int(pExplain, 0);
11629 int iParentId = sqlite3_column_int(pExplain, 1);
11630 if( zEQPLine[0]=='-' ) eqp_render(pArg);
11631 eqp_append(pArg, iEqpId, iParentId, zEQPLine);
11635 sqlite3_finalize(pExplain);
11636 sqlite3_free(zEQP);
11637 if( pArg->autoEQP>=AUTOEQP_full ){
11638 /* Also do an EXPLAIN for ".eqp full" mode */
11639 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql);
11640 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
11641 if( rc==SQLITE_OK ){
11642 pArg->cMode = MODE_Explain;
11643 explain_data_prepare(pArg, pExplain);
11644 exec_prepared_stmt(pArg, pExplain);
11645 explain_data_delete(pArg);
11647 sqlite3_finalize(pExplain);
11648 sqlite3_free(zEQP);
11650 if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){
11651 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0);
11652 /* Reprepare pStmt before reactiving trace modes */
11653 sqlite3_finalize(pStmt);
11654 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
11655 if( pArg ) pArg->pStmt = pStmt;
11657 restore_debug_trace_modes();
11661 pArg->cMode = pArg->mode;
11662 if( pArg->autoExplain ){
11663 if( sqlite3_stmt_isexplain(pStmt)==1 ){
11664 pArg->cMode = MODE_Explain;
11666 if( sqlite3_stmt_isexplain(pStmt)==2 ){
11667 pArg->cMode = MODE_EQP;
11671 /* If the shell is currently in ".explain" mode, gather the extra
11672 ** data required to add indents to the output.*/
11673 if( pArg->cMode==MODE_Explain ){
11674 explain_data_prepare(pArg, pStmt);
11678 bind_prepared_stmt(pArg, pStmt);
11679 exec_prepared_stmt(pArg, pStmt);
11680 explain_data_delete(pArg);
11683 /* print usage stats if stats on */
11684 if( pArg && pArg->statsOn ){
11685 display_stats(db, pArg, 0);
11688 /* print loop-counters if required */
11689 if( pArg && pArg->scanstatsOn ){
11690 display_scanstats(db, pArg);
11693 /* Finalize the statement just executed. If this fails, save a
11694 ** copy of the error message. Otherwise, set zSql to point to the
11695 ** next statement to execute. */
11696 rc2 = sqlite3_finalize(pStmt);
11697 if( rc!=SQLITE_NOMEM ) rc = rc2;
11698 if( rc==SQLITE_OK ){
11700 while( IsSpace(zSql[0]) ) zSql++;
11701 }else if( pzErrMsg ){
11702 *pzErrMsg = save_err_msg(db);
11705 /* clear saved stmt handle */
11707 pArg->pStmt = NULL;
11716 ** Release memory previously allocated by tableColumnList().
11718 static void freeColumnList(char **azCol){
11720 for(i=1; azCol[i]; i++){
11721 sqlite3_free(azCol[i]);
11723 /* azCol[0] is a static string */
11724 sqlite3_free(azCol);
11728 ** Return a list of pointers to strings which are the names of all
11729 ** columns in table zTab. The memory to hold the names is dynamically
11730 ** allocated and must be released by the caller using a subsequent call
11731 ** to freeColumnList().
11733 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
11734 ** value that needs to be preserved, then azCol[0] is filled in with the
11735 ** name of the rowid column.
11737 ** The first regular column in the table is azCol[1]. The list is terminated
11738 ** by an entry with azCol[i]==0.
11740 static char **tableColumnList(ShellState *p, const char *zTab){
11742 sqlite3_stmt *pStmt;
11746 int nPK = 0; /* Number of PRIMARY KEY columns seen */
11747 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
11748 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
11751 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
11752 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
11753 sqlite3_free(zSql);
11755 while( sqlite3_step(pStmt)==SQLITE_ROW ){
11756 if( nCol>=nAlloc-2 ){
11757 nAlloc = nAlloc*2 + nCol + 10;
11758 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
11759 if( azCol==0 ) shell_out_of_memory();
11761 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
11762 if( sqlite3_column_int(pStmt, 5) ){
11765 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
11774 sqlite3_finalize(pStmt);
11775 if( azCol==0 ) return 0;
11779 /* The decision of whether or not a rowid really needs to be preserved
11780 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
11781 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
11782 ** rowids on tables where the rowid is inaccessible because there are other
11783 ** columns in the table named "rowid", "_rowid_", and "oid".
11785 if( preserveRowid && isIPK ){
11786 /* If a single PRIMARY KEY column with type INTEGER was seen, then it
11787 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
11788 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
11789 ** ROWID aliases. To distinguish these cases, check to see if
11790 ** there is a "pk" entry in "PRAGMA index_list". There will be
11791 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
11793 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
11794 " WHERE origin='pk'", zTab);
11795 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
11796 sqlite3_free(zSql);
11798 freeColumnList(azCol);
11801 rc = sqlite3_step(pStmt);
11802 sqlite3_finalize(pStmt);
11803 preserveRowid = rc==SQLITE_ROW;
11805 if( preserveRowid ){
11806 /* Only preserve the rowid if we can find a name to use for the
11808 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
11810 for(j=0; j<3; j++){
11811 for(i=1; i<=nCol; i++){
11812 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
11815 /* At this point, we know that azRowid[j] is not the name of any
11816 ** ordinary column in the table. Verify that azRowid[j] is a valid
11817 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
11818 ** tables will fail this last check */
11819 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
11820 if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
11829 ** Toggle the reverse_unordered_selects setting.
11831 static void toggleSelectOrder(sqlite3 *db){
11832 sqlite3_stmt *pStmt = 0;
11835 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
11836 if( sqlite3_step(pStmt)==SQLITE_ROW ){
11837 iSetting = sqlite3_column_int(pStmt, 0);
11839 sqlite3_finalize(pStmt);
11840 sqlite3_snprintf(sizeof(zStmt), zStmt,
11841 "PRAGMA reverse_unordered_selects(%d)", !iSetting);
11842 sqlite3_exec(db, zStmt, 0, 0, 0);
11846 ** This is a different callback routine used for dumping the database.
11847 ** Each row received by this callback consists of a table name,
11848 ** the table type ("index" or "table") and SQL to create the table.
11849 ** This routine should print text sufficient to recreate the table.
11851 static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
11853 const char *zTable;
11856 ShellState *p = (ShellState *)pArg;
11858 UNUSED_PARAMETER(azNotUsed);
11859 if( nArg!=3 || azArg==0 ) return 0;
11864 if( strcmp(zTable, "sqlite_sequence")==0 ){
11865 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
11866 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
11867 raw_printf(p->out, "ANALYZE sqlite_master;\n");
11868 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
11870 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
11872 if( !p->writableSchema ){
11873 raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
11874 p->writableSchema = 1;
11876 zIns = sqlite3_mprintf(
11877 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
11878 "VALUES('table','%q','%q',0,'%q');",
11879 zTable, zTable, zSql);
11880 utf8_printf(p->out, "%s\n", zIns);
11881 sqlite3_free(zIns);
11884 printSchemaLine(p->out, zSql, ";\n");
11887 if( strcmp(zType, "table")==0 ){
11892 char *savedDestTable;
11895 azCol = tableColumnList(p, zTable);
11901 /* Always quote the table name, even if it appears to be pure ascii,
11902 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
11904 appendText(&sTable, zTable, quoteChar(zTable));
11905 /* If preserving the rowid, add a column list after the table name.
11906 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
11907 ** instead of the usual "INSERT INTO tab VALUES(...)".
11910 appendText(&sTable, "(", 0);
11911 appendText(&sTable, azCol[0], 0);
11912 for(i=1; azCol[i]; i++){
11913 appendText(&sTable, ",", 0);
11914 appendText(&sTable, azCol[i], quoteChar(azCol[i]));
11916 appendText(&sTable, ")", 0);
11919 /* Build an appropriate SELECT statement */
11920 initText(&sSelect);
11921 appendText(&sSelect, "SELECT ", 0);
11923 appendText(&sSelect, azCol[0], 0);
11924 appendText(&sSelect, ",", 0);
11926 for(i=1; azCol[i]; i++){
11927 appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
11929 appendText(&sSelect, ",", 0);
11932 freeColumnList(azCol);
11933 appendText(&sSelect, " FROM ", 0);
11934 appendText(&sSelect, zTable, quoteChar(zTable));
11936 savedDestTable = p->zDestTable;
11937 savedMode = p->mode;
11938 p->zDestTable = sTable.z;
11939 p->mode = p->cMode = MODE_Insert;
11940 rc = shell_exec(p, sSelect.z, 0);
11941 if( (rc&0xff)==SQLITE_CORRUPT ){
11942 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
11943 toggleSelectOrder(p->db);
11944 shell_exec(p, sSelect.z, 0);
11945 toggleSelectOrder(p->db);
11947 p->zDestTable = savedDestTable;
11948 p->mode = savedMode;
11950 freeText(&sSelect);
11951 if( rc ) p->nErr++;
11957 ** Run zQuery. Use dump_callback() as the callback routine so that
11958 ** the contents of the query are output as SQL statements.
11960 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
11961 ** "ORDER BY rowid DESC" to the end.
11963 static int run_schema_dump_query(
11969 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
11970 if( rc==SQLITE_CORRUPT ){
11972 int len = strlen30(zQuery);
11973 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
11975 utf8_printf(p->out, "/****** %s ******/\n", zErr);
11976 sqlite3_free(zErr);
11979 zQ2 = malloc( len+100 );
11980 if( zQ2==0 ) return rc;
11981 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
11982 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
11984 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr);
11986 rc = SQLITE_CORRUPT;
11988 sqlite3_free(zErr);
11995 ** Text of help messages.
11997 ** The help text for each individual command begins with a line that starts
11998 ** with ".". Subsequent lines are supplimental information.
12000 ** There must be two or more spaces between the end of the command and the
12001 ** start of the description of what that command does.
12003 static const char *(azHelp[]) = {
12004 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
12005 ".archive ... Manage SQL archives",
12006 " Each command must have exactly one of the following options:",
12007 " -c, --create Create a new archive",
12008 " -u, --update Add or update files with changed mtime",
12009 " -i, --insert Like -u but always add even if unchanged",
12010 " -t, --list List contents of archive",
12011 " -x, --extract Extract files from archive",
12012 " Optional arguments:",
12013 " -v, --verbose Print each filename as it is processed",
12014 " -f FILE, --file FILE Use archive FILE (default is current db)",
12015 " -a FILE, --append FILE Open FILE using the apndvfs VFS",
12016 " -C DIR, --directory DIR Read/extract files from directory DIR",
12017 " -n, --dryrun Show the SQL that would have occurred",
12019 " .ar -cf ARCHIVE foo bar # Create ARCHIVE from files foo and bar",
12020 " .ar -tf ARCHIVE # List members of ARCHIVE",
12021 " .ar -xvf ARCHIVE # Verbosely extract files from ARCHIVE",
12023 " http://sqlite.org/cli.html#sqlar_archive_support",
12025 #ifndef SQLITE_OMIT_AUTHORIZATION
12026 ".auth ON|OFF Show authorizer callbacks",
12028 ".backup ?DB? FILE Backup DB (default \"main\") to FILE",
12029 " --append Use the appendvfs",
12030 " --async Write to FILE without journal and fsync()",
12031 ".bail on|off Stop after hitting an error. Default OFF",
12032 ".binary on|off Turn binary output on or off. Default OFF",
12033 ".cd DIRECTORY Change the working directory to DIRECTORY",
12034 ".changes on|off Show number of rows changed by SQL",
12035 ".check GLOB Fail if output since .testcase does not match",
12036 ".clone NEWDB Clone data into NEWDB from the existing database",
12037 ".databases List names and files of attached databases",
12038 ".dbconfig ?op? ?val? List or change sqlite3_db_config() options",
12039 ".dbinfo ?DB? Show status information about the database",
12040 ".dump ?TABLE? ... Render all database content as SQL",
12042 " --preserve-rowids Include ROWID values in the output",
12043 " --newlines Allow unescaped newline characters in output",
12044 " TABLE is a LIKE pattern for the tables to dump",
12045 ".echo on|off Turn command echo on or off",
12046 ".eqp on|off|full|... Enable or disable automatic EXPLAIN QUERY PLAN",
12048 #ifdef SQLITE_DEBUG
12049 " test Show raw EXPLAIN QUERY PLAN output",
12050 " trace Like \"full\" but enable \"PRAGMA vdbe_trace\"",
12052 " trigger Like \"full\" but also show trigger bytecode",
12053 ".excel Display the output of next command in spreadsheet",
12054 ".exit ?CODE? Exit this program with return-code CODE",
12055 ".expert EXPERIMENTAL. Suggest indexes for queries",
12056 /* Because explain mode comes on automatically now, the ".explain" mode
12057 ** is removed from the help screen. It is still supported for legacy, however */
12058 /*".explain ?on|off|auto? Turn EXPLAIN output mode on or off",*/
12059 ".filectrl CMD ... Run various sqlite3_file_control() operations",
12060 " Run \".filectrl\" with no arguments for details",
12061 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables",
12062 ".headers on|off Turn display of headers on or off",
12063 ".help ?-all? ?PATTERN? Show help text for PATTERN",
12064 ".import FILE TABLE Import data from FILE into TABLE",
12065 #ifndef SQLITE_OMIT_TEST_CONTROL
12066 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX",
12068 ".indexes ?TABLE? Show names of indexes",
12069 " If TABLE is specified, only show indexes for",
12070 " tables matching TABLE using the LIKE operator.",
12071 #ifdef SQLITE_ENABLE_IOTRACE
12072 ".iotrace FILE Enable I/O diagnostic logging to FILE",
12074 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT",
12075 ".lint OPTIONS Report potential schema issues.",
12077 " fkey-indexes Find missing foreign key indexes",
12078 #ifndef SQLITE_OMIT_LOAD_EXTENSION
12079 ".load FILE ?ENTRY? Load an extension library",
12081 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout",
12082 ".mode MODE ?TABLE? Set output mode",
12083 " MODE is one of:",
12084 " ascii Columns/rows delimited by 0x1F and 0x1E",
12085 " csv Comma-separated values",
12086 " column Left-aligned columns. (See .width)",
12087 " html HTML <table> code",
12088 " insert SQL insert statements for TABLE",
12089 " line One value per line",
12090 " list Values delimited by \"|\"",
12091 " quote Escape answers as for SQL",
12092 " tabs Tab-separated values",
12093 " tcl TCL list elements",
12094 ".nullvalue STRING Use STRING in place of NULL values",
12095 ".once (-e|-x|FILE) Output for the next SQL command only to FILE",
12096 " If FILE begins with '|' then open as a pipe",
12098 " -e Invoke system text editor",
12099 " -x Open in a spreadsheet",
12100 ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE",
12102 " --append Use appendvfs to append database to the end of FILE",
12103 #ifdef SQLITE_ENABLE_DESERIALIZE
12104 " --deserialize Load into memory useing sqlite3_deserialize()",
12105 " --hexdb Load the output of \"dbtotxt\" as an in-memory db",
12106 " --maxsize N Maximum size for --hexdb or --deserialized database",
12108 " --new Initialize FILE to an empty database",
12109 " --readonly Open FILE readonly",
12110 " --zip FILE is a ZIP archive",
12111 ".output ?FILE? Send output to FILE or stdout if FILE is omitted",
12112 " If FILE begins with '|' then open it as a pipe.",
12113 ".parameter CMD ... Manage SQL parameter bindings",
12114 " clear Erase all bindings",
12115 " init Initialize the TEMP table that holds bindings",
12116 " list List the current parameter bindings",
12117 " set PARAMETER VALUE Given SQL parameter PARAMETER a value of VALUE",
12118 " PARAMETER should start with one of: $ : @ ?",
12119 " unset PARAMETER Remove PARAMETER from the binding table",
12120 ".print STRING... Print literal STRING",
12121 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
12122 ".progress N Invoke progress handler after every N opcodes",
12123 " --limit N Interrupt after N progress callbacks",
12124 " --once Do no more than one progress interrupt",
12125 " --quiet|-q No output except at interrupts",
12126 " --reset Reset the count for each input and interrupt",
12128 ".prompt MAIN CONTINUE Replace the standard prompts",
12129 ".quit Exit this program",
12130 ".read FILE Read input from FILE",
12131 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
12132 ".recover Recover as much data as possible from corrupt db.",
12133 " --freelist-corrupt Assume the freelist is corrupt",
12134 " --recovery-db NAME Store recovery metadata in database file NAME",
12135 " --lost-and-found TABLE Alternative name for the lost-and-found table",
12136 " --no-rowids Do not attempt to recover rowid values",
12137 " that are not also INTEGER PRIMARY KEYs",
12139 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE",
12140 ".save FILE Write in-memory database into FILE",
12141 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off",
12142 ".schema ?PATTERN? Show the CREATE statements matching PATTERN",
12144 " --indent Try to pretty-print the schema",
12145 ".selftest ?OPTIONS? Run tests defined in the SELFTEST table",
12147 " --init Create a new SELFTEST table",
12148 " -v Verbose output",
12149 ".separator COL ?ROW? Change the column and row separators",
12150 #if defined(SQLITE_ENABLE_SESSION)
12151 ".session ?NAME? CMD ... Create or control sessions",
12153 " attach TABLE Attach TABLE",
12154 " changeset FILE Write a changeset into FILE",
12155 " close Close one session",
12156 " enable ?BOOLEAN? Set or query the enable bit",
12157 " filter GLOB... Reject tables matching GLOBs",
12158 " indirect ?BOOLEAN? Mark or query the indirect status",
12159 " isempty Query whether the session is empty",
12160 " list List currently open session names",
12161 " open DB NAME Open a new session on DB",
12162 " patchset FILE Write a patchset into FILE",
12163 " If ?NAME? is omitted, the first defined session is used.",
12165 ".sha3sum ... Compute a SHA3 hash of database content",
12167 " --schema Also hash the sqlite_master table",
12168 " --sha3-224 Use the sha3-224 algorithm",
12169 " --sha3-256 Use the sha3-256 algorithm (default)",
12170 " --sha3-384 Use the sha3-384 algorithm",
12171 " --sha3-512 Use the sha3-512 algorithm",
12172 " Any other argument is a LIKE pattern for tables to hash",
12173 #ifndef SQLITE_NOHAVE_SYSTEM
12174 ".shell CMD ARGS... Run CMD ARGS... in a system shell",
12176 ".show Show the current values for various settings",
12177 ".stats ?on|off? Show stats or turn stats on or off",
12178 #ifndef SQLITE_NOHAVE_SYSTEM
12179 ".system CMD ARGS... Run CMD ARGS... in a system shell",
12181 ".tables ?TABLE? List names of tables matching LIKE pattern TABLE",
12182 ".testcase NAME Begin redirecting output to 'testcase-out.txt'",
12183 ".testctrl CMD ... Run various sqlite3_test_control() operations",
12184 " Run \".testctrl\" with no arguments for details",
12185 ".timeout MS Try opening locked tables for MS milliseconds",
12186 ".timer on|off Turn SQL timer on or off",
12187 #ifndef SQLITE_OMIT_TRACE
12188 ".trace ?OPTIONS? Output each SQL statement as it is run",
12189 " FILE Send output to FILE",
12190 " stdout Send output to stdout",
12191 " stderr Send output to stderr",
12192 " off Disable tracing",
12193 " --expanded Expand query parameters",
12194 #ifdef SQLITE_ENABLE_NORMALIZE
12195 " --normalized Normal the SQL statements",
12197 " --plain Show SQL as it is input",
12198 " --stmt Trace statement execution (SQLITE_TRACE_STMT)",
12199 " --profile Profile statements (SQLITE_TRACE_PROFILE)",
12200 " --row Trace each row (SQLITE_TRACE_ROW)",
12201 " --close Trace connection close (SQLITE_TRACE_CLOSE)",
12202 #endif /* SQLITE_OMIT_TRACE */
12203 #ifdef SQLITE_DEBUG
12204 ".unmodule NAME ... Unregister virtual table modules",
12205 " --allexcept Unregister everything except those named",
12207 ".vfsinfo ?AUX? Information about the top-level VFS",
12208 ".vfslist List all available VFSes",
12209 ".vfsname ?AUX? Print the name of the VFS stack",
12210 ".width NUM1 NUM2 ... Set column widths for \"column\" mode",
12211 " Negative values right-justify",
12215 ** Output help text.
12217 ** zPattern describes the set of commands for which help text is provided.
12218 ** If zPattern is NULL, then show all commands, but only give a one-line
12219 ** description of each.
12221 ** Return the number of matches.
12223 static int showHelp(FILE *out, const char *zPattern){
12229 || zPattern[0]=='0'
12230 || strcmp(zPattern,"-a")==0
12231 || strcmp(zPattern,"-all")==0
12233 /* Show all commands, but only one line per command */
12234 if( zPattern==0 ) zPattern = "";
12235 for(i=0; i<ArraySize(azHelp); i++){
12236 if( azHelp[i][0]=='.' || zPattern[0] ){
12237 utf8_printf(out, "%s\n", azHelp[i]);
12242 /* Look for commands that for which zPattern is an exact prefix */
12243 zPat = sqlite3_mprintf(".%s*", zPattern);
12244 for(i=0; i<ArraySize(azHelp); i++){
12245 if( sqlite3_strglob(zPat, azHelp[i])==0 ){
12246 utf8_printf(out, "%s\n", azHelp[i]);
12251 sqlite3_free(zPat);
12254 /* when zPattern is a prefix of exactly one command, then include the
12255 ** details of that command, which should begin at offset j */
12256 while( j<ArraySize(azHelp)-1 && azHelp[j][0]!='.' ){
12257 utf8_printf(out, "%s\n", azHelp[j]);
12263 /* Look for commands that contain zPattern anywhere. Show the complete
12264 ** text of all commands that match. */
12265 zPat = sqlite3_mprintf("%%%s%%", zPattern);
12266 for(i=0; i<ArraySize(azHelp); i++){
12267 if( azHelp[i][0]=='.' ) j = i;
12268 if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){
12269 utf8_printf(out, "%s\n", azHelp[j]);
12270 while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]!='.' ){
12272 utf8_printf(out, "%s\n", azHelp[j]);
12278 sqlite3_free(zPat);
12283 /* Forward reference */
12284 static int process_input(ShellState *p);
12287 ** Read the content of file zName into memory obtained from sqlite3_malloc64()
12288 ** and return a pointer to the buffer. The caller is responsible for freeing
12291 ** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes
12294 ** For convenience, a nul-terminator byte is always appended to the data read
12295 ** from the file before the buffer is returned. This byte is not included in
12296 ** the final value of (*pnByte), if applicable.
12298 ** NULL is returned if any error is encountered. The final value of *pnByte
12299 ** is undefined in this case.
12301 static char *readFile(const char *zName, int *pnByte){
12302 FILE *in = fopen(zName, "rb");
12306 if( in==0 ) return 0;
12307 fseek(in, 0, SEEK_END);
12310 pBuf = sqlite3_malloc64( nIn+1 );
12311 if( pBuf==0 ){ fclose(in); return 0; }
12312 nRead = fread(pBuf, nIn, 1, in);
12315 sqlite3_free(pBuf);
12319 if( pnByte ) *pnByte = nIn;
12323 #if defined(SQLITE_ENABLE_SESSION)
12325 ** Close a single OpenSession object and release all of its associated
12328 static void session_close(OpenSession *pSession){
12330 sqlite3session_delete(pSession->p);
12331 sqlite3_free(pSession->zName);
12332 for(i=0; i<pSession->nFilter; i++){
12333 sqlite3_free(pSession->azFilter[i]);
12335 sqlite3_free(pSession->azFilter);
12336 memset(pSession, 0, sizeof(OpenSession));
12341 ** Close all OpenSession objects and release all associated resources.
12343 #if defined(SQLITE_ENABLE_SESSION)
12344 static void session_close_all(ShellState *p){
12346 for(i=0; i<p->nSession; i++){
12347 session_close(&p->aSession[i]);
12352 # define session_close_all(X)
12356 ** Implementation of the xFilter function for an open session. Omit
12357 ** any tables named by ".session filter" but let all other table through.
12359 #if defined(SQLITE_ENABLE_SESSION)
12360 static int session_filter(void *pCtx, const char *zTab){
12361 OpenSession *pSession = (OpenSession*)pCtx;
12363 for(i=0; i<pSession->nFilter; i++){
12364 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0;
12371 ** Try to deduce the type of file for zName based on its content. Return
12372 ** one of the SHELL_OPEN_* constants.
12374 ** If the file does not exist or is empty but its name looks like a ZIP
12375 ** archive and the dfltZip flag is true, then assume it is a ZIP archive.
12376 ** Otherwise, assume an ordinary database regardless of the filename if
12377 ** the type cannot be determined from content.
12379 int deduceDatabaseType(const char *zName, int dfltZip){
12380 FILE *f = fopen(zName, "rb");
12382 int rc = SHELL_OPEN_UNSPEC;
12385 if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
12386 return SHELL_OPEN_ZIPFILE;
12388 return SHELL_OPEN_NORMAL;
12391 n = fread(zBuf, 16, 1, f);
12392 if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){
12394 return SHELL_OPEN_NORMAL;
12396 fseek(f, -25, SEEK_END);
12397 n = fread(zBuf, 25, 1, f);
12398 if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){
12399 rc = SHELL_OPEN_APPENDVFS;
12401 fseek(f, -22, SEEK_END);
12402 n = fread(zBuf, 22, 1, f);
12403 if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05
12404 && zBuf[3]==0x06 ){
12405 rc = SHELL_OPEN_ZIPFILE;
12406 }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
12407 rc = SHELL_OPEN_ZIPFILE;
12414 #ifdef SQLITE_ENABLE_DESERIALIZE
12416 ** Reconstruct an in-memory database using the output from the "dbtotxt"
12417 ** program. Read content from the file in p->zDbFilename. If p->zDbFilename
12418 ** is 0, then read from standard input.
12420 static unsigned char *readHexDb(ShellState *p, int *pnData){
12421 unsigned char *a = 0;
12429 unsigned int x[16];
12431 if( p->zDbFilename ){
12432 in = fopen(p->zDbFilename, "r");
12434 utf8_printf(stderr, "cannot open \"%s\" for reading\n", p->zDbFilename);
12441 if( in==0 ) in = stdin;
12445 if( fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error;
12446 rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz);
12447 if( rc!=2 ) goto readHexDb_error;
12448 if( n<0 ) goto readHexDb_error;
12449 if( pgsz<512 || pgsz>65536 || (pgsz&(pgsz-1))!=0 ) goto readHexDb_error;
12450 n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */
12451 a = sqlite3_malloc( n ? n : 1 );
12453 utf8_printf(stderr, "Out of memory!\n");
12454 goto readHexDb_error;
12457 if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){
12458 utf8_printf(stderr, "invalid pagesize\n");
12459 goto readHexDb_error;
12461 for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){
12462 rc = sscanf(zLine, "| page %d offset %d", &j, &k);
12467 if( strncmp(zLine, "| end ", 6)==0 ){
12470 rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
12471 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7],
12472 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]);
12477 for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff;
12493 while( fgets(zLine, sizeof(zLine), p->in)!=0 ){
12495 if(strncmp(zLine, "| end ", 6)==0 ) break;
12500 utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine);
12503 #endif /* SQLITE_ENABLE_DESERIALIZE */
12506 ** Scalar function "shell_int32". The first argument to this function
12507 ** must be a blob. The second a non-negative integer. This function
12508 ** reads and returns a 32-bit big-endian integer from byte
12509 ** offset (4*<arg2>) of the blob.
12511 static void shellInt32(
12512 sqlite3_context *context,
12514 sqlite3_value **argv
12516 const unsigned char *pBlob;
12520 UNUSED_PARAMETER(argc);
12521 nBlob = sqlite3_value_bytes(argv[0]);
12522 pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]);
12523 iInt = sqlite3_value_int(argv[1]);
12525 if( iInt>=0 && (iInt+1)*4<=nBlob ){
12526 const unsigned char *a = &pBlob[iInt*4];
12527 sqlite3_int64 iVal = ((sqlite3_int64)a[0]<<24)
12528 + ((sqlite3_int64)a[1]<<16)
12529 + ((sqlite3_int64)a[2]<< 8)
12530 + ((sqlite3_int64)a[3]<< 0);
12531 sqlite3_result_int64(context, iVal);
12536 ** Scalar function "shell_idquote(X)" returns string X quoted as an identifier,
12537 ** using "..." with internal double-quote characters doubled.
12539 static void shellIdQuote(
12540 sqlite3_context *context,
12542 sqlite3_value **argv
12544 const char *zName = (const char*)sqlite3_value_text(argv[0]);
12545 UNUSED_PARAMETER(argc);
12547 char *z = sqlite3_mprintf("\"%w\"", zName);
12548 sqlite3_result_text(context, z, -1, sqlite3_free);
12553 ** Scalar function "shell_escape_crnl" used by the .recover command.
12554 ** The argument passed to this function is the output of built-in
12555 ** function quote(). If the first character of the input is "'",
12556 ** indicating that the value passed to quote() was a text value,
12557 ** then this function searches the input for "\n" and "\r" characters
12558 ** and adds a wrapper similar to the following:
12560 ** replace(replace(<input>, '\n', char(10), '\r', char(13));
12562 ** Or, if the first character of the input is not "'", then a copy
12563 ** of the input is returned.
12565 static void shellEscapeCrnl(
12566 sqlite3_context *context,
12568 sqlite3_value **argv
12570 const char *zText = (const char*)sqlite3_value_text(argv[0]);
12571 UNUSED_PARAMETER(argc);
12572 if( zText[0]=='\'' ){
12573 int nText = sqlite3_value_bytes(argv[0]);
12577 const char *zNL = 0;
12578 const char *zCR = 0;
12582 for(i=0; zText[i]; i++){
12583 if( zNL==0 && zText[i]=='\n' ){
12584 zNL = unused_string(zText, "\\n", "\\012", zBuf1);
12585 nNL = (int)strlen(zNL);
12587 if( zCR==0 && zText[i]=='\r' ){
12588 zCR = unused_string(zText, "\\r", "\\015", zBuf2);
12589 nCR = (int)strlen(zCR);
12595 i64 nMax = (nNL > nCR) ? nNL : nCR;
12596 i64 nAlloc = nMax * nText + (nMax+64)*2;
12597 char *zOut = (char*)sqlite3_malloc64(nAlloc);
12599 sqlite3_result_error_nomem(context);
12604 memcpy(&zOut[iOut], "replace(replace(", 16);
12607 memcpy(&zOut[iOut], "replace(", 8);
12610 for(i=0; zText[i]; i++){
12611 if( zText[i]=='\n' ){
12612 memcpy(&zOut[iOut], zNL, nNL);
12614 }else if( zText[i]=='\r' ){
12615 memcpy(&zOut[iOut], zCR, nCR);
12618 zOut[iOut] = zText[i];
12624 memcpy(&zOut[iOut], ",'", 2); iOut += 2;
12625 memcpy(&zOut[iOut], zNL, nNL); iOut += nNL;
12626 memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12;
12629 memcpy(&zOut[iOut], ",'", 2); iOut += 2;
12630 memcpy(&zOut[iOut], zCR, nCR); iOut += nCR;
12631 memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12;
12634 sqlite3_result_text(context, zOut, iOut, SQLITE_TRANSIENT);
12635 sqlite3_free(zOut);
12640 sqlite3_result_value(context, argv[0]);
12643 /* Flags for open_db().
12645 ** The default behavior of open_db() is to exit(1) if the database fails to
12646 ** open. The OPEN_DB_KEEPALIVE flag changes that so that it prints an error
12647 ** but still returns without calling exit.
12649 ** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a
12650 ** ZIP archive if the file does not exist or is empty and its name matches
12651 ** the *.zip pattern.
12653 #define OPEN_DB_KEEPALIVE 0x001 /* Return after error if true */
12654 #define OPEN_DB_ZIPFILE 0x002 /* Open as ZIP if name matches *.zip */
12657 ** Make sure the database is open. If it is not, then open it. If
12658 ** the database fails to open, print an error message and exit.
12660 static void open_db(ShellState *p, int openFlags){
12662 if( p->openMode==SHELL_OPEN_UNSPEC ){
12663 if( p->zDbFilename==0 || p->zDbFilename[0]==0 ){
12664 p->openMode = SHELL_OPEN_NORMAL;
12666 p->openMode = (u8)deduceDatabaseType(p->zDbFilename,
12667 (openFlags & OPEN_DB_ZIPFILE)!=0);
12670 switch( p->openMode ){
12671 case SHELL_OPEN_APPENDVFS: {
12672 sqlite3_open_v2(p->zDbFilename, &p->db,
12673 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, "apndvfs");
12676 case SHELL_OPEN_HEXDB:
12677 case SHELL_OPEN_DESERIALIZE: {
12678 sqlite3_open(0, &p->db);
12681 case SHELL_OPEN_ZIPFILE: {
12682 sqlite3_open(":memory:", &p->db);
12685 case SHELL_OPEN_READONLY: {
12686 sqlite3_open_v2(p->zDbFilename, &p->db, SQLITE_OPEN_READONLY, 0);
12689 case SHELL_OPEN_UNSPEC:
12690 case SHELL_OPEN_NORMAL: {
12691 sqlite3_open(p->zDbFilename, &p->db);
12696 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
12697 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
12698 p->zDbFilename, sqlite3_errmsg(p->db));
12699 if( openFlags & OPEN_DB_KEEPALIVE ){
12700 sqlite3_open(":memory:", &p->db);
12705 #ifndef SQLITE_OMIT_LOAD_EXTENSION
12706 sqlite3_enable_load_extension(p->db, 1);
12708 sqlite3_fileio_init(p->db, 0, 0);
12709 sqlite3_shathree_init(p->db, 0, 0);
12710 sqlite3_completion_init(p->db, 0, 0);
12711 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
12712 sqlite3_dbdata_init(p->db, 0, 0);
12714 #ifdef SQLITE_HAVE_ZLIB
12715 sqlite3_zipfile_init(p->db, 0, 0);
12716 sqlite3_sqlar_init(p->db, 0, 0);
12718 sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0,
12719 shellAddSchemaName, 0, 0);
12720 sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, 0,
12721 shellModuleSchema, 0, 0);
12722 sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p,
12723 shellPutsFunc, 0, 0);
12724 sqlite3_create_function(p->db, "shell_escape_crnl", 1, SQLITE_UTF8, 0,
12725 shellEscapeCrnl, 0, 0);
12726 sqlite3_create_function(p->db, "shell_int32", 2, SQLITE_UTF8, 0,
12728 sqlite3_create_function(p->db, "shell_idquote", 1, SQLITE_UTF8, 0,
12729 shellIdQuote, 0, 0);
12730 #ifndef SQLITE_NOHAVE_SYSTEM
12731 sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0,
12733 sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0,
12736 if( p->openMode==SHELL_OPEN_ZIPFILE ){
12737 char *zSql = sqlite3_mprintf(
12738 "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", p->zDbFilename);
12739 sqlite3_exec(p->db, zSql, 0, 0, 0);
12740 sqlite3_free(zSql);
12742 #ifdef SQLITE_ENABLE_DESERIALIZE
12744 if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){
12747 unsigned char *aData;
12748 if( p->openMode==SHELL_OPEN_DESERIALIZE ){
12749 aData = (unsigned char*)readFile(p->zDbFilename, &nData);
12751 aData = readHexDb(p, &nData);
12756 rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
12757 SQLITE_DESERIALIZE_RESIZEABLE |
12758 SQLITE_DESERIALIZE_FREEONCLOSE);
12760 utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc);
12763 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
12771 ** Attempt to close the databaes connection. Report errors.
12773 void close_db(sqlite3 *db){
12774 int rc = sqlite3_close(db);
12776 utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n",
12777 rc, sqlite3_errmsg(db));
12781 #if HAVE_READLINE || HAVE_EDITLINE
12783 ** Readline completion callbacks
12785 static char *readline_completion_generator(const char *text, int state){
12786 static sqlite3_stmt *pStmt = 0;
12790 sqlite3_finalize(pStmt);
12791 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
12792 " FROM completion(%Q) ORDER BY 1", text);
12793 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
12794 sqlite3_free(zSql);
12796 if( sqlite3_step(pStmt)==SQLITE_ROW ){
12797 zRet = strdup((const char*)sqlite3_column_text(pStmt, 0));
12799 sqlite3_finalize(pStmt);
12805 static char **readline_completion(const char *zText, int iStart, int iEnd){
12806 rl_attempted_completion_over = 1;
12807 return rl_completion_matches(zText, readline_completion_generator);
12810 #elif HAVE_LINENOISE
12812 ** Linenoise completion callback
12814 static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){
12815 int nLine = strlen30(zLine);
12817 sqlite3_stmt *pStmt = 0;
12821 if( nLine>sizeof(zBuf)-30 ) return;
12822 if( zLine[0]=='.' || zLine[0]=='#') return;
12823 for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){}
12824 if( i==nLine-1 ) return;
12826 memcpy(zBuf, zLine, iStart);
12827 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
12828 " FROM completion(%Q,%Q) ORDER BY 1",
12829 &zLine[iStart], zLine);
12830 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
12831 sqlite3_free(zSql);
12832 sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */
12833 while( sqlite3_step(pStmt)==SQLITE_ROW ){
12834 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0);
12835 int nCompletion = sqlite3_column_bytes(pStmt, 0);
12836 if( iStart+nCompletion < sizeof(zBuf)-1 ){
12837 memcpy(zBuf+iStart, zCompletion, nCompletion+1);
12838 linenoiseAddCompletion(lc, zBuf);
12841 sqlite3_finalize(pStmt);
12846 ** Do C-language style dequoting.
12852 ** \v -> vertical tab
12854 ** \r -> carriage return
12859 ** \NNN -> ascii character NNN in octal
12861 static void resolve_backslashes(char *z){
12864 while( *z && *z!='\\' ) z++;
12865 for(i=j=0; (c = z[i])!=0; i++, j++){
12866 if( c=='\\' && z[i+1]!=0 ){
12870 }else if( c=='b' ){
12872 }else if( c=='t' ){
12874 }else if( c=='n' ){
12876 }else if( c=='v' ){
12878 }else if( c=='f' ){
12880 }else if( c=='r' ){
12882 }else if( c=='"' ){
12884 }else if( c=='\'' ){
12886 }else if( c=='\\' ){
12888 }else if( c>='0' && c<='7' ){
12890 if( z[i+1]>='0' && z[i+1]<='7' ){
12892 c = (c<<3) + z[i] - '0';
12893 if( z[i+1]>='0' && z[i+1]<='7' ){
12895 c = (c<<3) + z[i] - '0';
12902 if( j<i ) z[j] = 0;
12906 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
12907 ** for TRUE and FALSE. Return the integer value if appropriate.
12909 static int booleanValue(const char *zArg){
12911 if( zArg[0]=='0' && zArg[1]=='x' ){
12912 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
12914 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
12916 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
12917 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
12920 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
12923 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
12929 ** Set or clear a shell flag according to a boolean value.
12931 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
12932 if( booleanValue(zArg) ){
12933 ShellSetFlag(p, mFlag);
12935 ShellClearFlag(p, mFlag);
12940 ** Close an output file, assuming it is not stderr or stdout
12942 static void output_file_close(FILE *f){
12943 if( f && f!=stdout && f!=stderr ) fclose(f);
12947 ** Try to open an output file. The names "stdout" and "stderr" are
12948 ** recognized and do the right thing. NULL is returned if the output
12949 ** filename is "off".
12951 static FILE *output_file_open(const char *zFile, int bTextMode){
12953 if( strcmp(zFile,"stdout")==0 ){
12955 }else if( strcmp(zFile, "stderr")==0 ){
12957 }else if( strcmp(zFile, "off")==0 ){
12960 f = fopen(zFile, bTextMode ? "w" : "wb");
12962 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
12968 #ifndef SQLITE_OMIT_TRACE
12970 ** A routine for handling output from sqlite3_trace().
12972 static int sql_trace_callback(
12973 unsigned mType, /* The trace type */
12974 void *pArg, /* The ShellState pointer */
12975 void *pP, /* Usually a pointer to sqlite_stmt */
12976 void *pX /* Auxiliary output */
12978 ShellState *p = (ShellState*)pArg;
12979 sqlite3_stmt *pStmt;
12982 if( p->traceOut==0 ) return 0;
12983 if( mType==SQLITE_TRACE_CLOSE ){
12984 utf8_printf(p->traceOut, "-- closing database connection\n");
12987 if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){
12988 zSql = (const char*)pX;
12990 pStmt = (sqlite3_stmt*)pP;
12991 switch( p->eTraceType ){
12992 case SHELL_TRACE_EXPANDED: {
12993 zSql = sqlite3_expanded_sql(pStmt);
12996 #ifdef SQLITE_ENABLE_NORMALIZE
12997 case SHELL_TRACE_NORMALIZED: {
12998 zSql = sqlite3_normalized_sql(pStmt);
13003 zSql = sqlite3_sql(pStmt);
13008 if( zSql==0 ) return 0;
13009 nSql = strlen30(zSql);
13010 while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
13012 case SQLITE_TRACE_ROW:
13013 case SQLITE_TRACE_STMT: {
13014 utf8_printf(p->traceOut, "%.*s;\n", nSql, zSql);
13017 case SQLITE_TRACE_PROFILE: {
13018 sqlite3_int64 nNanosec = *(sqlite3_int64*)pX;
13019 utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", nSql, zSql, nNanosec);
13028 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
13029 ** a useful spot to set a debugger breakpoint.
13031 static void test_breakpoint(void){
13032 static int nCall = 0;
13037 ** An object used to read a CSV and other files for import.
13039 typedef struct ImportCtx ImportCtx;
13041 const char *zFile; /* Name of the input file */
13042 FILE *in; /* Read the CSV text from this input stream */
13043 char *z; /* Accumulated text for a field */
13044 int n; /* Number of bytes in z */
13045 int nAlloc; /* Space allocated for z[] */
13046 int nLine; /* Current line number */
13047 int bNotFirst; /* True if one or more bytes already read */
13048 int cTerm; /* Character that terminated the most recent field */
13049 int cColSep; /* The column separator character. (Usually ",") */
13050 int cRowSep; /* The row separator character. (Usually "\n") */
13053 /* Append a single byte to z[] */
13054 static void import_append_char(ImportCtx *p, int c){
13055 if( p->n+1>=p->nAlloc ){
13056 p->nAlloc += p->nAlloc + 100;
13057 p->z = sqlite3_realloc64(p->z, p->nAlloc);
13058 if( p->z==0 ) shell_out_of_memory();
13060 p->z[p->n++] = (char)c;
13063 /* Read a single field of CSV text. Compatible with rfc4180 and extended
13064 ** with the option of having a separator other than ",".
13066 ** + Input comes from p->in.
13067 ** + Store results in p->z of length p->n. Space to hold p->z comes
13068 ** from sqlite3_malloc64().
13069 ** + Use p->cSep as the column separator. The default is ",".
13070 ** + Use p->rSep as the row separator. The default is "\n".
13071 ** + Keep track of the line number in p->nLine.
13072 ** + Store the character that terminates the field in p->cTerm. Store
13073 ** EOF on end-of-file.
13074 ** + Report syntax errors on stderr
13076 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
13078 int cSep = p->cColSep;
13079 int rSep = p->cRowSep;
13082 if( c==EOF || seenInterrupt ){
13088 int startLine = p->nLine;
13093 if( c==rSep ) p->nLine++;
13100 if( (c==cSep && pc==cQuote)
13101 || (c==rSep && pc==cQuote)
13102 || (c==rSep && pc=='\r' && ppc==cQuote)
13103 || (c==EOF && pc==cQuote)
13105 do{ p->n--; }while( p->z[p->n]!=cQuote );
13109 if( pc==cQuote && c!='\r' ){
13110 utf8_printf(stderr, "%s:%d: unescaped %c character\n",
13111 p->zFile, p->nLine, cQuote);
13114 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
13115 p->zFile, startLine, cQuote);
13119 import_append_char(p, c);
13124 /* If this is the first field being parsed and it begins with the
13125 ** UTF-8 BOM (0xEF BB BF) then skip the BOM */
13126 if( (c&0xff)==0xef && p->bNotFirst==0 ){
13127 import_append_char(p, c);
13129 if( (c&0xff)==0xbb ){
13130 import_append_char(p, c);
13132 if( (c&0xff)==0xbf ){
13135 return csv_read_one_field(p);
13139 while( c!=EOF && c!=cSep && c!=rSep ){
13140 import_append_char(p, c);
13145 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
13149 if( p->z ) p->z[p->n] = 0;
13154 /* Read a single field of ASCII delimited text.
13156 ** + Input comes from p->in.
13157 ** + Store results in p->z of length p->n. Space to hold p->z comes
13158 ** from sqlite3_malloc64().
13159 ** + Use p->cSep as the column separator. The default is "\x1F".
13160 ** + Use p->rSep as the row separator. The default is "\x1E".
13161 ** + Keep track of the row number in p->nLine.
13162 ** + Store the character that terminates the field in p->cTerm. Store
13163 ** EOF on end-of-file.
13164 ** + Report syntax errors on stderr
13166 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
13168 int cSep = p->cColSep;
13169 int rSep = p->cRowSep;
13172 if( c==EOF || seenInterrupt ){
13176 while( c!=EOF && c!=cSep && c!=rSep ){
13177 import_append_char(p, c);
13184 if( p->z ) p->z[p->n] = 0;
13189 ** Try to transfer data for table zTable. If an error is seen while
13190 ** moving forward, try to go backwards. The backwards movement won't
13191 ** work for WITHOUT ROWID tables.
13193 static void tryToCloneData(
13198 sqlite3_stmt *pQuery = 0;
13199 sqlite3_stmt *pInsert = 0;
13204 int nTable = strlen30(zTable);
13207 const int spinRate = 10000;
13209 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
13210 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13212 utf8_printf(stderr, "Error %d: %s on [%s]\n",
13213 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13215 goto end_data_xfer;
13217 n = sqlite3_column_count(pQuery);
13218 zInsert = sqlite3_malloc64(200 + nTable + n*3);
13219 if( zInsert==0 ) shell_out_of_memory();
13220 sqlite3_snprintf(200+nTable,zInsert,
13221 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
13222 i = strlen30(zInsert);
13223 for(j=1; j<n; j++){
13224 memcpy(zInsert+i, ",?", 2);
13227 memcpy(zInsert+i, ");", 3);
13228 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
13230 utf8_printf(stderr, "Error %d: %s on [%s]\n",
13231 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
13233 goto end_data_xfer;
13235 for(k=0; k<2; k++){
13236 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13237 for(i=0; i<n; i++){
13238 switch( sqlite3_column_type(pQuery, i) ){
13239 case SQLITE_NULL: {
13240 sqlite3_bind_null(pInsert, i+1);
13243 case SQLITE_INTEGER: {
13244 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
13247 case SQLITE_FLOAT: {
13248 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
13251 case SQLITE_TEXT: {
13252 sqlite3_bind_text(pInsert, i+1,
13253 (const char*)sqlite3_column_text(pQuery,i),
13254 -1, SQLITE_STATIC);
13257 case SQLITE_BLOB: {
13258 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
13259 sqlite3_column_bytes(pQuery,i),
13265 rc = sqlite3_step(pInsert);
13266 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
13267 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
13268 sqlite3_errmsg(newDb));
13270 sqlite3_reset(pInsert);
13272 if( (cnt%spinRate)==0 ){
13273 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
13277 if( rc==SQLITE_DONE ) break;
13278 sqlite3_finalize(pQuery);
13279 sqlite3_free(zQuery);
13280 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
13282 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13284 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
13287 } /* End for(k=0...) */
13290 sqlite3_finalize(pQuery);
13291 sqlite3_finalize(pInsert);
13292 sqlite3_free(zQuery);
13293 sqlite3_free(zInsert);
13298 ** Try to transfer all rows of the schema that match zWhere. For
13299 ** each row, invoke xForEach() on the object defined by that row.
13300 ** If an error is encountered while moving forward through the
13301 ** sqlite_master table, try again moving backwards.
13303 static void tryToCloneSchema(
13306 const char *zWhere,
13307 void (*xForEach)(ShellState*,sqlite3*,const char*)
13309 sqlite3_stmt *pQuery = 0;
13312 const unsigned char *zName;
13313 const unsigned char *zSql;
13316 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
13317 " WHERE %s", zWhere);
13318 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13320 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
13321 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13323 goto end_schema_xfer;
13325 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13326 zName = sqlite3_column_text(pQuery, 0);
13327 zSql = sqlite3_column_text(pQuery, 1);
13328 printf("%s... ", zName); fflush(stdout);
13329 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
13331 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
13332 sqlite3_free(zErrMsg);
13336 xForEach(p, newDb, (const char*)zName);
13340 if( rc!=SQLITE_DONE ){
13341 sqlite3_finalize(pQuery);
13342 sqlite3_free(zQuery);
13343 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
13344 " WHERE %s ORDER BY rowid DESC", zWhere);
13345 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13347 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
13348 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13350 goto end_schema_xfer;
13352 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13353 zName = sqlite3_column_text(pQuery, 0);
13354 zSql = sqlite3_column_text(pQuery, 1);
13355 printf("%s... ", zName); fflush(stdout);
13356 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
13358 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
13359 sqlite3_free(zErrMsg);
13363 xForEach(p, newDb, (const char*)zName);
13369 sqlite3_finalize(pQuery);
13370 sqlite3_free(zQuery);
13374 ** Open a new database file named "zNewDb". Try to recover as much information
13375 ** as possible out of the main database (which might be corrupt) and write it
13378 static void tryToClone(ShellState *p, const char *zNewDb){
13380 sqlite3 *newDb = 0;
13381 if( access(zNewDb,0)==0 ){
13382 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
13385 rc = sqlite3_open(zNewDb, &newDb);
13387 utf8_printf(stderr, "Cannot create output database: %s\n",
13388 sqlite3_errmsg(newDb));
13390 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
13391 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
13392 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
13393 tryToCloneSchema(p, newDb, "type!='table'", 0);
13394 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
13395 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
13401 ** Change the output file back to stdout.
13403 ** If the p->doXdgOpen flag is set, that means the output was being
13404 ** redirected to a temporary file named by p->zTempFile. In that case,
13405 ** launch start/open/xdg-open on that temporary file.
13407 static void output_reset(ShellState *p){
13408 if( p->outfile[0]=='|' ){
13409 #ifndef SQLITE_OMIT_POPEN
13413 output_file_close(p->out);
13414 #ifndef SQLITE_NOHAVE_SYSTEM
13415 if( p->doXdgOpen ){
13416 const char *zXdgOpenCmd =
13417 #if defined(_WIN32)
13419 #elif defined(__APPLE__)
13425 zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
13426 if( system(zCmd) ){
13427 utf8_printf(stderr, "Failed: [%s]\n", zCmd);
13429 sqlite3_free(zCmd);
13432 sqlite3_sleep(100);
13434 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
13441 ** Run an SQL command and return the single integer result.
13443 static int db_int(ShellState *p, const char *zSql){
13444 sqlite3_stmt *pStmt;
13446 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
13447 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
13448 res = sqlite3_column_int(pStmt,0);
13450 sqlite3_finalize(pStmt);
13455 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
13457 static unsigned int get2byteInt(unsigned char *a){
13458 return (a[0]<<8) + a[1];
13460 static unsigned int get4byteInt(unsigned char *a){
13461 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
13465 ** Implementation of the ".info" command.
13467 ** Return 1 on error, 2 to exit, and 0 otherwise.
13469 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
13470 static const struct { const char *zName; int ofst; } aField[] = {
13471 { "file change counter:", 24 },
13472 { "database page count:", 28 },
13473 { "freelist page count:", 36 },
13474 { "schema cookie:", 40 },
13475 { "schema format:", 44 },
13476 { "default cache size:", 48 },
13477 { "autovacuum top root:", 52 },
13478 { "incremental vacuum:", 64 },
13479 { "text encoding:", 56 },
13480 { "user version:", 60 },
13481 { "application id:", 68 },
13482 { "software version:", 96 },
13484 static const struct { const char *zName; const char *zSql; } aQuery[] = {
13485 { "number of tables:",
13486 "SELECT count(*) FROM %s WHERE type='table'" },
13487 { "number of indexes:",
13488 "SELECT count(*) FROM %s WHERE type='index'" },
13489 { "number of triggers:",
13490 "SELECT count(*) FROM %s WHERE type='trigger'" },
13491 { "number of views:",
13492 "SELECT count(*) FROM %s WHERE type='view'" },
13494 "SELECT total(length(sql)) FROM %s" },
13497 unsigned iDataVersion;
13499 char *zDb = nArg>=2 ? azArg[1] : "main";
13500 sqlite3_stmt *pStmt = 0;
13501 unsigned char aHdr[100];
13503 if( p->db==0 ) return 1;
13504 rc = sqlite3_prepare_v2(p->db,
13505 "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
13508 if( !sqlite3_compileoption_used("ENABLE_DBPAGE_VTAB") ){
13509 utf8_printf(stderr, "the \".dbinfo\" command requires the "
13510 "-DSQLITE_ENABLE_DBPAGE_VTAB compile-time options\n");
13512 utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db));
13514 sqlite3_finalize(pStmt);
13517 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
13518 if( sqlite3_step(pStmt)==SQLITE_ROW
13519 && sqlite3_column_bytes(pStmt,0)>100
13521 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100);
13522 sqlite3_finalize(pStmt);
13524 raw_printf(stderr, "unable to read database header\n");
13525 sqlite3_finalize(pStmt);
13528 i = get2byteInt(aHdr+16);
13529 if( i==1 ) i = 65536;
13530 utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
13531 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
13532 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
13533 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
13534 for(i=0; i<ArraySize(aField); i++){
13535 int ofst = aField[i].ofst;
13536 unsigned int val = get4byteInt(aHdr + ofst);
13537 utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
13540 if( val==1 ) raw_printf(p->out, " (utf8)");
13541 if( val==2 ) raw_printf(p->out, " (utf16le)");
13542 if( val==3 ) raw_printf(p->out, " (utf16be)");
13545 raw_printf(p->out, "\n");
13548 zSchemaTab = sqlite3_mprintf("main.sqlite_master");
13549 }else if( strcmp(zDb,"temp")==0 ){
13550 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
13552 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
13554 for(i=0; i<ArraySize(aQuery); i++){
13555 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
13556 int val = db_int(p, zSql);
13557 sqlite3_free(zSql);
13558 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
13560 sqlite3_free(zSchemaTab);
13561 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion);
13562 utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion);
13567 ** Print the current sqlite3_errmsg() value to stderr and return 1.
13569 static int shellDatabaseError(sqlite3 *db){
13570 const char *zErr = sqlite3_errmsg(db);
13571 utf8_printf(stderr, "Error: %s\n", zErr);
13576 ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
13577 ** if they match and FALSE (0) if they do not match.
13581 ** '*' Matches any sequence of zero or more characters.
13583 ** '?' Matches exactly one character.
13585 ** [...] Matches one character from the enclosed list of
13588 ** [^...] Matches one character not in the enclosed list.
13590 ** '#' Matches any sequence of one or more digits with an
13591 ** optional + or - sign in front
13593 ** ' ' Any span of whitespace matches any other span of
13596 ** Extra whitespace at the end of z[] is ignored.
13598 static int testcase_glob(const char *zGlob, const char *z){
13603 while( (c = (*(zGlob++)))!=0 ){
13605 if( !IsSpace(*z) ) return 0;
13606 while( IsSpace(*zGlob) ) zGlob++;
13607 while( IsSpace(*z) ) z++;
13608 }else if( c=='*' ){
13609 while( (c=(*(zGlob++))) == '*' || c=='?' ){
13610 if( c=='?' && (*(z++))==0 ) return 0;
13614 }else if( c=='[' ){
13615 while( *z && testcase_glob(zGlob-1,z)==0 ){
13620 while( (c2 = (*(z++)))!=0 ){
13623 if( c2==0 ) return 0;
13625 if( testcase_glob(zGlob,z) ) return 1;
13628 }else if( c=='?' ){
13629 if( (*(z++))==0 ) return 0;
13630 }else if( c=='[' ){
13635 if( c==0 ) return 0;
13642 if( c==']' ) seen = 1;
13645 while( c2 && c2!=']' ){
13646 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
13648 if( c>=prior_c && c<=c2 ) seen = 1;
13658 if( c2==0 || (seen ^ invert)==0 ) return 0;
13659 }else if( c=='#' ){
13660 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++;
13661 if( !IsDigit(z[0]) ) return 0;
13663 while( IsDigit(z[0]) ){ z++; }
13665 if( c!=(*(z++)) ) return 0;
13668 while( IsSpace(*z) ){ z++; }
13674 ** Compare the string as a command-line option with either one or two
13675 ** initial "-" characters.
13677 static int optionMatch(const char *zStr, const char *zOpt){
13678 if( zStr[0]!='-' ) return 0;
13680 if( zStr[0]=='-' ) zStr++;
13681 return strcmp(zStr, zOpt)==0;
13687 int shellDeleteFile(const char *zFilename){
13690 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename);
13694 rc = unlink(zFilename);
13700 ** Try to delete the temporary file (if there is one) and free the
13701 ** memory used to hold the name of the temp file.
13703 static void clearTempFile(ShellState *p){
13704 if( p->zTempFile==0 ) return;
13705 if( p->doXdgOpen ) return;
13706 if( shellDeleteFile(p->zTempFile) ) return;
13707 sqlite3_free(p->zTempFile);
13712 ** Create a new temp file name with the given suffix.
13714 static void newTempFile(ShellState *p, const char *zSuffix){
13716 sqlite3_free(p->zTempFile);
13719 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile);
13721 if( p->zTempFile==0 ){
13723 sqlite3_randomness(sizeof(r), &r);
13724 p->zTempFile = sqlite3_mprintf("temp%llx.%s", r, zSuffix);
13726 p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix);
13728 if( p->zTempFile==0 ){
13729 raw_printf(stderr, "out of memory\n");
13736 ** The implementation of SQL scalar function fkey_collate_clause(), used
13737 ** by the ".lint fkey-indexes" command. This scalar function is always
13738 ** called with four arguments - the parent table name, the parent column name,
13739 ** the child table name and the child column name.
13741 ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col')
13743 ** If either of the named tables or columns do not exist, this function
13744 ** returns an empty string. An empty string is also returned if both tables
13745 ** and columns exist but have the same default collation sequence. Or,
13746 ** if both exist but the default collation sequences are different, this
13747 ** function returns the string " COLLATE <parent-collation>", where
13748 ** <parent-collation> is the default collation sequence of the parent column.
13750 static void shellFkeyCollateClause(
13751 sqlite3_context *pCtx,
13753 sqlite3_value **apVal
13755 sqlite3 *db = sqlite3_context_db_handle(pCtx);
13756 const char *zParent;
13757 const char *zParentCol;
13758 const char *zParentSeq;
13759 const char *zChild;
13760 const char *zChildCol;
13761 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */
13765 zParent = (const char*)sqlite3_value_text(apVal[0]);
13766 zParentCol = (const char*)sqlite3_value_text(apVal[1]);
13767 zChild = (const char*)sqlite3_value_text(apVal[2]);
13768 zChildCol = (const char*)sqlite3_value_text(apVal[3]);
13770 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
13771 rc = sqlite3_table_column_metadata(
13772 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0
13774 if( rc==SQLITE_OK ){
13775 rc = sqlite3_table_column_metadata(
13776 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0
13780 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){
13781 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
13782 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
13789 ** The implementation of dot-command ".lint fkey-indexes".
13791 static int lintFkeyIndexes(
13792 ShellState *pState, /* Current shell tool state */
13793 char **azArg, /* Array of arguments passed to dot command */
13794 int nArg /* Number of entries in azArg[] */
13796 sqlite3 *db = pState->db; /* Database handle to query "main" db of */
13797 FILE *out = pState->out; /* Stream to write non-error output to */
13798 int bVerbose = 0; /* If -verbose is present */
13799 int bGroupByParent = 0; /* If -groupbyparent is present */
13800 int i; /* To iterate through azArg[] */
13801 const char *zIndent = ""; /* How much to indent CREATE INDEX by */
13802 int rc; /* Return code */
13803 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */
13806 ** This SELECT statement returns one row for each foreign key constraint
13807 ** in the schema of the main database. The column values are:
13809 ** 0. The text of an SQL statement similar to:
13811 ** "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?"
13813 ** This SELECT is similar to the one that the foreign keys implementation
13814 ** needs to run internally on child tables. If there is an index that can
13815 ** be used to optimize this query, then it can also be used by the FK
13816 ** implementation to optimize DELETE or UPDATE statements on the parent
13819 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
13820 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema
13821 ** contains an index that can be used to optimize the query.
13823 ** 2. Human readable text that describes the child table and columns. e.g.
13825 ** "child_table(child_key1, child_key2)"
13827 ** 3. Human readable text that describes the parent table and columns. e.g.
13829 ** "parent_table(parent_key1, parent_key2)"
13831 ** 4. A full CREATE INDEX statement for an index that could be used to
13832 ** optimize DELETE or UPDATE statements on the parent table. e.g.
13834 ** "CREATE INDEX child_table_child_key ON child_table(child_key)"
13836 ** 5. The name of the parent table.
13838 ** These six values are used by the C logic below to generate the report.
13842 " 'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '"
13843 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
13844 " || fkey_collate_clause("
13845 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
13847 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('"
13848 " || group_concat('*=?', ' AND ') || ')'"
13850 " s.name || '(' || group_concat(f.[from], ', ') || ')'"
13852 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
13854 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
13855 " || ' ON ' || quote(s.name) || '('"
13856 " || group_concat(quote(f.[from]) ||"
13857 " fkey_collate_clause("
13858 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
13862 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f "
13863 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
13864 "GROUP BY s.name, f.id "
13865 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
13867 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)";
13869 for(i=2; i<nArg; i++){
13870 int n = strlen30(azArg[i]);
13871 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){
13874 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
13875 bGroupByParent = 1;
13879 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
13882 return SQLITE_ERROR;
13886 /* Register the fkey_collate_clause() SQL function */
13887 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8,
13888 0, shellFkeyCollateClause, 0, 0
13892 if( rc==SQLITE_OK ){
13893 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
13895 if( rc==SQLITE_OK ){
13896 sqlite3_bind_int(pSql, 1, bGroupByParent);
13899 if( rc==SQLITE_OK ){
13902 while( SQLITE_ROW==sqlite3_step(pSql) ){
13904 sqlite3_stmt *pExplain = 0;
13905 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
13906 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
13907 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
13908 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
13909 const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
13910 const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
13912 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
13913 if( rc!=SQLITE_OK ) break;
13914 if( SQLITE_ROW==sqlite3_step(pExplain) ){
13915 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
13917 0==sqlite3_strglob(zGlob, zPlan)
13918 || 0==sqlite3_strglob(zGlobIPK, zPlan)
13921 rc = sqlite3_finalize(pExplain);
13922 if( rc!=SQLITE_OK ) break;
13925 raw_printf(stderr, "Error: internal error");
13929 && (bVerbose || res==0)
13930 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev))
13932 raw_printf(out, "-- Parent table %s\n", zParent);
13933 sqlite3_free(zPrev);
13934 zPrev = sqlite3_mprintf("%s", zParent);
13938 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
13939 }else if( bVerbose ){
13940 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n",
13941 zIndent, zFrom, zTarget
13946 sqlite3_free(zPrev);
13948 if( rc!=SQLITE_OK ){
13949 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13952 rc2 = sqlite3_finalize(pSql);
13953 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
13955 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13958 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13965 ** Implementation of ".lint" dot command.
13967 static int lintDotCommand(
13968 ShellState *pState, /* Current shell tool state */
13969 char **azArg, /* Array of arguments passed to dot command */
13970 int nArg /* Number of entries in azArg[] */
13973 n = (nArg>=2 ? strlen30(azArg[1]) : 0);
13974 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
13975 return lintFkeyIndexes(pState, azArg, nArg);
13978 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]);
13979 raw_printf(stderr, "Where sub-commands are:\n");
13980 raw_printf(stderr, " fkey-indexes\n");
13981 return SQLITE_ERROR;
13984 #if !defined SQLITE_OMIT_VIRTUALTABLE
13985 static void shellPrepare(
13989 sqlite3_stmt **ppStmt
13992 if( *pRc==SQLITE_OK ){
13993 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
13994 if( rc!=SQLITE_OK ){
13995 raw_printf(stderr, "sql error: %s (%d)\n",
13996 sqlite3_errmsg(db), sqlite3_errcode(db)
14004 ** Create a prepared statement using printf-style arguments for the SQL.
14006 ** This routine is could be marked "static". But it is not always used,
14007 ** depending on compile-time options. By omitting the "static", we avoid
14008 ** nuisance compiler warnings about "defined but not used".
14010 void shellPreparePrintf(
14013 sqlite3_stmt **ppStmt,
14018 if( *pRc==SQLITE_OK ){
14021 va_start(ap, zFmt);
14022 z = sqlite3_vmprintf(zFmt, ap);
14025 *pRc = SQLITE_NOMEM;
14027 shellPrepare(db, pRc, z, ppStmt);
14033 /* Finalize the prepared statement created using shellPreparePrintf().
14035 ** This routine is could be marked "static". But it is not always used,
14036 ** depending on compile-time options. By omitting the "static", we avoid
14037 ** nuisance compiler warnings about "defined but not used".
14039 void shellFinalize(
14041 sqlite3_stmt *pStmt
14044 sqlite3 *db = sqlite3_db_handle(pStmt);
14045 int rc = sqlite3_finalize(pStmt);
14046 if( *pRc==SQLITE_OK ){
14047 if( rc!=SQLITE_OK ){
14048 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
14055 /* Reset the prepared statement created using shellPreparePrintf().
14057 ** This routine is could be marked "static". But it is not always used,
14058 ** depending on compile-time options. By omitting the "static", we avoid
14059 ** nuisance compiler warnings about "defined but not used".
14063 sqlite3_stmt *pStmt
14065 int rc = sqlite3_reset(pStmt);
14066 if( *pRc==SQLITE_OK ){
14067 if( rc!=SQLITE_OK ){
14068 sqlite3 *db = sqlite3_db_handle(pStmt);
14069 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
14074 #endif /* !defined SQLITE_OMIT_VIRTUALTABLE */
14076 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
14077 /******************************************************************************
14078 ** The ".archive" or ".ar" command.
14081 ** Structure representing a single ".ar" command.
14083 typedef struct ArCommand ArCommand;
14085 u8 eCmd; /* An AR_CMD_* value */
14086 u8 bVerbose; /* True if --verbose */
14087 u8 bZip; /* True if the archive is a ZIP */
14088 u8 bDryRun; /* True if --dry-run */
14089 u8 bAppend; /* True if --append */
14090 u8 fromCmdLine; /* Run from -A instead of .archive */
14091 int nArg; /* Number of command arguments */
14092 char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */
14093 const char *zFile; /* --file argument, or NULL */
14094 const char *zDir; /* --directory argument, or NULL */
14095 char **azArg; /* Array of command arguments */
14096 ShellState *p; /* Shell state */
14097 sqlite3 *db; /* Database containing the archive */
14101 ** Print a usage message for the .ar command to stderr and return SQLITE_ERROR.
14103 static int arUsage(FILE *f){
14104 showHelp(f,"archive");
14105 return SQLITE_ERROR;
14109 ** Print an error message for the .ar command to stderr and return
14112 static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){
14115 va_start(ap, zFmt);
14116 z = sqlite3_vmprintf(zFmt, ap);
14118 utf8_printf(stderr, "Error: %s\n", z);
14119 if( pAr->fromCmdLine ){
14120 utf8_printf(stderr, "Use \"-A\" for more help\n");
14122 utf8_printf(stderr, "Use \".archive --help\" for more help\n");
14125 return SQLITE_ERROR;
14129 ** Values for ArCommand.eCmd.
14131 #define AR_CMD_CREATE 1
14132 #define AR_CMD_UPDATE 2
14133 #define AR_CMD_INSERT 3
14134 #define AR_CMD_EXTRACT 4
14135 #define AR_CMD_LIST 5
14136 #define AR_CMD_HELP 6
14139 ** Other (non-command) switches.
14141 #define AR_SWITCH_VERBOSE 7
14142 #define AR_SWITCH_FILE 8
14143 #define AR_SWITCH_DIRECTORY 9
14144 #define AR_SWITCH_APPEND 10
14145 #define AR_SWITCH_DRYRUN 11
14147 static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){
14149 case AR_CMD_CREATE:
14150 case AR_CMD_EXTRACT:
14152 case AR_CMD_UPDATE:
14153 case AR_CMD_INSERT:
14156 return arErrorMsg(pAr, "multiple command options");
14158 pAr->eCmd = eSwitch;
14161 case AR_SWITCH_DRYRUN:
14164 case AR_SWITCH_VERBOSE:
14167 case AR_SWITCH_APPEND:
14169 /* Fall thru into --file */
14170 case AR_SWITCH_FILE:
14173 case AR_SWITCH_DIRECTORY:
14182 ** Parse the command line for an ".ar" command. The results are written into
14183 ** structure (*pAr). SQLITE_OK is returned if the command line is parsed
14184 ** successfully, otherwise an error message is written to stderr and
14185 ** SQLITE_ERROR returned.
14187 static int arParseCommand(
14188 char **azArg, /* Array of arguments passed to dot command */
14189 int nArg, /* Number of entries in azArg[] */
14190 ArCommand *pAr /* Populate this object */
14198 { "create", 'c', AR_CMD_CREATE, 0 },
14199 { "extract", 'x', AR_CMD_EXTRACT, 0 },
14200 { "insert", 'i', AR_CMD_INSERT, 0 },
14201 { "list", 't', AR_CMD_LIST, 0 },
14202 { "update", 'u', AR_CMD_UPDATE, 0 },
14203 { "help", 'h', AR_CMD_HELP, 0 },
14204 { "verbose", 'v', AR_SWITCH_VERBOSE, 0 },
14205 { "file", 'f', AR_SWITCH_FILE, 1 },
14206 { "append", 'a', AR_SWITCH_APPEND, 1 },
14207 { "directory", 'C', AR_SWITCH_DIRECTORY, 1 },
14208 { "dryrun", 'n', AR_SWITCH_DRYRUN, 0 },
14210 int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch);
14211 struct ArSwitch *pEnd = &aSwitch[nSwitch];
14214 utf8_printf(stderr, "Wrong number of arguments. Usage:\n");
14215 return arUsage(stderr);
14217 char *z = azArg[1];
14219 /* Traditional style [tar] invocation */
14222 for(i=0; z[i]; i++){
14223 const char *zArg = 0;
14224 struct ArSwitch *pOpt;
14225 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14226 if( z[i]==pOpt->cShort ) break;
14229 return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
14233 return arErrorMsg(pAr, "option requires an argument: %c",z[i]);
14235 zArg = azArg[iArg++];
14237 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
14239 pAr->nArg = nArg-iArg;
14241 pAr->azArg = &azArg[iArg];
14244 /* Non-traditional invocation */
14246 for(iArg=1; iArg<nArg; iArg++){
14250 /* All remaining command line words are command arguments. */
14251 pAr->azArg = &azArg[iArg];
14252 pAr->nArg = nArg-iArg;
14259 /* One or more short options */
14260 for(i=1; i<n; i++){
14261 const char *zArg = 0;
14262 struct ArSwitch *pOpt;
14263 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14264 if( z[i]==pOpt->cShort ) break;
14267 return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
14274 if( iArg>=(nArg-1) ){
14275 return arErrorMsg(pAr, "option requires an argument: %c",
14278 zArg = azArg[++iArg];
14281 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
14283 }else if( z[2]=='\0' ){
14284 /* A -- option, indicating that all remaining command line words
14285 ** are command arguments. */
14286 pAr->azArg = &azArg[iArg+1];
14287 pAr->nArg = nArg-iArg-1;
14290 /* A long option */
14291 const char *zArg = 0; /* Argument for option, if any */
14292 struct ArSwitch *pMatch = 0; /* Matching option */
14293 struct ArSwitch *pOpt; /* Iterator */
14294 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14295 const char *zLong = pOpt->zLong;
14296 if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){
14298 return arErrorMsg(pAr, "ambiguous option: %s",z);
14306 return arErrorMsg(pAr, "unrecognized option: %s", z);
14308 if( pMatch->bArg ){
14309 if( iArg>=(nArg-1) ){
14310 return arErrorMsg(pAr, "option requires an argument: %s", z);
14312 zArg = azArg[++iArg];
14314 if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR;
14324 ** This function assumes that all arguments within the ArCommand.azArg[]
14325 ** array refer to archive members, as for the --extract or --list commands.
14326 ** It checks that each of them are present. If any specified file is not
14327 ** present in the archive, an error is printed to stderr and an error
14328 ** code returned. Otherwise, if all specified arguments are present in
14329 ** the archive, SQLITE_OK is returned.
14331 ** This function strips any trailing '/' characters from each argument.
14332 ** This is consistent with the way the [tar] command seems to work on
14335 static int arCheckEntries(ArCommand *pAr){
14336 int rc = SQLITE_OK;
14339 sqlite3_stmt *pTest = 0;
14341 shellPreparePrintf(pAr->db, &rc, &pTest,
14342 "SELECT name FROM %s WHERE name=$name",
14345 j = sqlite3_bind_parameter_index(pTest, "$name");
14346 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){
14347 char *z = pAr->azArg[i];
14348 int n = strlen30(z);
14350 while( n>0 && z[n-1]=='/' ) n--;
14352 sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC);
14353 if( SQLITE_ROW==sqlite3_step(pTest) ){
14356 shellReset(&rc, pTest);
14357 if( rc==SQLITE_OK && bOk==0 ){
14358 utf8_printf(stderr, "not found in archive: %s\n", z);
14362 shellFinalize(&rc, pTest);
14368 ** Format a WHERE clause that can be used against the "sqlar" table to
14369 ** identify all archive members that match the command arguments held
14370 ** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning.
14371 ** The caller is responsible for eventually calling sqlite3_free() on
14372 ** any non-NULL (*pzWhere) value.
14374 static void arWhereClause(
14377 char **pzWhere /* OUT: New WHERE clause */
14380 if( *pRc==SQLITE_OK ){
14381 if( pAr->nArg==0 ){
14382 zWhere = sqlite3_mprintf("1");
14385 const char *zSep = "";
14386 for(i=0; i<pAr->nArg; i++){
14387 const char *z = pAr->azArg[i];
14388 zWhere = sqlite3_mprintf(
14389 "%z%s name = '%q' OR substr(name,1,%d) = '%q/'",
14390 zWhere, zSep, z, strlen30(z)+1, z
14393 *pRc = SQLITE_NOMEM;
14404 ** Implementation of .ar "lisT" command.
14406 static int arListCommand(ArCommand *pAr){
14407 const char *zSql = "SELECT %s FROM %s WHERE %s";
14408 const char *azCols[] = {
14410 "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name"
14414 sqlite3_stmt *pSql = 0;
14417 rc = arCheckEntries(pAr);
14418 arWhereClause(&rc, pAr, &zWhere);
14420 shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose],
14421 pAr->zSrcTable, zWhere);
14422 if( pAr->bDryRun ){
14423 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
14425 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
14426 if( pAr->bVerbose ){
14427 utf8_printf(pAr->p->out, "%s % 10d %s %s\n",
14428 sqlite3_column_text(pSql, 0),
14429 sqlite3_column_int(pSql, 1),
14430 sqlite3_column_text(pSql, 2),
14431 sqlite3_column_text(pSql, 3)
14434 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
14438 shellFinalize(&rc, pSql);
14439 sqlite3_free(zWhere);
14445 ** Implementation of .ar "eXtract" command.
14447 static int arExtractCommand(ArCommand *pAr){
14448 const char *zSql1 =
14451 " writefile(($dir || name), %s, mode, mtime) "
14452 "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)"
14453 " AND name NOT GLOB '*..[/\\]*'";
14455 const char *azExtraArg[] = {
14456 "sqlar_uncompress(data, sz)",
14460 sqlite3_stmt *pSql = 0;
14461 int rc = SQLITE_OK;
14466 /* If arguments are specified, check that they actually exist within
14467 ** the archive before proceeding. And formulate a WHERE clause to
14469 rc = arCheckEntries(pAr);
14470 arWhereClause(&rc, pAr, &zWhere);
14472 if( rc==SQLITE_OK ){
14474 zDir = sqlite3_mprintf("%s/", pAr->zDir);
14476 zDir = sqlite3_mprintf("");
14478 if( zDir==0 ) rc = SQLITE_NOMEM;
14481 shellPreparePrintf(pAr->db, &rc, &pSql, zSql1,
14482 azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere
14485 if( rc==SQLITE_OK ){
14486 j = sqlite3_bind_parameter_index(pSql, "$dir");
14487 sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC);
14489 /* Run the SELECT statement twice. The first time, writefile() is called
14490 ** for all archive members that should be extracted. The second time,
14491 ** only for the directories. This is because the timestamps for
14492 ** extracted directories must be reset after they are populated (as
14493 ** populating them changes the timestamp). */
14494 for(i=0; i<2; i++){
14495 j = sqlite3_bind_parameter_index(pSql, "$dirOnly");
14496 sqlite3_bind_int(pSql, j, i);
14497 if( pAr->bDryRun ){
14498 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
14500 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
14501 if( i==0 && pAr->bVerbose ){
14502 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
14506 shellReset(&rc, pSql);
14508 shellFinalize(&rc, pSql);
14511 sqlite3_free(zDir);
14512 sqlite3_free(zWhere);
14517 ** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out.
14519 static int arExecSql(ArCommand *pAr, const char *zSql){
14521 if( pAr->bDryRun ){
14522 utf8_printf(pAr->p->out, "%s\n", zSql);
14526 rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
14528 utf8_printf(stdout, "ERROR: %s\n", zErr);
14529 sqlite3_free(zErr);
14537 ** Implementation of .ar "create", "insert", and "update" commands.
14539 ** create -> Create a new SQL archive
14540 ** insert -> Insert or reinsert all files listed
14541 ** update -> Insert files that have changed or that were not
14542 ** previously in the archive
14544 ** Create the "sqlar" table in the database if it does not already exist.
14545 ** Then add each file in the azFile[] array to the archive. Directories
14546 ** are added recursively. If argument bVerbose is non-zero, a message is
14547 ** printed on stdout for each file archived.
14549 ** The create command is the same as update, except that it drops
14550 ** any existing "sqlar" table before beginning. The "insert" command
14551 ** always overwrites every file named on the command-line, where as
14552 ** "update" only overwrites if the size or mtime or mode has changed.
14554 static int arCreateOrUpdateCommand(
14555 ArCommand *pAr, /* Command arguments and options */
14556 int bUpdate, /* true for a --create. */
14557 int bOnlyIfChanged /* Only update if file has changed */
14559 const char *zCreate =
14560 "CREATE TABLE IF NOT EXISTS sqlar(\n"
14561 " name TEXT PRIMARY KEY, -- name of the file\n"
14562 " mode INT, -- access permissions\n"
14563 " mtime INT, -- last modification time\n"
14564 " sz INT, -- original file size\n"
14565 " data BLOB -- compressed content\n"
14567 const char *zDrop = "DROP TABLE IF EXISTS sqlar";
14568 const char *zInsertFmt[2] = {
14569 "REPLACE INTO %s(name,mode,mtime,sz,data)\n"
14574 " CASE substr(lsmode(mode),1,1)\n"
14575 " WHEN '-' THEN length(data)\n"
14576 " WHEN 'd' THEN 0\n"
14578 " sqlar_compress(data)\n"
14579 " FROM fsdir(%Q,%Q) AS disk\n"
14580 " WHERE lsmode(mode) NOT LIKE '?%%'%s;"
14582 "REPLACE INTO %s(name,mode,mtime,data)\n"
14588 " FROM fsdir(%Q,%Q) AS disk\n"
14589 " WHERE lsmode(mode) NOT LIKE '?%%'%s;"
14591 int i; /* For iterating through azFile[] */
14592 int rc; /* Return code */
14593 const char *zTab = 0; /* SQL table into which to insert */
14598 arExecSql(pAr, "PRAGMA page_size=512");
14599 rc = arExecSql(pAr, "SAVEPOINT ar;");
14600 if( rc!=SQLITE_OK ) return rc;
14603 /* Initialize the zipfile virtual table, if necessary */
14606 sqlite3_randomness(sizeof(r),&r);
14607 sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r);
14609 zSql = sqlite3_mprintf(
14610 "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)",
14613 rc = arExecSql(pAr, zSql);
14614 sqlite3_free(zSql);
14619 /* Initialize the table for an SQLAR */
14622 rc = arExecSql(pAr, zDrop);
14623 if( rc!=SQLITE_OK ) goto end_ar_transaction;
14625 rc = arExecSql(pAr, zCreate);
14627 if( bOnlyIfChanged ){
14628 zExists = sqlite3_mprintf(
14630 "SELECT 1 FROM %s AS mem"
14631 " WHERE mem.name=disk.name"
14632 " AND mem.mtime=disk.mtime"
14633 " AND mem.mode=disk.mode)", zTab);
14635 zExists = sqlite3_mprintf("");
14637 if( zExists==0 ) rc = SQLITE_NOMEM;
14638 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){
14639 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab,
14640 pAr->bVerbose ? "shell_putsnl(name)" : "name",
14641 pAr->azArg[i], pAr->zDir, zExists);
14642 rc = arExecSql(pAr, zSql2);
14643 sqlite3_free(zSql2);
14645 end_ar_transaction:
14646 if( rc!=SQLITE_OK ){
14647 sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0);
14649 rc = arExecSql(pAr, "RELEASE ar;");
14650 if( pAr->bZip && pAr->zFile ){
14651 zSql = sqlite3_mprintf("DROP TABLE %s", zTemp);
14652 arExecSql(pAr, zSql);
14653 sqlite3_free(zSql);
14656 sqlite3_free(zExists);
14661 ** Implementation of ".ar" dot command.
14663 static int arDotCommand(
14664 ShellState *pState, /* Current shell tool state */
14665 int fromCmdLine, /* True if -A command-line option, not .ar cmd */
14666 char **azArg, /* Array of arguments passed to dot command */
14667 int nArg /* Number of entries in azArg[] */
14671 memset(&cmd, 0, sizeof(cmd));
14672 cmd.fromCmdLine = fromCmdLine;
14673 rc = arParseCommand(azArg, nArg, &cmd);
14674 if( rc==SQLITE_OK ){
14675 int eDbType = SHELL_OPEN_UNSPEC;
14677 cmd.db = pState->db;
14679 eDbType = deduceDatabaseType(cmd.zFile, 1);
14681 eDbType = pState->openMode;
14683 if( eDbType==SHELL_OPEN_ZIPFILE ){
14684 if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){
14685 if( cmd.zFile==0 ){
14686 cmd.zSrcTable = sqlite3_mprintf("zip");
14688 cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile);
14692 }else if( cmd.zFile ){
14694 if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS;
14695 if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT
14696 || cmd.eCmd==AR_CMD_UPDATE ){
14697 flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
14699 flags = SQLITE_OPEN_READONLY;
14703 utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile,
14704 eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
14706 rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags,
14707 eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0);
14708 if( rc!=SQLITE_OK ){
14709 utf8_printf(stderr, "cannot open file: %s (%s)\n",
14710 cmd.zFile, sqlite3_errmsg(cmd.db)
14712 goto end_ar_command;
14714 sqlite3_fileio_init(cmd.db, 0, 0);
14715 sqlite3_sqlar_init(cmd.db, 0, 0);
14716 sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p,
14717 shellPutsFunc, 0, 0);
14720 if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){
14721 if( cmd.eCmd!=AR_CMD_CREATE
14722 && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0)
14724 utf8_printf(stderr, "database does not contain an 'sqlar' table\n");
14726 goto end_ar_command;
14728 cmd.zSrcTable = sqlite3_mprintf("sqlar");
14731 switch( cmd.eCmd ){
14732 case AR_CMD_CREATE:
14733 rc = arCreateOrUpdateCommand(&cmd, 0, 0);
14736 case AR_CMD_EXTRACT:
14737 rc = arExtractCommand(&cmd);
14741 rc = arListCommand(&cmd);
14745 arUsage(pState->out);
14748 case AR_CMD_INSERT:
14749 rc = arCreateOrUpdateCommand(&cmd, 1, 0);
14753 assert( cmd.eCmd==AR_CMD_UPDATE );
14754 rc = arCreateOrUpdateCommand(&cmd, 1, 1);
14759 if( cmd.db!=pState->db ){
14762 sqlite3_free(cmd.zSrcTable);
14766 /* End of the ".archive" or ".ar" command logic
14767 *******************************************************************************/
14768 #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */
14770 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
14772 ** If (*pRc) is not SQLITE_OK when this function is called, it is a no-op.
14773 ** Otherwise, the SQL statement or statements in zSql are executed using
14774 ** database connection db and the error code written to *pRc before
14775 ** this function returns.
14777 static void shellExec(sqlite3 *db, int *pRc, const char *zSql){
14779 if( rc==SQLITE_OK ){
14781 rc = sqlite3_exec(db, zSql, 0, 0, &zErr);
14782 if( rc!=SQLITE_OK ){
14783 raw_printf(stderr, "SQL error: %s\n", zErr);
14790 ** Like shellExec(), except that zFmt is a printf() style format string.
14792 static void shellExecPrintf(sqlite3 *db, int *pRc, const char *zFmt, ...){
14794 if( *pRc==SQLITE_OK ){
14796 va_start(ap, zFmt);
14797 z = sqlite3_vmprintf(zFmt, ap);
14800 *pRc = SQLITE_NOMEM;
14802 shellExec(db, pRc, z);
14809 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
14810 ** Otherwise, an attempt is made to allocate, zero and return a pointer
14811 ** to a buffer nByte bytes in size. If an OOM error occurs, *pRc is set
14812 ** to SQLITE_NOMEM and NULL returned.
14814 static void *shellMalloc(int *pRc, sqlite3_int64 nByte){
14816 if( *pRc==SQLITE_OK ){
14817 pRet = sqlite3_malloc64(nByte);
14819 *pRc = SQLITE_NOMEM;
14821 memset(pRet, 0, nByte);
14828 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
14829 ** Otherwise, zFmt is treated as a printf() style string. The result of
14830 ** formatting it along with any trailing arguments is written into a
14831 ** buffer obtained from sqlite3_malloc(), and pointer to which is returned.
14832 ** It is the responsibility of the caller to eventually free this buffer
14833 ** using a call to sqlite3_free().
14835 ** If an OOM error occurs, (*pRc) is set to SQLITE_NOMEM and a NULL
14836 ** pointer returned.
14838 static char *shellMPrintf(int *pRc, const char *zFmt, ...){
14840 if( *pRc==SQLITE_OK ){
14842 va_start(ap, zFmt);
14843 z = sqlite3_vmprintf(zFmt, ap);
14846 *pRc = SQLITE_NOMEM;
14853 ** When running the ".recover" command, each output table, and the special
14854 ** orphaned row table if it is required, is represented by an instance
14855 ** of the following struct.
14857 typedef struct RecoverTable RecoverTable;
14858 struct RecoverTable {
14859 char *zQuoted; /* Quoted version of table name */
14860 int nCol; /* Number of columns in table */
14861 char **azlCol; /* Array of column lists */
14862 int iPk; /* Index of IPK column */
14866 ** Free a RecoverTable object allocated by recoverFindTable() or
14867 ** recoverOrphanTable().
14869 static void recoverFreeTable(RecoverTable *pTab){
14871 sqlite3_free(pTab->zQuoted);
14872 if( pTab->azlCol ){
14874 for(i=0; i<=pTab->nCol; i++){
14875 sqlite3_free(pTab->azlCol[i]);
14877 sqlite3_free(pTab->azlCol);
14879 sqlite3_free(pTab);
14884 ** This function is a no-op if (*pRc) is not SQLITE_OK when it is called.
14885 ** Otherwise, it allocates and returns a RecoverTable object based on the
14886 ** final four arguments passed to this function. It is the responsibility
14887 ** of the caller to eventually free the returned object using
14888 ** recoverFreeTable().
14890 static RecoverTable *recoverNewTable(
14891 int *pRc, /* IN/OUT: Error code */
14892 const char *zName, /* Name of table */
14893 const char *zSql, /* CREATE TABLE statement */
14897 sqlite3 *dbtmp = 0; /* sqlite3 handle for testing CREATE TABLE */
14899 RecoverTable *pTab = 0;
14901 pTab = (RecoverTable*)shellMalloc(&rc, sizeof(RecoverTable));
14902 if( rc==SQLITE_OK ){
14904 int bSqlIntkey = 0;
14905 sqlite3_stmt *pStmt = 0;
14907 rc = sqlite3_open("", &dbtmp);
14908 if( rc==SQLITE_OK ){
14909 sqlite3_create_function(dbtmp, "shell_idquote", 1, SQLITE_UTF8, 0,
14910 shellIdQuote, 0, 0);
14912 if( rc==SQLITE_OK ){
14913 rc = sqlite3_exec(dbtmp, "PRAGMA writable_schema = on", 0, 0, 0);
14915 if( rc==SQLITE_OK ){
14916 rc = sqlite3_exec(dbtmp, zSql, 0, 0, 0);
14917 if( rc==SQLITE_ERROR ){
14922 shellPreparePrintf(dbtmp, &rc, &pStmt,
14923 "SELECT count(*) FROM pragma_table_info(%Q)", zName
14925 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14926 nSqlCol = sqlite3_column_int(pStmt, 0);
14928 shellFinalize(&rc, pStmt);
14930 if( rc!=SQLITE_OK || nSqlCol<nCol ){
14934 shellPreparePrintf(dbtmp, &rc, &pStmt,
14936 " SELECT substr(data,1,1)==X'0D' FROM sqlite_dbpage WHERE pgno=rootpage"
14937 ") FROM sqlite_master WHERE name = %Q", zName
14939 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14940 bSqlIntkey = sqlite3_column_int(pStmt, 0);
14942 shellFinalize(&rc, pStmt);
14944 if( bIntkey==bSqlIntkey ){
14946 const char *zPk = "_rowid_";
14947 sqlite3_stmt *pPkFinder = 0;
14949 /* If this is an intkey table and there is an INTEGER PRIMARY KEY,
14950 ** set zPk to the name of the PK column, and pTab->iPk to the index
14951 ** of the column, where columns are 0-numbered from left to right.
14952 ** Or, if this is a WITHOUT ROWID table or if there is no IPK column,
14953 ** leave zPk as "_rowid_" and pTab->iPk at -2. */
14956 shellPreparePrintf(dbtmp, &rc, &pPkFinder,
14957 "SELECT cid, name FROM pragma_table_info(%Q) "
14958 " WHERE pk=1 AND type='integer' COLLATE nocase"
14959 " AND NOT EXISTS (SELECT cid FROM pragma_table_info(%Q) WHERE pk=2)"
14962 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPkFinder) ){
14963 pTab->iPk = sqlite3_column_int(pPkFinder, 0);
14964 zPk = (const char*)sqlite3_column_text(pPkFinder, 1);
14968 pTab->zQuoted = shellMPrintf(&rc, "\"%w\"", zName);
14969 pTab->azlCol = (char**)shellMalloc(&rc, sizeof(char*) * (nSqlCol+1));
14970 pTab->nCol = nSqlCol;
14973 pTab->azlCol[0] = shellMPrintf(&rc, "\"%w\"", zPk);
14975 pTab->azlCol[0] = shellMPrintf(&rc, "");
14978 shellPreparePrintf(dbtmp, &rc, &pStmt,
14979 "SELECT %Q || group_concat(shell_idquote(name), ', ') "
14980 " FILTER (WHERE cid!=%d) OVER (ORDER BY %s cid) "
14981 "FROM pragma_table_info(%Q)",
14982 bIntkey ? ", " : "", pTab->iPk,
14983 bIntkey ? "" : "(CASE WHEN pk=0 THEN 1000000 ELSE pk END), ",
14986 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14987 const char *zText = (const char*)sqlite3_column_text(pStmt, 0);
14988 pTab->azlCol[i] = shellMPrintf(&rc, "%s%s", pTab->azlCol[0], zText);
14991 shellFinalize(&rc, pStmt);
14993 shellFinalize(&rc, pPkFinder);
14998 sqlite3_close(dbtmp);
15000 if( rc!=SQLITE_OK || (pTab && pTab->zQuoted==0) ){
15001 recoverFreeTable(pTab);
15008 ** This function is called to search the schema recovered from the
15009 ** sqlite_master table of the (possibly) corrupt database as part
15010 ** of a ".recover" command. Specifically, for a table with root page
15011 ** iRoot and at least nCol columns. Additionally, if bIntkey is 0, the
15012 ** table must be a WITHOUT ROWID table, or if non-zero, not one of
15015 ** If a table is found, a (RecoverTable*) object is returned. Or, if
15016 ** no such table is found, but bIntkey is false and iRoot is the
15017 ** root page of an index in the recovered schema, then (*pbNoop) is
15018 ** set to true and NULL returned. Or, if there is no such table or
15019 ** index, NULL is returned and (*pbNoop) set to 0, indicating that
15020 ** the caller should write data to the orphans table.
15022 static RecoverTable *recoverFindTable(
15023 ShellState *pState, /* Shell state object */
15024 int *pRc, /* IN/OUT: Error code */
15025 int iRoot, /* Root page of table */
15026 int bIntkey, /* True for an intkey table */
15027 int nCol, /* Number of columns in table */
15028 int *pbNoop /* OUT: True if iRoot is root of index */
15030 sqlite3_stmt *pStmt = 0;
15031 RecoverTable *pRet = 0;
15033 const char *zSql = 0;
15034 const char *zName = 0;
15036 /* Search the recovered schema for an object with root page iRoot. */
15037 shellPreparePrintf(pState->db, pRc, &pStmt,
15038 "SELECT type, name, sql FROM recovery.schema WHERE rootpage=%d", iRoot
15040 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15041 const char *zType = (const char*)sqlite3_column_text(pStmt, 0);
15042 if( bIntkey==0 && sqlite3_stricmp(zType, "index")==0 ){
15046 if( sqlite3_stricmp(zType, "table")==0 ){
15047 zName = (const char*)sqlite3_column_text(pStmt, 1);
15048 zSql = (const char*)sqlite3_column_text(pStmt, 2);
15049 pRet = recoverNewTable(pRc, zName, zSql, bIntkey, nCol);
15054 shellFinalize(pRc, pStmt);
15060 ** Return a RecoverTable object representing the orphans table.
15062 static RecoverTable *recoverOrphanTable(
15063 ShellState *pState, /* Shell state object */
15064 int *pRc, /* IN/OUT: Error code */
15065 const char *zLostAndFound, /* Base name for orphans table */
15066 int nCol /* Number of user data columns */
15068 RecoverTable *pTab = 0;
15069 if( nCol>=0 && *pRc==SQLITE_OK ){
15072 /* This block determines the name of the orphan table. The prefered
15073 ** name is zLostAndFound. But if that clashes with another name
15074 ** in the recovered schema, try zLostAndFound_0, zLostAndFound_1
15075 ** and so on until a non-clashing name is found. */
15077 char *zTab = shellMPrintf(pRc, "%s", zLostAndFound);
15078 sqlite3_stmt *pTest = 0;
15079 shellPrepare(pState->db, pRc,
15080 "SELECT 1 FROM recovery.schema WHERE name=?", &pTest
15082 if( pTest ) sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT);
15083 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pTest) ){
15084 shellReset(pRc, pTest);
15085 sqlite3_free(zTab);
15086 zTab = shellMPrintf(pRc, "%s_%d", zLostAndFound, iTab++);
15087 sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT);
15089 shellFinalize(pRc, pTest);
15091 pTab = (RecoverTable*)shellMalloc(pRc, sizeof(RecoverTable));
15093 pTab->zQuoted = shellMPrintf(pRc, "\"%w\"", zTab);
15097 pTab->azlCol = (char**)shellMalloc(pRc, sizeof(char*) * (nCol+1));
15098 if( pTab->azlCol ){
15099 pTab->azlCol[nCol] = shellMPrintf(pRc, "");
15100 for(i=nCol-1; i>=0; i--){
15101 pTab->azlCol[i] = shellMPrintf(pRc, "%s, NULL", pTab->azlCol[i+1]);
15106 if( *pRc!=SQLITE_OK ){
15107 recoverFreeTable(pTab);
15110 raw_printf(pState->out,
15111 "CREATE TABLE %s(rootpgno INTEGER, "
15112 "pgno INTEGER, nfield INTEGER, id INTEGER", pTab->zQuoted
15114 for(i=0; i<nCol; i++){
15115 raw_printf(pState->out, ", c%d", i);
15117 raw_printf(pState->out, ");\n");
15120 sqlite3_free(zTab);
15126 ** This function is called to recover data from the database. A script
15127 ** to construct a new database containing all recovered data is output
15128 ** on stream pState->out.
15130 static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){
15131 int rc = SQLITE_OK;
15132 sqlite3_stmt *pLoop = 0; /* Loop through all root pages */
15133 sqlite3_stmt *pPages = 0; /* Loop through all pages in a group */
15134 sqlite3_stmt *pCells = 0; /* Loop through all cells in a page */
15135 const char *zRecoveryDb = ""; /* Name of "recovery" database */
15136 const char *zLostAndFound = "lost_and_found";
15139 RecoverTable *pOrphan = 0;
15141 int bFreelist = 1; /* 0 if --freelist-corrupt is specified */
15142 int bRowids = 1; /* 0 if --no-rowids */
15143 for(i=1; i<nArg; i++){
15144 char *z = azArg[i];
15146 if( z[0]=='-' && z[1]=='-' ) z++;
15148 if( n<=17 && memcmp("-freelist-corrupt", z, n)==0 ){
15151 if( n<=12 && memcmp("-recovery-db", z, n)==0 && i<(nArg-1) ){
15153 zRecoveryDb = azArg[i];
15155 if( n<=15 && memcmp("-lost-and-found", z, n)==0 && i<(nArg-1) ){
15157 zLostAndFound = azArg[i];
15159 if( n<=10 && memcmp("-no-rowids", z, n)==0 ){
15163 utf8_printf(stderr, "unexpected option: %s\n", azArg[i]);
15164 showHelp(pState->out, azArg[0]);
15169 shellExecPrintf(pState->db, &rc,
15170 /* Attach an in-memory database named 'recovery'. Create an indexed
15171 ** cache of the sqlite_dbptr virtual table. */
15172 "PRAGMA writable_schema = on;"
15173 "ATTACH %Q AS recovery;"
15174 "DROP TABLE IF EXISTS recovery.dbptr;"
15175 "DROP TABLE IF EXISTS recovery.freelist;"
15176 "DROP TABLE IF EXISTS recovery.map;"
15177 "DROP TABLE IF EXISTS recovery.schema;"
15178 "CREATE TABLE recovery.freelist(pgno INTEGER PRIMARY KEY);", zRecoveryDb
15182 shellExec(pState->db, &rc,
15183 "WITH trunk(pgno) AS ("
15184 " SELECT shell_int32("
15185 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 8) AS x "
15188 " SELECT shell_int32("
15189 " (SELECT data FROM sqlite_dbpage WHERE pgno=trunk.pgno), 0) AS x "
15190 " FROM trunk WHERE x>0"
15192 "freelist(data, n, freepgno) AS ("
15193 " SELECT data, min(16384, shell_int32(data, 1)-1), t.pgno "
15194 " FROM trunk t, sqlite_dbpage s WHERE s.pgno=t.pgno"
15196 " SELECT data, n-1, shell_int32(data, 2+n) "
15197 " FROM freelist WHERE n>=0"
15199 "REPLACE INTO recovery.freelist SELECT freepgno FROM freelist;"
15203 /* If this is an auto-vacuum database, add all pointer-map pages to
15204 ** the freelist table. Do this regardless of whether or not
15205 ** --freelist-corrupt was specified. */
15206 shellExec(pState->db, &rc,
15207 "WITH ptrmap(pgno) AS ("
15208 " SELECT 2 WHERE shell_int32("
15209 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 13"
15212 " SELECT pgno+1+(SELECT page_size FROM pragma_page_size)/5 AS pp "
15213 " FROM ptrmap WHERE pp<=(SELECT page_count FROM pragma_page_count)"
15215 "REPLACE INTO recovery.freelist SELECT pgno FROM ptrmap"
15218 shellExec(pState->db, &rc,
15219 "CREATE TABLE recovery.dbptr("
15220 " pgno, child, PRIMARY KEY(child, pgno)"
15222 "INSERT OR IGNORE INTO recovery.dbptr(pgno, child) "
15223 " SELECT * FROM sqlite_dbptr"
15224 " WHERE pgno NOT IN freelist AND child NOT IN freelist;"
15226 /* Delete any pointer to page 1. This ensures that page 1 is considered
15227 ** a root page, regardless of how corrupt the db is. */
15228 "DELETE FROM recovery.dbptr WHERE child = 1;"
15230 /* Delete all pointers to any pages that have more than one pointer
15231 ** to them. Such pages will be treated as root pages when recovering
15233 "DELETE FROM recovery.dbptr WHERE child IN ("
15234 " SELECT child FROM recovery.dbptr GROUP BY child HAVING count(*)>1"
15237 /* Create the "map" table that will (eventually) contain instructions
15238 ** for dealing with each page in the db that contains one or more
15240 "CREATE TABLE recovery.map("
15241 "pgno INTEGER PRIMARY KEY, maxlen INT, intkey, root INT"
15244 /* Populate table [map]. If there are circular loops of pages in the
15245 ** database, the following adds all pages in such a loop to the map
15246 ** as individual root pages. This could be handled better. */
15247 "WITH pages(i, maxlen) AS ("
15248 " SELECT page_count, ("
15249 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=page_count"
15250 " ) FROM pragma_page_count WHERE page_count>0"
15253 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=i-1"
15254 " ) FROM pages WHERE i>=2"
15256 "INSERT INTO recovery.map(pgno, maxlen, intkey, root) "
15257 " SELECT i, maxlen, NULL, ("
15258 " WITH p(orig, pgno, parent) AS ("
15259 " SELECT 0, i, (SELECT pgno FROM recovery.dbptr WHERE child=i)"
15261 " SELECT i, p.parent, "
15262 " (SELECT pgno FROM recovery.dbptr WHERE child=p.parent) FROM p"
15264 " SELECT pgno FROM p WHERE (parent IS NULL OR pgno = orig)"
15266 "FROM pages WHERE maxlen IS NOT NULL AND i NOT IN freelist;"
15267 "UPDATE recovery.map AS o SET intkey = ("
15268 " SELECT substr(data, 1, 1)==X'0D' FROM sqlite_dbpage WHERE pgno=o.pgno"
15271 /* Extract data from page 1 and any linked pages into table
15272 ** recovery.schema. With the same schema as an sqlite_master table. */
15273 "CREATE TABLE recovery.schema(type, name, tbl_name, rootpage, sql);"
15274 "INSERT INTO recovery.schema SELECT "
15275 " max(CASE WHEN field=0 THEN value ELSE NULL END),"
15276 " max(CASE WHEN field=1 THEN value ELSE NULL END),"
15277 " max(CASE WHEN field=2 THEN value ELSE NULL END),"
15278 " max(CASE WHEN field=3 THEN value ELSE NULL END),"
15279 " max(CASE WHEN field=4 THEN value ELSE NULL END)"
15280 "FROM sqlite_dbdata WHERE pgno IN ("
15281 " SELECT pgno FROM recovery.map WHERE root=1"
15283 "GROUP BY pgno, cell;"
15284 "CREATE INDEX recovery.schema_rootpage ON schema(rootpage);"
15287 /* Open a transaction, then print out all non-virtual, non-"sqlite_%"
15288 ** CREATE TABLE statements that extracted from the existing schema. */
15289 if( rc==SQLITE_OK ){
15290 sqlite3_stmt *pStmt = 0;
15291 /* ".recover" might output content in an order which causes immediate
15292 ** foreign key constraints to be violated. So disable foreign-key
15293 ** constraint enforcement to prevent problems when running the output
15295 raw_printf(pState->out, "PRAGMA foreign_keys=OFF;\n");
15296 raw_printf(pState->out, "BEGIN;\n");
15297 raw_printf(pState->out, "PRAGMA writable_schema = on;\n");
15298 shellPrepare(pState->db, &rc,
15299 "SELECT sql FROM recovery.schema "
15300 "WHERE type='table' AND sql LIKE 'create table%'", &pStmt
15302 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15303 const char *zCreateTable = (const char*)sqlite3_column_text(pStmt, 0);
15304 raw_printf(pState->out, "CREATE TABLE IF NOT EXISTS %s;\n",
15308 shellFinalize(&rc, pStmt);
15311 /* Figure out if an orphan table will be required. And if so, how many
15312 ** user columns it should contain */
15313 shellPrepare(pState->db, &rc,
15314 "SELECT coalesce(max(maxlen), -2) FROM recovery.map WHERE root>1"
15317 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){
15318 nOrphan = sqlite3_column_int(pLoop, 0);
15320 shellFinalize(&rc, pLoop);
15323 shellPrepare(pState->db, &rc,
15324 "SELECT pgno FROM recovery.map WHERE root=?", &pPages
15327 shellPrepare(pState->db, &rc,
15328 "SELECT max(field), group_concat(shell_escape_crnl(quote"
15329 "(case when (? AND field<0) then NULL else value end)"
15332 "FROM sqlite_dbdata WHERE pgno = ? AND field != ?"
15333 "GROUP BY cell", &pCells
15336 /* Loop through each root page. */
15337 shellPrepare(pState->db, &rc,
15338 "SELECT root, intkey, max(maxlen) FROM recovery.map"
15339 " WHERE root>1 GROUP BY root, intkey ORDER BY root=("
15340 " SELECT rootpage FROM recovery.schema WHERE name='sqlite_sequence'"
15343 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){
15344 int iRoot = sqlite3_column_int(pLoop, 0);
15345 int bIntkey = sqlite3_column_int(pLoop, 1);
15346 int nCol = sqlite3_column_int(pLoop, 2);
15348 RecoverTable *pTab;
15350 assert( bIntkey==0 || bIntkey==1 );
15351 pTab = recoverFindTable(pState, &rc, iRoot, bIntkey, nCol, &bNoop);
15352 if( bNoop || rc ) continue;
15355 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan);
15358 if( pTab==0 ) break;
15361 if( 0==sqlite3_stricmp(pTab->zQuoted, "\"sqlite_sequence\"") ){
15362 raw_printf(pState->out, "DELETE FROM sqlite_sequence;\n");
15364 sqlite3_bind_int(pPages, 1, iRoot);
15365 if( bRowids==0 && pTab->iPk<0 ){
15366 sqlite3_bind_int(pCells, 1, 1);
15368 sqlite3_bind_int(pCells, 1, 0);
15370 sqlite3_bind_int(pCells, 3, pTab->iPk);
15372 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPages) ){
15373 int iPgno = sqlite3_column_int(pPages, 0);
15374 sqlite3_bind_int(pCells, 2, iPgno);
15375 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pCells) ){
15376 int nField = sqlite3_column_int(pCells, 0);
15377 int iMin = sqlite3_column_int(pCells, 2);
15378 const char *zVal = (const char*)sqlite3_column_text(pCells, 1);
15380 RecoverTable *pTab2 = pTab;
15381 if( pTab!=pOrphan && (iMin<0)!=bIntkey ){
15383 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan);
15386 if( pTab2==0 ) break;
15390 if( pTab2==pOrphan ){
15391 raw_printf(pState->out,
15392 "INSERT INTO %s VALUES(%d, %d, %d, %s%s%s);\n",
15393 pTab2->zQuoted, iRoot, iPgno, nField,
15394 iMin<0 ? "" : "NULL, ", zVal, pTab2->azlCol[nField]
15397 raw_printf(pState->out, "INSERT INTO %s(%s) VALUES( %s );\n",
15398 pTab2->zQuoted, pTab2->azlCol[nField], zVal
15402 shellReset(&rc, pCells);
15404 shellReset(&rc, pPages);
15405 if( pTab!=pOrphan ) recoverFreeTable(pTab);
15407 shellFinalize(&rc, pLoop);
15408 shellFinalize(&rc, pPages);
15409 shellFinalize(&rc, pCells);
15410 recoverFreeTable(pOrphan);
15412 /* The rest of the schema */
15413 if( rc==SQLITE_OK ){
15414 sqlite3_stmt *pStmt = 0;
15415 shellPrepare(pState->db, &rc,
15416 "SELECT sql, name FROM recovery.schema "
15417 "WHERE sql NOT LIKE 'create table%'", &pStmt
15419 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15420 const char *zSql = (const char*)sqlite3_column_text(pStmt, 0);
15421 if( sqlite3_strnicmp(zSql, "create virt", 11)==0 ){
15422 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
15423 char *zPrint = shellMPrintf(&rc,
15424 "INSERT INTO sqlite_master VALUES('table', %Q, %Q, 0, %Q)",
15427 raw_printf(pState->out, "%s;\n", zPrint);
15428 sqlite3_free(zPrint);
15430 raw_printf(pState->out, "%s;\n", zSql);
15433 shellFinalize(&rc, pStmt);
15436 if( rc==SQLITE_OK ){
15437 raw_printf(pState->out, "PRAGMA writable_schema = off;\n");
15438 raw_printf(pState->out, "COMMIT;\n");
15440 sqlite3_exec(pState->db, "DETACH recovery", 0, 0, 0);
15443 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */
15447 ** If an input line begins with "." then invoke this routine to
15448 ** process that line.
15450 ** Return 1 on error, 2 to exit, and 0 otherwise.
15452 static int do_meta_command(char *zLine, ShellState *p){
15459 #ifndef SQLITE_OMIT_VIRTUALTABLE
15460 if( p->expert.pExpert ){
15461 expertFinish(p, 1, 0);
15465 /* Parse the input line into tokens.
15467 while( zLine[h] && nArg<ArraySize(azArg)-1 ){
15468 while( IsSpace(zLine[h]) ){ h++; }
15469 if( zLine[h]==0 ) break;
15470 if( zLine[h]=='\'' || zLine[h]=='"' ){
15471 int delim = zLine[h++];
15472 azArg[nArg++] = &zLine[h];
15473 while( zLine[h] && zLine[h]!=delim ){
15474 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
15477 if( zLine[h]==delim ){
15480 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
15482 azArg[nArg++] = &zLine[h];
15483 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
15484 if( zLine[h] ) zLine[h++] = 0;
15485 resolve_backslashes(azArg[nArg-1]);
15490 /* Process the input line.
15492 if( nArg==0 ) return 0; /* no tokens, no error */
15493 n = strlen30(azArg[0]);
15497 #ifndef SQLITE_OMIT_AUTHORIZATION
15498 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){
15500 raw_printf(stderr, "Usage: .auth ON|OFF\n");
15502 goto meta_command_exit;
15505 if( booleanValue(azArg[1]) ){
15506 sqlite3_set_authorizer(p->db, shellAuth, p);
15508 sqlite3_set_authorizer(p->db, 0, 0);
15513 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
15514 if( c=='a' && strncmp(azArg[0], "archive", n)==0 ){
15516 rc = arDotCommand(p, 0, azArg, nArg);
15520 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
15521 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
15523 const char *zDestFile = 0;
15524 const char *zDb = 0;
15526 sqlite3_backup *pBackup;
15529 const char *zVfs = 0;
15530 for(j=1; j<nArg; j++){
15531 const char *z = azArg[j];
15533 if( z[1]=='-' ) z++;
15534 if( strcmp(z, "-append")==0 ){
15537 if( strcmp(z, "-async")==0 ){
15541 utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
15544 }else if( zDestFile==0 ){
15545 zDestFile = azArg[j];
15546 }else if( zDb==0 ){
15548 zDestFile = azArg[j];
15550 raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
15554 if( zDestFile==0 ){
15555 raw_printf(stderr, "missing FILENAME argument on .backup\n");
15558 if( zDb==0 ) zDb = "main";
15559 rc = sqlite3_open_v2(zDestFile, &pDest,
15560 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs);
15561 if( rc!=SQLITE_OK ){
15562 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
15567 sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
15571 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
15573 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
15577 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
15578 sqlite3_backup_finish(pBackup);
15579 if( rc==SQLITE_DONE ){
15582 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
15588 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
15590 bail_on_error = booleanValue(azArg[1]);
15592 raw_printf(stderr, "Usage: .bail on|off\n");
15597 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
15599 if( booleanValue(azArg[1]) ){
15600 setBinaryMode(p->out, 1);
15602 setTextMode(p->out, 1);
15605 raw_printf(stderr, "Usage: .binary on|off\n");
15610 if( c=='c' && strcmp(azArg[0],"cd")==0 ){
15612 #if defined(_WIN32) || defined(WIN32)
15613 wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]);
15614 rc = !SetCurrentDirectoryW(z);
15617 rc = chdir(azArg[1]);
15620 utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]);
15624 raw_printf(stderr, "Usage: .cd DIRECTORY\n");
15629 /* The undocumented ".breakpoint" command causes a call to the no-op
15630 ** routine named test_breakpoint().
15632 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
15636 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
15638 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
15640 raw_printf(stderr, "Usage: .changes on|off\n");
15645 /* Cancel output redirection, if it is currently set (by .testcase)
15646 ** Then read the content of the testcase-out.txt file and compare against
15647 ** azArg[1]. If there are differences, report an error and exit.
15649 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){
15653 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n");
15655 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
15656 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n");
15658 }else if( testcase_glob(azArg[1],zRes)==0 ){
15659 utf8_printf(stderr,
15660 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
15661 p->zTestcase, azArg[1], zRes);
15664 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase);
15667 sqlite3_free(zRes);
15670 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
15672 tryToClone(p, azArg[1]);
15674 raw_printf(stderr, "Usage: .clone FILENAME\n");
15679 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
15683 memcpy(&data, p, sizeof(data));
15684 data.showHeader = 0;
15685 data.cMode = data.mode = MODE_List;
15686 sqlite3_snprintf(sizeof(data.colSeparator),data.colSeparator,": ");
15688 sqlite3_exec(p->db, "SELECT name, file FROM pragma_database_list",
15689 callback, &data, &zErrMsg);
15691 utf8_printf(stderr,"Error: %s\n", zErrMsg);
15692 sqlite3_free(zErrMsg);
15697 if( c=='d' && n>=3 && strncmp(azArg[0], "dbconfig", n)==0 ){
15698 static const struct DbConfigChoices {
15702 { "enable_fkey", SQLITE_DBCONFIG_ENABLE_FKEY },
15703 { "enable_trigger", SQLITE_DBCONFIG_ENABLE_TRIGGER },
15704 { "enable_view", SQLITE_DBCONFIG_ENABLE_VIEW },
15705 { "fts3_tokenizer", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
15706 { "load_extension", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
15707 { "no_ckpt_on_close", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE },
15708 { "enable_qpsg", SQLITE_DBCONFIG_ENABLE_QPSG },
15709 { "trigger_eqp", SQLITE_DBCONFIG_TRIGGER_EQP },
15710 { "reset_database", SQLITE_DBCONFIG_RESET_DATABASE },
15711 { "defensive", SQLITE_DBCONFIG_DEFENSIVE },
15712 { "writable_schema", SQLITE_DBCONFIG_WRITABLE_SCHEMA },
15713 { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE },
15714 { "dqs_dml", SQLITE_DBCONFIG_DQS_DML },
15715 { "dqs_ddl", SQLITE_DBCONFIG_DQS_DDL },
15719 for(ii=0; ii<ArraySize(aDbConfig); ii++){
15720 if( nArg>1 && strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
15722 sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
15724 sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
15725 utf8_printf(p->out, "%18s %s\n", aDbConfig[ii].zName, v ? "on" : "off");
15726 if( nArg>1 ) break;
15728 if( nArg>1 && ii==ArraySize(aDbConfig) ){
15729 utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]);
15730 utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n");
15734 if( c=='d' && n>=3 && strncmp(azArg[0], "dbinfo", n)==0 ){
15735 rc = shell_dbinfo_command(p, nArg, azArg);
15738 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
15739 if( c=='r' && strncmp(azArg[0], "recover", n)==0 ){
15741 rc = recoverDatabaseCmd(p, nArg, azArg);
15743 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */
15745 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
15746 const char *zLike = 0;
15748 int savedShowHeader = p->showHeader;
15749 int savedShellFlags = p->shellFlgs;
15750 ShellClearFlag(p, SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo);
15751 for(i=1; i<nArg; i++){
15752 if( azArg[i][0]=='-' ){
15753 const char *z = azArg[i]+1;
15754 if( z[0]=='-' ) z++;
15755 if( strcmp(z,"preserve-rowids")==0 ){
15756 #ifdef SQLITE_OMIT_VIRTUALTABLE
15757 raw_printf(stderr, "The --preserve-rowids option is not compatible"
15758 " with SQLITE_OMIT_VIRTUALTABLE\n");
15760 goto meta_command_exit;
15762 ShellSetFlag(p, SHFLG_PreserveRowid);
15765 if( strcmp(z,"newlines")==0 ){
15766 ShellSetFlag(p, SHFLG_Newlines);
15769 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
15771 goto meta_command_exit;
15774 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? "
15775 "?--newlines? ?LIKE-PATTERN?\n");
15777 goto meta_command_exit;
15785 /* When playing back a "dump", the content might appear in an order
15786 ** which causes immediate foreign key constraints to be violated.
15787 ** So disable foreign-key constraint enforcement to prevent problems. */
15788 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
15789 raw_printf(p->out, "BEGIN TRANSACTION;\n");
15790 p->writableSchema = 0;
15792 /* Set writable_schema=ON since doing so forces SQLite to initialize
15793 ** as much of the schema as it can even if the sqlite_master table is
15795 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
15798 run_schema_dump_query(p,
15799 "SELECT name, type, sql FROM sqlite_master "
15800 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
15802 run_schema_dump_query(p,
15803 "SELECT name, type, sql FROM sqlite_master "
15804 "WHERE name=='sqlite_sequence'"
15806 run_table_dump_query(p,
15807 "SELECT sql FROM sqlite_master "
15808 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
15812 zSql = sqlite3_mprintf(
15813 "SELECT name, type, sql FROM sqlite_master "
15814 "WHERE tbl_name LIKE %Q AND type=='table'"
15815 " AND sql NOT NULL", zLike);
15816 run_schema_dump_query(p,zSql);
15817 sqlite3_free(zSql);
15818 zSql = sqlite3_mprintf(
15819 "SELECT sql FROM sqlite_master "
15820 "WHERE sql NOT NULL"
15821 " AND type IN ('index','trigger','view')"
15822 " AND tbl_name LIKE %Q", zLike);
15823 run_table_dump_query(p, zSql, 0);
15824 sqlite3_free(zSql);
15826 if( p->writableSchema ){
15827 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
15828 p->writableSchema = 0;
15830 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
15831 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
15832 raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n");
15833 p->showHeader = savedShowHeader;
15834 p->shellFlgs = savedShellFlags;
15837 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
15839 setOrClearFlag(p, SHFLG_Echo, azArg[1]);
15841 raw_printf(stderr, "Usage: .echo on|off\n");
15846 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
15848 p->autoEQPtest = 0;
15849 if( p->autoEQPtrace ){
15850 if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0);
15851 p->autoEQPtrace = 0;
15853 if( strcmp(azArg[1],"full")==0 ){
15854 p->autoEQP = AUTOEQP_full;
15855 }else if( strcmp(azArg[1],"trigger")==0 ){
15856 p->autoEQP = AUTOEQP_trigger;
15857 #ifdef SQLITE_DEBUG
15858 }else if( strcmp(azArg[1],"test")==0 ){
15859 p->autoEQP = AUTOEQP_on;
15860 p->autoEQPtest = 1;
15861 }else if( strcmp(azArg[1],"trace")==0 ){
15862 p->autoEQP = AUTOEQP_full;
15863 p->autoEQPtrace = 1;
15865 sqlite3_exec(p->db, "SELECT name FROM sqlite_master LIMIT 1", 0, 0, 0);
15866 sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0);
15869 p->autoEQP = (u8)booleanValue(azArg[1]);
15872 raw_printf(stderr, "Usage: .eqp off|on|trace|trigger|full\n");
15877 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
15878 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
15882 /* The ".explain" command is automatic now. It is largely pointless. It
15883 ** retained purely for backwards compatibility */
15884 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
15887 if( strcmp(azArg[1],"auto")==0 ){
15890 val = booleanValue(azArg[1]);
15893 if( val==1 && p->mode!=MODE_Explain ){
15894 p->normalMode = p->mode;
15895 p->mode = MODE_Explain;
15896 p->autoExplain = 0;
15897 }else if( val==0 ){
15898 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
15899 p->autoExplain = 0;
15900 }else if( val==99 ){
15901 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
15902 p->autoExplain = 1;
15906 #ifndef SQLITE_OMIT_VIRTUALTABLE
15907 if( c=='e' && strncmp(azArg[0], "expert", n)==0 ){
15909 expertDotCommand(p, azArg, nArg);
15913 if( c=='f' && strncmp(azArg[0], "filectrl", n)==0 ){
15914 static const struct {
15915 const char *zCtrlName; /* Name of a test-control option */
15916 int ctrlCode; /* Integer code for that option */
15917 const char *zUsage; /* Usage notes */
15919 { "size_limit", SQLITE_FCNTL_SIZE_LIMIT, "[LIMIT]" },
15920 { "chunk_size", SQLITE_FCNTL_CHUNK_SIZE, "SIZE" },
15921 /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY, "COUNT DELAY" },*/
15922 { "persist_wal", SQLITE_FCNTL_PERSIST_WAL, "[BOOLEAN]" },
15923 { "psow", SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]" },
15924 /* { "pragma", SQLITE_FCNTL_PRAGMA, "NAME ARG" },*/
15925 { "tempfilename", SQLITE_FCNTL_TEMPFILENAME, "" },
15926 { "has_moved", SQLITE_FCNTL_HAS_MOVED, "" },
15927 { "lock_timeout", SQLITE_FCNTL_LOCK_TIMEOUT, "MILLISEC" },
15931 sqlite3_int64 iRes = 0; /* Integer result to display if rc2==1 */
15932 int isOk = 0; /* 0: usage 1: %lld 2: no-result */
15934 const char *zCmd = 0;
15937 zCmd = nArg>=2 ? azArg[1] : "help";
15939 /* The argument can optionally begin with "-" or "--" */
15940 if( zCmd[0]=='-' && zCmd[1] ){
15942 if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
15945 /* --help lists all file-controls */
15946 if( strcmp(zCmd,"help")==0 ){
15947 utf8_printf(p->out, "Available file-controls:\n");
15948 for(i=0; i<ArraySize(aCtrl); i++){
15949 utf8_printf(p->out, " .filectrl %s %s\n",
15950 aCtrl[i].zCtrlName, aCtrl[i].zUsage);
15953 goto meta_command_exit;
15956 /* convert filectrl text option to value. allow any unique prefix
15957 ** of the option name, or a numerical value. */
15958 n2 = strlen30(zCmd);
15959 for(i=0; i<ArraySize(aCtrl); i++){
15960 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
15962 filectrl = aCtrl[i].ctrlCode;
15965 utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n"
15966 "Use \".filectrl --help\" for help\n", zCmd);
15968 goto meta_command_exit;
15973 utf8_printf(stderr,"Error: unknown file-control: %s\n"
15974 "Use \".filectrl --help\" for help\n", zCmd);
15977 case SQLITE_FCNTL_SIZE_LIMIT: {
15978 if( nArg!=2 && nArg!=3 ) break;
15979 iRes = nArg==3 ? integerValue(azArg[2]) : -1;
15980 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_SIZE_LIMIT, &iRes);
15984 case SQLITE_FCNTL_LOCK_TIMEOUT:
15985 case SQLITE_FCNTL_CHUNK_SIZE: {
15987 if( nArg!=3 ) break;
15988 x = (int)integerValue(azArg[2]);
15989 sqlite3_file_control(p->db, 0, filectrl, &x);
15993 case SQLITE_FCNTL_PERSIST_WAL:
15994 case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
15996 if( nArg!=2 && nArg!=3 ) break;
15997 x = nArg==3 ? booleanValue(azArg[2]) : -1;
15998 sqlite3_file_control(p->db, 0, filectrl, &x);
16003 case SQLITE_FCNTL_HAS_MOVED: {
16005 if( nArg!=2 ) break;
16006 sqlite3_file_control(p->db, 0, filectrl, &x);
16011 case SQLITE_FCNTL_TEMPFILENAME: {
16013 if( nArg!=2 ) break;
16014 sqlite3_file_control(p->db, 0, filectrl, &z);
16016 utf8_printf(p->out, "%s\n", z);
16024 if( isOk==0 && iCtrl>=0 ){
16025 utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
16027 }else if( isOk==1 ){
16029 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
16030 raw_printf(p->out, "%s\n", zBuf);
16034 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
16038 memcpy(&data, p, sizeof(data));
16039 data.showHeader = 0;
16040 data.cMode = data.mode = MODE_Semi;
16041 if( nArg==2 && optionMatch(azArg[1], "indent") ){
16042 data.cMode = data.mode = MODE_Pretty;
16046 raw_printf(stderr, "Usage: .fullschema ?--indent?\n");
16048 goto meta_command_exit;
16051 rc = sqlite3_exec(p->db,
16053 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
16054 " FROM sqlite_master UNION ALL"
16055 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
16056 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
16058 callback, &data, &zErrMsg
16060 if( rc==SQLITE_OK ){
16061 sqlite3_stmt *pStmt;
16062 rc = sqlite3_prepare_v2(p->db,
16063 "SELECT rowid FROM sqlite_master"
16064 " WHERE name GLOB 'sqlite_stat[134]'",
16066 doStats = sqlite3_step(pStmt)==SQLITE_ROW;
16067 sqlite3_finalize(pStmt);
16070 raw_printf(p->out, "/* No STAT tables available */\n");
16072 raw_printf(p->out, "ANALYZE sqlite_master;\n");
16073 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
16074 callback, &data, &zErrMsg);
16075 data.cMode = data.mode = MODE_Insert;
16076 data.zDestTable = "sqlite_stat1";
16077 shell_exec(&data, "SELECT * FROM sqlite_stat1", &zErrMsg);
16078 data.zDestTable = "sqlite_stat4";
16079 shell_exec(&data, "SELECT * FROM sqlite_stat4", &zErrMsg);
16080 raw_printf(p->out, "ANALYZE sqlite_master;\n");
16084 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
16086 p->showHeader = booleanValue(azArg[1]);
16088 raw_printf(stderr, "Usage: .headers on|off\n");
16093 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
16095 n = showHelp(p->out, azArg[1]);
16097 utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]);
16100 showHelp(p->out, 0);
16104 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
16105 char *zTable; /* Insert data into this table */
16106 char *zFile; /* Name of file to extra content from */
16107 sqlite3_stmt *pStmt = NULL; /* A statement */
16108 int nCol; /* Number of columns in the table */
16109 int nByte; /* Number of bytes in an SQL string */
16110 int i, j; /* Loop counters */
16111 int needCommit; /* True to COMMIT or ROLLBACK at end */
16112 int nSep; /* Number of bytes in p->colSeparator[] */
16113 char *zSql; /* An SQL statement */
16114 ImportCtx sCtx; /* Reader context */
16115 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
16116 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
16119 raw_printf(stderr, "Usage: .import FILE TABLE\n");
16120 goto meta_command_exit;
16125 memset(&sCtx, 0, sizeof(sCtx));
16127 nSep = strlen30(p->colSeparator);
16130 "Error: non-null column separator required for import\n");
16134 raw_printf(stderr, "Error: multi-character column separators not allowed"
16138 nSep = strlen30(p->rowSeparator);
16140 raw_printf(stderr, "Error: non-null row separator required for import\n");
16143 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
16144 /* When importing CSV (only), if the row separator is set to the
16145 ** default output row separator, change it to the default input
16146 ** row separator. This avoids having to maintain different input
16147 ** and output row separators. */
16148 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16149 nSep = strlen30(p->rowSeparator);
16152 raw_printf(stderr, "Error: multi-character row separators not allowed"
16156 sCtx.zFile = zFile;
16158 if( sCtx.zFile[0]=='|' ){
16159 #ifdef SQLITE_OMIT_POPEN
16160 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
16163 sCtx.in = popen(sCtx.zFile+1, "r");
16164 sCtx.zFile = "<pipe>";
16168 sCtx.in = fopen(sCtx.zFile, "rb");
16171 if( p->mode==MODE_Ascii ){
16172 xRead = ascii_read_one_field;
16174 xRead = csv_read_one_field;
16177 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
16180 sCtx.cColSep = p->colSeparator[0];
16181 sCtx.cRowSep = p->rowSeparator[0];
16182 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
16185 shell_out_of_memory();
16187 nByte = strlen30(zSql);
16188 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16189 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
16190 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
16191 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
16193 while( xRead(&sCtx) ){
16194 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z);
16196 if( sCtx.cTerm!=sCtx.cColSep ) break;
16199 sqlite3_free(zCreate);
16200 sqlite3_free(sCtx.z);
16202 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
16205 zCreate = sqlite3_mprintf("%z\n)", zCreate);
16206 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
16207 sqlite3_free(zCreate);
16209 utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
16210 sqlite3_errmsg(p->db));
16211 sqlite3_free(sCtx.z);
16215 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16217 sqlite3_free(zSql);
16219 if (pStmt) sqlite3_finalize(pStmt);
16220 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
16224 nCol = sqlite3_column_count(pStmt);
16225 sqlite3_finalize(pStmt);
16227 if( nCol==0 ) return 0; /* no columns, no error */
16228 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
16231 shell_out_of_memory();
16233 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
16234 j = strlen30(zSql);
16235 for(i=1; i<nCol; i++){
16241 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16242 sqlite3_free(zSql);
16244 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16245 if (pStmt) sqlite3_finalize(pStmt);
16249 needCommit = sqlite3_get_autocommit(p->db);
16250 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
16252 int startLine = sCtx.nLine;
16253 for(i=0; i<nCol; i++){
16254 char *z = xRead(&sCtx);
16256 ** Did we reach end-of-file before finding any columns?
16257 ** If so, stop instead of NULL filling the remaining columns.
16259 if( z==0 && i==0 ) break;
16261 ** Did we reach end-of-file OR end-of-line before finding any
16262 ** columns in ASCII mode? If so, stop instead of NULL filling
16263 ** the remaining columns.
16265 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
16266 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
16267 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
16268 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
16269 "filling the rest with NULL\n",
16270 sCtx.zFile, startLine, nCol, i+1);
16272 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
16275 if( sCtx.cTerm==sCtx.cColSep ){
16279 }while( sCtx.cTerm==sCtx.cColSep );
16280 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
16281 "extras ignored\n",
16282 sCtx.zFile, startLine, nCol, i);
16285 sqlite3_step(pStmt);
16286 rc = sqlite3_reset(pStmt);
16287 if( rc!=SQLITE_OK ){
16288 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
16289 startLine, sqlite3_errmsg(p->db));
16292 }while( sCtx.cTerm!=EOF );
16295 sqlite3_free(sCtx.z);
16296 sqlite3_finalize(pStmt);
16297 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
16300 #ifndef SQLITE_UNTESTABLE
16301 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){
16303 char *zCollist = 0;
16304 sqlite3_stmt *pStmt;
16307 if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
16308 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n"
16309 " .imposter off\n");
16311 goto meta_command_exit;
16315 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1);
16316 goto meta_command_exit;
16318 zSql = sqlite3_mprintf("SELECT rootpage FROM sqlite_master"
16319 " WHERE name='%q' AND type='index'", azArg[1]);
16320 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16321 sqlite3_free(zSql);
16322 if( sqlite3_step(pStmt)==SQLITE_ROW ){
16323 tnum = sqlite3_column_int(pStmt, 0);
16325 sqlite3_finalize(pStmt);
16327 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]);
16329 goto meta_command_exit;
16331 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]);
16332 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16333 sqlite3_free(zSql);
16335 while( sqlite3_step(pStmt)==SQLITE_ROW ){
16337 const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
16340 if( sqlite3_column_int(pStmt,1)==-1 ){
16343 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i);
16348 zCollist = sqlite3_mprintf("\"%w\"", zCol);
16350 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
16353 sqlite3_finalize(pStmt);
16354 zSql = sqlite3_mprintf(
16355 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%s))WITHOUT ROWID",
16356 azArg[2], zCollist, zCollist);
16357 sqlite3_free(zCollist);
16358 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
16359 if( rc==SQLITE_OK ){
16360 rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
16361 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
16363 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
16365 utf8_printf(stdout, "%s;\n", zSql);
16367 "WARNING: writing to an imposter table will corrupt the index!\n"
16371 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
16374 sqlite3_free(zSql);
16376 #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
16378 #ifdef SQLITE_ENABLE_IOTRACE
16379 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
16380 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
16381 if( iotrace && iotrace!=stdout ) fclose(iotrace);
16384 sqlite3IoTrace = 0;
16385 }else if( strcmp(azArg[1], "-")==0 ){
16386 sqlite3IoTrace = iotracePrintf;
16389 iotrace = fopen(azArg[1], "w");
16391 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
16392 sqlite3IoTrace = 0;
16395 sqlite3IoTrace = iotracePrintf;
16401 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
16402 static const struct {
16403 const char *zLimitName; /* Name of a limit */
16404 int limitCode; /* Integer code for that limit */
16406 { "length", SQLITE_LIMIT_LENGTH },
16407 { "sql_length", SQLITE_LIMIT_SQL_LENGTH },
16408 { "column", SQLITE_LIMIT_COLUMN },
16409 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH },
16410 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT },
16411 { "vdbe_op", SQLITE_LIMIT_VDBE_OP },
16412 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG },
16413 { "attached", SQLITE_LIMIT_ATTACHED },
16414 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
16415 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER },
16416 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH },
16417 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS },
16422 for(i=0; i<ArraySize(aLimit); i++){
16423 printf("%20s %d\n", aLimit[i].zLimitName,
16424 sqlite3_limit(p->db, aLimit[i].limitCode, -1));
16426 }else if( nArg>3 ){
16427 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
16429 goto meta_command_exit;
16432 n2 = strlen30(azArg[1]);
16433 for(i=0; i<ArraySize(aLimit); i++){
16434 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
16438 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
16440 goto meta_command_exit;
16445 utf8_printf(stderr, "unknown limit: \"%s\"\n"
16446 "enter \".limits\" with no arguments for a list.\n",
16449 goto meta_command_exit;
16452 sqlite3_limit(p->db, aLimit[iLimit].limitCode,
16453 (int)integerValue(azArg[2]));
16455 printf("%20s %d\n", aLimit[iLimit].zLimitName,
16456 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
16460 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){
16462 lintDotCommand(p, azArg, nArg);
16465 #ifndef SQLITE_OMIT_LOAD_EXTENSION
16466 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
16467 const char *zFile, *zProc;
16470 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
16472 goto meta_command_exit;
16475 zProc = nArg>=3 ? azArg[2] : 0;
16477 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
16478 if( rc!=SQLITE_OK ){
16479 utf8_printf(stderr, "Error: %s\n", zErrMsg);
16480 sqlite3_free(zErrMsg);
16486 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
16488 raw_printf(stderr, "Usage: .log FILENAME\n");
16491 const char *zFile = azArg[1];
16492 output_file_close(p->pLog);
16493 p->pLog = output_file_open(zFile, 0);
16497 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
16498 const char *zMode = nArg>=2 ? azArg[1] : "";
16499 int n2 = strlen30(zMode);
16501 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
16502 p->mode = MODE_Line;
16503 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16504 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
16505 p->mode = MODE_Column;
16506 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16507 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
16508 p->mode = MODE_List;
16509 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column);
16510 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16511 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
16512 p->mode = MODE_Html;
16513 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
16514 p->mode = MODE_Tcl;
16515 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
16516 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16517 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
16518 p->mode = MODE_Csv;
16519 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
16520 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
16521 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
16522 p->mode = MODE_List;
16523 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
16524 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
16525 p->mode = MODE_Insert;
16526 set_table_name(p, nArg>=3 ? azArg[2] : "table");
16527 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){
16528 p->mode = MODE_Quote;
16529 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
16530 p->mode = MODE_Ascii;
16531 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
16532 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
16533 }else if( nArg==1 ){
16534 raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]);
16536 raw_printf(stderr, "Error: mode should be one of: "
16537 "ascii column csv html insert line list quote tabs tcl\n");
16540 p->cMode = p->mode;
16543 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
16545 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
16546 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
16548 raw_printf(stderr, "Usage: .nullvalue STRING\n");
16553 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
16554 char *zNewFilename; /* Name of the database file to open */
16555 int iName = 1; /* Index in azArg[] of the filename */
16556 int newFlag = 0; /* True to delete file before opening */
16557 /* Close the existing database */
16558 session_close_all(p);
16561 p->zDbFilename = 0;
16562 sqlite3_free(p->zFreeOnClose);
16563 p->zFreeOnClose = 0;
16564 p->openMode = SHELL_OPEN_UNSPEC;
16566 /* Check for command-line arguments */
16567 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){
16568 const char *z = azArg[iName];
16569 if( optionMatch(z,"new") ){
16571 #ifdef SQLITE_HAVE_ZLIB
16572 }else if( optionMatch(z, "zip") ){
16573 p->openMode = SHELL_OPEN_ZIPFILE;
16575 }else if( optionMatch(z, "append") ){
16576 p->openMode = SHELL_OPEN_APPENDVFS;
16577 }else if( optionMatch(z, "readonly") ){
16578 p->openMode = SHELL_OPEN_READONLY;
16579 #ifdef SQLITE_ENABLE_DESERIALIZE
16580 }else if( optionMatch(z, "deserialize") ){
16581 p->openMode = SHELL_OPEN_DESERIALIZE;
16582 }else if( optionMatch(z, "hexdb") ){
16583 p->openMode = SHELL_OPEN_HEXDB;
16584 }else if( optionMatch(z, "maxsize") && iName+1<nArg ){
16585 p->szMax = integerValue(azArg[++iName]);
16586 #endif /* SQLITE_ENABLE_DESERIALIZE */
16587 }else if( z[0]=='-' ){
16588 utf8_printf(stderr, "unknown option: %s\n", z);
16590 goto meta_command_exit;
16593 /* If a filename is specified, try to open it first */
16594 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0;
16595 if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){
16596 if( newFlag ) shellDeleteFile(zNewFilename);
16597 p->zDbFilename = zNewFilename;
16598 open_db(p, OPEN_DB_KEEPALIVE);
16600 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
16601 sqlite3_free(zNewFilename);
16603 p->zFreeOnClose = zNewFilename;
16607 /* As a fall-back open a TEMP database */
16608 p->zDbFilename = 0;
16614 && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0))
16615 || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0)
16617 const char *zFile = nArg>=2 ? azArg[1] : "stdout";
16619 if( azArg[0][0]=='e' ){
16620 /* Transform the ".excel" command into ".once -x" */
16623 zFile = azArg[1] = "-x";
16627 utf8_printf(stderr, "Usage: .%s [-e|-x|FILE]\n", azArg[0]);
16629 goto meta_command_exit;
16631 if( n>1 && strncmp(azArg[0], "once", n)==0 ){
16633 raw_printf(stderr, "Usage: .once (-e|-x|FILE)\n");
16635 goto meta_command_exit;
16642 if( zFile[0]=='-' && zFile[1]=='-' ) zFile++;
16643 #ifndef SQLITE_NOHAVE_SYSTEM
16644 if( strcmp(zFile, "-e")==0 || strcmp(zFile, "-x")==0 ){
16647 if( zFile[1]=='x' ){
16648 newTempFile(p, "csv");
16649 p->mode = MODE_Csv;
16650 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
16651 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
16653 newTempFile(p, "txt");
16656 zFile = p->zTempFile;
16658 #endif /* SQLITE_NOHAVE_SYSTEM */
16659 if( zFile[0]=='|' ){
16660 #ifdef SQLITE_OMIT_POPEN
16661 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
16665 p->out = popen(zFile + 1, "w");
16667 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
16671 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
16675 p->out = output_file_open(zFile, bTxtMode);
16677 if( strcmp(zFile,"off")!=0 ){
16678 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
16683 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
16688 if( c=='p' && n>=3 && strncmp(azArg[0], "parameter", n)==0 ){
16690 if( nArg<=1 ) goto parameter_syntax_error;
16692 /* .parameter clear
16693 ** Clear all bind parameters by dropping the TEMP table that holds them.
16695 if( nArg==2 && strcmp(azArg[1],"clear")==0 ){
16696 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;",
16701 ** List all bind parameters.
16703 if( nArg==2 && strcmp(azArg[1],"list")==0 ){
16704 sqlite3_stmt *pStmt = 0;
16707 rx = sqlite3_prepare_v2(p->db,
16708 "SELECT max(length(key)) "
16709 "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
16710 if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
16711 len = sqlite3_column_int(pStmt, 0);
16712 if( len>40 ) len = 40;
16714 sqlite3_finalize(pStmt);
16717 rx = sqlite3_prepare_v2(p->db,
16718 "SELECT key, quote(value) "
16719 "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
16720 while( sqlite3_step(pStmt)==SQLITE_ROW ){
16721 utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
16722 sqlite3_column_text(pStmt,1));
16724 sqlite3_finalize(pStmt);
16729 ** Make sure the TEMP table used to hold bind parameters exists.
16730 ** Create it if necessary.
16732 if( nArg==2 && strcmp(azArg[1],"init")==0 ){
16733 bind_table_init(p);
16736 /* .parameter set NAME VALUE
16737 ** Set or reset a bind parameter. NAME should be the full parameter
16738 ** name exactly as it appears in the query. (ex: $abc, @def). The
16739 ** VALUE can be in either SQL literal notation, or if not it will be
16740 ** understood to be a text string.
16742 if( nArg==4 && strcmp(azArg[1],"set")==0 ){
16745 sqlite3_stmt *pStmt;
16746 const char *zKey = azArg[2];
16747 const char *zValue = azArg[3];
16748 bind_table_init(p);
16749 zSql = sqlite3_mprintf(
16750 "REPLACE INTO temp.sqlite_parameters(key,value)"
16751 "VALUES(%Q,%s);", zKey, zValue);
16752 if( zSql==0 ) shell_out_of_memory();
16754 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16755 sqlite3_free(zSql);
16756 if( rx!=SQLITE_OK ){
16757 sqlite3_finalize(pStmt);
16759 zSql = sqlite3_mprintf(
16760 "REPLACE INTO temp.sqlite_parameters(key,value)"
16761 "VALUES(%Q,%Q);", zKey, zValue);
16762 if( zSql==0 ) shell_out_of_memory();
16763 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16764 sqlite3_free(zSql);
16765 if( rx!=SQLITE_OK ){
16766 utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
16767 sqlite3_finalize(pStmt);
16772 sqlite3_step(pStmt);
16773 sqlite3_finalize(pStmt);
16776 /* .parameter unset NAME
16777 ** Remove the NAME binding from the parameter binding table, if it
16780 if( nArg==3 && strcmp(azArg[1],"unset")==0 ){
16781 char *zSql = sqlite3_mprintf(
16782 "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]);
16783 if( zSql==0 ) shell_out_of_memory();
16784 sqlite3_exec(p->db, zSql, 0, 0, 0);
16785 sqlite3_free(zSql);
16787 /* If no command name matches, show a syntax error */
16788 parameter_syntax_error:
16789 showHelp(p->out, "parameter");
16792 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
16794 for(i=1; i<nArg; i++){
16795 if( i>1 ) raw_printf(p->out, " ");
16796 utf8_printf(p->out, "%s", azArg[i]);
16798 raw_printf(p->out, "\n");
16801 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
16802 if( c=='p' && n>=3 && strncmp(azArg[0], "progress", n)==0 ){
16805 p->flgProgress = 0;
16808 for(i=1; i<nArg; i++){
16809 const char *z = azArg[i];
16812 if( z[0]=='-' ) z++;
16813 if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){
16814 p->flgProgress |= SHELL_PROGRESS_QUIET;
16817 if( strcmp(z,"reset")==0 ){
16818 p->flgProgress |= SHELL_PROGRESS_RESET;
16821 if( strcmp(z,"once")==0 ){
16822 p->flgProgress |= SHELL_PROGRESS_ONCE;
16825 if( strcmp(z,"limit")==0 ){
16827 utf8_printf(stderr, "Error: missing argument on --limit\n");
16829 goto meta_command_exit;
16831 p->mxProgress = (int)integerValue(azArg[++i]);
16835 utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]);
16837 goto meta_command_exit;
16839 nn = (int)integerValue(z);
16843 sqlite3_progress_handler(p->db, nn, progress_handler, p);
16845 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
16847 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
16849 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
16852 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
16856 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
16860 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
16861 FILE *inSaved = p->in;
16862 int savedLineno = p->lineno;
16864 raw_printf(stderr, "Usage: .read FILE\n");
16866 goto meta_command_exit;
16868 p->in = fopen(azArg[1], "rb");
16870 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
16873 rc = process_input(p);
16877 p->lineno = savedLineno;
16880 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
16881 const char *zSrcFile;
16884 sqlite3_backup *pBackup;
16888 zSrcFile = azArg[1];
16890 }else if( nArg==3 ){
16891 zSrcFile = azArg[2];
16894 raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
16896 goto meta_command_exit;
16898 rc = sqlite3_open(zSrcFile, &pSrc);
16899 if( rc!=SQLITE_OK ){
16900 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
16905 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
16907 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16911 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
16912 || rc==SQLITE_BUSY ){
16913 if( rc==SQLITE_BUSY ){
16914 if( nTimeout++ >= 3 ) break;
16915 sqlite3_sleep(100);
16918 sqlite3_backup_finish(pBackup);
16919 if( rc==SQLITE_DONE ){
16921 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
16922 raw_printf(stderr, "Error: source database is busy\n");
16925 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16931 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
16933 p->scanstatsOn = (u8)booleanValue(azArg[1]);
16934 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
16935 raw_printf(stderr, "Warning: .scanstats not available in this build.\n");
16938 raw_printf(stderr, "Usage: .scanstats on|off\n");
16943 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
16947 const char *zDiv = "(";
16948 const char *zName = 0;
16954 memcpy(&data, p, sizeof(data));
16955 data.showHeader = 0;
16956 data.cMode = data.mode = MODE_Semi;
16957 initText(&sSelect);
16958 for(ii=1; ii<nArg; ii++){
16959 if( optionMatch(azArg[ii],"indent") ){
16960 data.cMode = data.mode = MODE_Pretty;
16961 }else if( optionMatch(azArg[ii],"debug") ){
16963 }else if( zName==0 ){
16966 raw_printf(stderr, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n");
16968 goto meta_command_exit;
16972 int isMaster = sqlite3_strlike(zName, "sqlite_master", '\\')==0;
16973 if( isMaster || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0 ){
16974 char *new_argv[2], *new_colv[2];
16975 new_argv[0] = sqlite3_mprintf(
16976 "CREATE TABLE %s (\n"
16979 " tbl_name text,\n"
16980 " rootpage integer,\n"
16982 ")", isMaster ? "sqlite_master" : "sqlite_temp_master");
16984 new_colv[0] = "sql";
16986 callback(&data, 1, new_argv, new_colv);
16987 sqlite3_free(new_argv[0]);
16991 sqlite3_stmt *pStmt = 0;
16992 rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
16995 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16996 sqlite3_finalize(pStmt);
16998 goto meta_command_exit;
17000 appendText(&sSelect, "SELECT sql FROM", 0);
17002 while( sqlite3_step(pStmt)==SQLITE_ROW ){
17003 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0);
17005 sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema);
17006 appendText(&sSelect, zDiv, 0);
17007 zDiv = " UNION ALL ";
17008 appendText(&sSelect, "SELECT shell_add_schema(sql,", 0);
17009 if( sqlite3_stricmp(zDb, "main")!=0 ){
17010 appendText(&sSelect, zDb, '\'');
17012 appendText(&sSelect, "NULL", 0);
17014 appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0);
17015 appendText(&sSelect, zScNum, 0);
17016 appendText(&sSelect, " AS snum, ", 0);
17017 appendText(&sSelect, zDb, '\'');
17018 appendText(&sSelect, " AS sname FROM ", 0);
17019 appendText(&sSelect, zDb, quoteChar(zDb));
17020 appendText(&sSelect, ".sqlite_master", 0);
17022 sqlite3_finalize(pStmt);
17023 #ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS
17025 appendText(&sSelect,
17026 " UNION ALL SELECT shell_module_schema(name),"
17027 " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list",
17031 appendText(&sSelect, ") WHERE ", 0);
17033 char *zQarg = sqlite3_mprintf("%Q", zName);
17034 int bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 ||
17035 strchr(zName, '[') != 0;
17036 if( strchr(zName, '.') ){
17037 appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0);
17039 appendText(&sSelect, "lower(tbl_name)", 0);
17041 appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0);
17042 appendText(&sSelect, zQarg, 0);
17044 appendText(&sSelect, " ESCAPE '\\' ", 0);
17046 appendText(&sSelect, " AND ", 0);
17047 sqlite3_free(zQarg);
17049 appendText(&sSelect, "type!='meta' AND sql IS NOT NULL"
17050 " ORDER BY snum, rowid", 0);
17052 utf8_printf(p->out, "SQL: %s;\n", sSelect.z);
17054 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
17056 freeText(&sSelect);
17059 utf8_printf(stderr,"Error: %s\n", zErrMsg);
17060 sqlite3_free(zErrMsg);
17062 }else if( rc != SQLITE_OK ){
17063 raw_printf(stderr,"Error: querying schema information\n");
17070 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
17071 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
17072 sqlite3SelectTrace = (int)integerValue(azArg[1]);
17076 #if defined(SQLITE_ENABLE_SESSION)
17077 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){
17078 OpenSession *pSession = &p->aSession[0];
17079 char **azCmd = &azArg[1];
17081 int nCmd = nArg - 1;
17083 if( nArg<=1 ) goto session_syntax_error;
17086 for(iSes=0; iSes<p->nSession; iSes++){
17087 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break;
17089 if( iSes<p->nSession ){
17090 pSession = &p->aSession[iSes];
17094 pSession = &p->aSession[0];
17099 /* .session attach TABLE
17100 ** Invoke the sqlite3session_attach() interface to attach a particular
17101 ** table so that it is never filtered.
17103 if( strcmp(azCmd[0],"attach")==0 ){
17104 if( nCmd!=2 ) goto session_syntax_error;
17105 if( pSession->p==0 ){
17107 raw_printf(stderr, "ERROR: No sessions are open\n");
17109 rc = sqlite3session_attach(pSession->p, azCmd[1]);
17111 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc);
17117 /* .session changeset FILE
17118 ** .session patchset FILE
17119 ** Write a changeset or patchset into a file. The file is overwritten.
17121 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){
17123 if( nCmd!=2 ) goto session_syntax_error;
17124 if( pSession->p==0 ) goto session_not_open;
17125 out = fopen(azCmd[1], "wb");
17127 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n",
17132 if( azCmd[0][0]=='c' ){
17133 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
17135 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
17138 printf("Error: error code %d\n", rc);
17142 && fwrite(pChng, szChng, 1, out)!=1 ){
17143 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n",
17146 sqlite3_free(pChng);
17152 ** Close the identified session
17154 if( strcmp(azCmd[0], "close")==0 ){
17155 if( nCmd!=1 ) goto session_syntax_error;
17157 session_close(pSession);
17158 p->aSession[iSes] = p->aSession[--p->nSession];
17162 /* .session enable ?BOOLEAN?
17163 ** Query or set the enable flag
17165 if( strcmp(azCmd[0], "enable")==0 ){
17167 if( nCmd>2 ) goto session_syntax_error;
17168 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
17170 ii = sqlite3session_enable(pSession->p, ii);
17171 utf8_printf(p->out, "session %s enable flag = %d\n",
17172 pSession->zName, ii);
17176 /* .session filter GLOB ....
17177 ** Set a list of GLOB patterns of table names to be excluded.
17179 if( strcmp(azCmd[0], "filter")==0 ){
17181 if( nCmd<2 ) goto session_syntax_error;
17183 for(ii=0; ii<pSession->nFilter; ii++){
17184 sqlite3_free(pSession->azFilter[ii]);
17186 sqlite3_free(pSession->azFilter);
17187 nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
17188 pSession->azFilter = sqlite3_malloc( nByte );
17189 if( pSession->azFilter==0 ){
17190 raw_printf(stderr, "Error: out or memory\n");
17193 for(ii=1; ii<nCmd; ii++){
17194 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
17196 pSession->nFilter = ii-1;
17200 /* .session indirect ?BOOLEAN?
17201 ** Query or set the indirect flag
17203 if( strcmp(azCmd[0], "indirect")==0 ){
17205 if( nCmd>2 ) goto session_syntax_error;
17206 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
17208 ii = sqlite3session_indirect(pSession->p, ii);
17209 utf8_printf(p->out, "session %s indirect flag = %d\n",
17210 pSession->zName, ii);
17214 /* .session isempty
17215 ** Determine if the session is empty
17217 if( strcmp(azCmd[0], "isempty")==0 ){
17219 if( nCmd!=1 ) goto session_syntax_error;
17221 ii = sqlite3session_isempty(pSession->p);
17222 utf8_printf(p->out, "session %s isempty flag = %d\n",
17223 pSession->zName, ii);
17228 ** List all currently open sessions
17230 if( strcmp(azCmd[0],"list")==0 ){
17231 for(i=0; i<p->nSession; i++){
17232 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName);
17236 /* .session open DB NAME
17237 ** Open a new session called NAME on the attached database DB.
17238 ** DB is normally "main".
17240 if( strcmp(azCmd[0],"open")==0 ){
17242 if( nCmd!=3 ) goto session_syntax_error;
17244 if( zName[0]==0 ) goto session_syntax_error;
17245 for(i=0; i<p->nSession; i++){
17246 if( strcmp(p->aSession[i].zName,zName)==0 ){
17247 utf8_printf(stderr, "Session \"%s\" already exists\n", zName);
17248 goto meta_command_exit;
17251 if( p->nSession>=ArraySize(p->aSession) ){
17252 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession));
17253 goto meta_command_exit;
17255 pSession = &p->aSession[p->nSession];
17256 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
17258 raw_printf(stderr, "Cannot open session: error code=%d\n", rc);
17260 goto meta_command_exit;
17262 pSession->nFilter = 0;
17263 sqlite3session_table_filter(pSession->p, session_filter, pSession);
17265 pSession->zName = sqlite3_mprintf("%s", zName);
17267 /* If no command name matches, show a syntax error */
17268 session_syntax_error:
17269 showHelp(p->out, "session");
17273 #ifdef SQLITE_DEBUG
17274 /* Undocumented commands for internal testing. Subject to change
17275 ** without notice. */
17276 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
17277 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
17279 for(i=1; i<nArg; i++){
17280 v = booleanValue(azArg[i]);
17281 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
17284 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
17285 int i; sqlite3_int64 v;
17286 for(i=1; i<nArg; i++){
17288 v = integerValue(azArg[i]);
17289 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
17290 utf8_printf(p->out, "%s", zBuf);
17296 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
17297 int bIsInit = 0; /* True to initialize the SELFTEST table */
17298 int bVerbose = 0; /* Verbose output */
17299 int bSelftestExists; /* True if SELFTEST already exists */
17300 int i, k; /* Loop counters */
17301 int nTest = 0; /* Number of tests runs */
17302 int nErr = 0; /* Number of errors seen */
17303 ShellText str; /* Answer for a query */
17304 sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */
17307 for(i=1; i<nArg; i++){
17308 const char *z = azArg[i];
17309 if( z[0]=='-' && z[1]=='-' ) z++;
17310 if( strcmp(z,"-init")==0 ){
17313 if( strcmp(z,"-v")==0 ){
17317 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
17318 azArg[i], azArg[0]);
17319 raw_printf(stderr, "Should be one of: --init -v\n");
17321 goto meta_command_exit;
17324 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
17326 bSelftestExists = 0;
17328 bSelftestExists = 1;
17331 createSelftestTable(p);
17332 bSelftestExists = 1;
17335 appendText(&str, "x", 0);
17336 for(k=bSelftestExists; k>=0; k--){
17338 rc = sqlite3_prepare_v2(p->db,
17339 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
17342 rc = sqlite3_prepare_v2(p->db,
17343 "VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
17344 " (1,'run','PRAGMA integrity_check','ok')",
17348 raw_printf(stderr, "Error querying the selftest table\n");
17350 sqlite3_finalize(pStmt);
17351 goto meta_command_exit;
17353 for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
17354 int tno = sqlite3_column_int(pStmt, 0);
17355 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1);
17356 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2);
17357 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3);
17361 char *zQuote = sqlite3_mprintf("%q", zSql);
17362 printf("%d: %s %s\n", tno, zOp, zSql);
17363 sqlite3_free(zQuote);
17365 if( strcmp(zOp,"memo")==0 ){
17366 utf8_printf(p->out, "%s\n", zSql);
17368 if( strcmp(zOp,"run")==0 ){
17372 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
17375 utf8_printf(p->out, "Result: %s\n", str.z);
17377 if( rc || zErrMsg ){
17380 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
17381 sqlite3_free(zErrMsg);
17382 }else if( strcmp(zAns,str.z)!=0 ){
17385 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
17386 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
17390 utf8_printf(stderr,
17391 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
17395 } /* End loop over rows of content from SELFTEST */
17396 sqlite3_finalize(pStmt);
17397 } /* End loop over k */
17399 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
17402 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
17403 if( nArg<2 || nArg>3 ){
17404 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
17408 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
17409 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
17412 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
17413 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
17417 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
17418 const char *zLike = 0; /* Which table to checksum. 0 means everything */
17419 int i; /* Loop counter */
17420 int bSchema = 0; /* Also hash the schema */
17421 int bSeparate = 0; /* Hash each table separately */
17422 int iSize = 224; /* Hash algorithm to use */
17423 int bDebug = 0; /* Only show the query that would have run */
17424 sqlite3_stmt *pStmt; /* For querying tables names */
17425 char *zSql; /* SQL to be run */
17426 char *zSep; /* Separator */
17427 ShellText sSql; /* Complete SQL for the query to run the hash */
17428 ShellText sQuery; /* Set of queries used to read all content */
17430 for(i=1; i<nArg; i++){
17431 const char *z = azArg[i];
17434 if( z[0]=='-' ) z++;
17435 if( strcmp(z,"schema")==0 ){
17438 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
17439 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
17441 iSize = atoi(&z[5]);
17443 if( strcmp(z,"debug")==0 ){
17447 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
17448 azArg[i], azArg[0]);
17449 showHelp(p->out, azArg[0]);
17451 goto meta_command_exit;
17454 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
17456 goto meta_command_exit;
17460 if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1;
17464 zSql = "SELECT lower(name) FROM sqlite_master"
17465 " WHERE type='table' AND coalesce(rootpage,0)>1"
17466 " UNION ALL SELECT 'sqlite_master'"
17467 " ORDER BY 1 collate nocase";
17469 zSql = "SELECT lower(name) FROM sqlite_master"
17470 " WHERE type='table' AND coalesce(rootpage,0)>1"
17471 " AND name NOT LIKE 'sqlite_%'"
17472 " ORDER BY 1 collate nocase";
17474 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
17477 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
17479 while( SQLITE_ROW==sqlite3_step(pStmt) ){
17480 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
17481 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
17482 if( strncmp(zTab, "sqlite_",7)!=0 ){
17483 appendText(&sQuery,"SELECT * FROM ", 0);
17484 appendText(&sQuery,zTab,'"');
17485 appendText(&sQuery," NOT INDEXED;", 0);
17486 }else if( strcmp(zTab, "sqlite_master")==0 ){
17487 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
17488 " ORDER BY name;", 0);
17489 }else if( strcmp(zTab, "sqlite_sequence")==0 ){
17490 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
17491 " ORDER BY name;", 0);
17492 }else if( strcmp(zTab, "sqlite_stat1")==0 ){
17493 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
17494 " ORDER BY tbl,idx;", 0);
17495 }else if( strcmp(zTab, "sqlite_stat4")==0 ){
17496 appendText(&sQuery, "SELECT * FROM ", 0);
17497 appendText(&sQuery, zTab, 0);
17498 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
17500 appendText(&sSql, zSep, 0);
17501 appendText(&sSql, sQuery.z, '\'');
17503 appendText(&sSql, ",", 0);
17504 appendText(&sSql, zTab, '\'');
17507 sqlite3_finalize(pStmt);
17509 zSql = sqlite3_mprintf(
17511 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
17512 " FROM [sha3sum$query]",
17515 zSql = sqlite3_mprintf(
17517 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
17518 " FROM [sha3sum$query]",
17524 utf8_printf(p->out, "%s\n", zSql);
17526 shell_exec(p, zSql, 0);
17528 sqlite3_free(zSql);
17531 #ifndef SQLITE_NOHAVE_SYSTEM
17533 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
17538 raw_printf(stderr, "Usage: .system COMMAND\n");
17540 goto meta_command_exit;
17542 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
17543 for(i=2; i<nArg; i++){
17544 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
17548 sqlite3_free(zCmd);
17549 if( x ) raw_printf(stderr, "System command returns %d\n", x);
17551 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
17553 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
17554 static const char *azBool[] = { "off", "on", "trigger", "full"};
17557 raw_printf(stderr, "Usage: .show\n");
17559 goto meta_command_exit;
17561 utf8_printf(p->out, "%12.12s: %s\n","echo",
17562 azBool[ShellHasFlag(p, SHFLG_Echo)]);
17563 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
17564 utf8_printf(p->out, "%12.12s: %s\n","explain",
17565 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
17566 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
17567 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
17568 utf8_printf(p->out, "%12.12s: ", "nullvalue");
17569 output_c_string(p->out, p->nullValue);
17570 raw_printf(p->out, "\n");
17571 utf8_printf(p->out,"%12.12s: %s\n","output",
17572 strlen30(p->outfile) ? p->outfile : "stdout");
17573 utf8_printf(p->out,"%12.12s: ", "colseparator");
17574 output_c_string(p->out, p->colSeparator);
17575 raw_printf(p->out, "\n");
17576 utf8_printf(p->out,"%12.12s: ", "rowseparator");
17577 output_c_string(p->out, p->rowSeparator);
17578 raw_printf(p->out, "\n");
17579 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]);
17580 utf8_printf(p->out, "%12.12s: ", "width");
17581 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
17582 raw_printf(p->out, "%d ", p->colWidth[i]);
17584 raw_printf(p->out, "\n");
17585 utf8_printf(p->out, "%12.12s: %s\n", "filename",
17586 p->zDbFilename ? p->zDbFilename : "");
17589 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
17591 p->statsOn = (u8)booleanValue(azArg[1]);
17592 }else if( nArg==1 ){
17593 display_stats(p->db, p, 0);
17595 raw_printf(stderr, "Usage: .stats ?on|off?\n");
17600 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0)
17601 || (c=='i' && (strncmp(azArg[0], "indices", n)==0
17602 || strncmp(azArg[0], "indexes", n)==0) )
17604 sqlite3_stmt *pStmt;
17611 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
17613 sqlite3_finalize(pStmt);
17614 return shellDatabaseError(p->db);
17617 if( nArg>2 && c=='i' ){
17618 /* It is an historical accident that the .indexes command shows an error
17619 ** when called with the wrong number of arguments whereas the .tables
17620 ** command does not. */
17621 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
17623 sqlite3_finalize(pStmt);
17624 goto meta_command_exit;
17626 for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
17627 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
17628 if( zDbName==0 ) continue;
17629 if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0);
17630 if( sqlite3_stricmp(zDbName, "main")==0 ){
17631 appendText(&s, "SELECT name FROM ", 0);
17633 appendText(&s, "SELECT ", 0);
17634 appendText(&s, zDbName, '\'');
17635 appendText(&s, "||'.'||name FROM ", 0);
17637 appendText(&s, zDbName, '"');
17638 appendText(&s, ".sqlite_master ", 0);
17640 appendText(&s," WHERE type IN ('table','view')"
17641 " AND name NOT LIKE 'sqlite_%'"
17642 " AND name LIKE ?1", 0);
17644 appendText(&s," WHERE type='index'"
17645 " AND tbl_name LIKE ?1", 0);
17648 rc = sqlite3_finalize(pStmt);
17649 appendText(&s, " ORDER BY 1", 0);
17650 rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0);
17652 if( rc ) return shellDatabaseError(p->db);
17654 /* Run the SQL statement prepared by the above block. Store the results
17655 ** as an array of nul-terminated strings in azResult[]. */
17659 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
17661 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
17663 while( sqlite3_step(pStmt)==SQLITE_ROW ){
17664 if( nRow>=nAlloc ){
17666 int n2 = nAlloc*2 + 10;
17667 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
17668 if( azNew==0 ) shell_out_of_memory();
17672 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
17673 if( 0==azResult[nRow] ) shell_out_of_memory();
17676 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
17677 rc = shellDatabaseError(p->db);
17680 /* Pretty-print the contents of array azResult[] to the output */
17681 if( rc==0 && nRow>0 ){
17682 int len, maxlen = 0;
17684 int nPrintCol, nPrintRow;
17685 for(i=0; i<nRow; i++){
17686 len = strlen30(azResult[i]);
17687 if( len>maxlen ) maxlen = len;
17689 nPrintCol = 80/(maxlen+2);
17690 if( nPrintCol<1 ) nPrintCol = 1;
17691 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
17692 for(i=0; i<nPrintRow; i++){
17693 for(j=i; j<nRow; j+=nPrintRow){
17694 char *zSp = j<nPrintRow ? "" : " ";
17695 utf8_printf(p->out, "%s%-*s", zSp, maxlen,
17696 azResult[j] ? azResult[j]:"");
17698 raw_printf(p->out, "\n");
17702 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
17703 sqlite3_free(azResult);
17706 /* Begin redirecting output to the file "testcase-out.txt" */
17707 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){
17709 p->out = output_file_open("testcase-out.txt", 0);
17711 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n");
17714 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
17716 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
17720 #ifndef SQLITE_UNTESTABLE
17721 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 ){
17722 static const struct {
17723 const char *zCtrlName; /* Name of a test-control option */
17724 int ctrlCode; /* Integer code for that option */
17725 const char *zUsage; /* Usage notes */
17727 { "always", SQLITE_TESTCTRL_ALWAYS, "BOOLEAN" },
17728 { "assert", SQLITE_TESTCTRL_ASSERT, "BOOLEAN" },
17729 /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, "" },*/
17730 /*{ "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST, "" },*/
17731 { "byteorder", SQLITE_TESTCTRL_BYTEORDER, "" },
17732 { "extra_schema_checks",SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS,"BOOLEAN" },
17733 /*{ "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL, "" },*/
17734 { "imposter", SQLITE_TESTCTRL_IMPOSTER, "SCHEMA ON/OFF ROOTPAGE"},
17735 { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "BOOLEAN" },
17736 { "localtime_fault", SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN" },
17737 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN" },
17738 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK" },
17740 { "parser_coverage", SQLITE_TESTCTRL_PARSER_COVERAGE, "" },
17742 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE, "OFFSET " },
17743 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE, "" },
17744 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE, "" },
17745 { "prng_seed", SQLITE_TESTCTRL_PRNG_SEED, "SEED ?db?" },
17746 { "reserve", SQLITE_TESTCTRL_RESERVE, "BYTES-OF-RESERVE"},
17750 int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */
17753 const char *zCmd = 0;
17756 zCmd = nArg>=2 ? azArg[1] : "help";
17758 /* The argument can optionally begin with "-" or "--" */
17759 if( zCmd[0]=='-' && zCmd[1] ){
17761 if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
17764 /* --help lists all test-controls */
17765 if( strcmp(zCmd,"help")==0 ){
17766 utf8_printf(p->out, "Available test-controls:\n");
17767 for(i=0; i<ArraySize(aCtrl); i++){
17768 utf8_printf(p->out, " .testctrl %s %s\n",
17769 aCtrl[i].zCtrlName, aCtrl[i].zUsage);
17772 goto meta_command_exit;
17775 /* convert testctrl text option to value. allow any unique prefix
17776 ** of the option name, or a numerical value. */
17777 n2 = strlen30(zCmd);
17778 for(i=0; i<ArraySize(aCtrl); i++){
17779 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
17781 testctrl = aCtrl[i].ctrlCode;
17784 utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n"
17785 "Use \".testctrl --help\" for help\n", zCmd);
17787 goto meta_command_exit;
17792 utf8_printf(stderr,"Error: unknown test-control: %s\n"
17793 "Use \".testctrl --help\" for help\n", zCmd);
17797 /* sqlite3_test_control(int, db, int) */
17798 case SQLITE_TESTCTRL_OPTIMIZATIONS:
17799 case SQLITE_TESTCTRL_RESERVE:
17801 int opt = (int)strtol(azArg[2], 0, 0);
17802 rc2 = sqlite3_test_control(testctrl, p->db, opt);
17807 /* sqlite3_test_control(int) */
17808 case SQLITE_TESTCTRL_PRNG_SAVE:
17809 case SQLITE_TESTCTRL_PRNG_RESTORE:
17810 case SQLITE_TESTCTRL_PRNG_RESET:
17811 case SQLITE_TESTCTRL_BYTEORDER:
17813 rc2 = sqlite3_test_control(testctrl);
17814 isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3;
17818 /* sqlite3_test_control(int, uint) */
17819 case SQLITE_TESTCTRL_PENDING_BYTE:
17821 unsigned int opt = (unsigned int)integerValue(azArg[2]);
17822 rc2 = sqlite3_test_control(testctrl, opt);
17827 /* sqlite3_test_control(int, int, sqlite3*) */
17828 case SQLITE_TESTCTRL_PRNG_SEED:
17829 if( nArg==3 || nArg==4 ){
17830 int ii = (int)integerValue(azArg[2]);
17832 if( ii==0 && strcmp(azArg[2],"random")==0 ){
17833 sqlite3_randomness(sizeof(ii),&ii);
17834 printf("-- random seed: %d\n", ii);
17840 /* Make sure the schema has been loaded */
17841 sqlite3_table_column_metadata(db, 0, "x", 0, 0, 0, 0, 0, 0);
17843 rc2 = sqlite3_test_control(testctrl, ii, db);
17848 /* sqlite3_test_control(int, int) */
17849 case SQLITE_TESTCTRL_ASSERT:
17850 case SQLITE_TESTCTRL_ALWAYS:
17851 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS:
17853 int opt = booleanValue(azArg[2]);
17854 rc2 = sqlite3_test_control(testctrl, opt);
17859 /* sqlite3_test_control(int, int) */
17860 case SQLITE_TESTCTRL_LOCALTIME_FAULT:
17861 case SQLITE_TESTCTRL_NEVER_CORRUPT:
17863 int opt = booleanValue(azArg[2]);
17864 rc2 = sqlite3_test_control(testctrl, opt);
17869 case SQLITE_TESTCTRL_IMPOSTER:
17871 rc2 = sqlite3_test_control(testctrl, p->db,
17873 integerValue(azArg[3]),
17874 integerValue(azArg[4]));
17880 case SQLITE_TESTCTRL_PARSER_COVERAGE:
17882 sqlite3_test_control(testctrl, p->out);
17888 if( isOk==0 && iCtrl>=0 ){
17889 utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
17891 }else if( isOk==1 ){
17892 raw_printf(p->out, "%d\n", rc2);
17893 }else if( isOk==2 ){
17894 raw_printf(p->out, "0x%08x\n", rc2);
17897 #endif /* !defined(SQLITE_UNTESTABLE) */
17899 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
17901 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
17904 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
17906 enableTimer = booleanValue(azArg[1]);
17907 if( enableTimer && !HAS_TIMER ){
17908 raw_printf(stderr, "Error: timer not available on this system.\n");
17912 raw_printf(stderr, "Usage: .timer on|off\n");
17917 #ifndef SQLITE_OMIT_TRACE
17918 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
17922 for(jj=1; jj<nArg; jj++){
17923 const char *z = azArg[jj];
17925 if( optionMatch(z, "expanded") ){
17926 p->eTraceType = SHELL_TRACE_EXPANDED;
17928 #ifdef SQLITE_ENABLE_NORMALIZE
17929 else if( optionMatch(z, "normalized") ){
17930 p->eTraceType = SHELL_TRACE_NORMALIZED;
17933 else if( optionMatch(z, "plain") ){
17934 p->eTraceType = SHELL_TRACE_PLAIN;
17936 else if( optionMatch(z, "profile") ){
17937 mType |= SQLITE_TRACE_PROFILE;
17939 else if( optionMatch(z, "row") ){
17940 mType |= SQLITE_TRACE_ROW;
17942 else if( optionMatch(z, "stmt") ){
17943 mType |= SQLITE_TRACE_STMT;
17945 else if( optionMatch(z, "close") ){
17946 mType |= SQLITE_TRACE_CLOSE;
17949 raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z);
17951 goto meta_command_exit;
17954 output_file_close(p->traceOut);
17955 p->traceOut = output_file_open(azArg[1], 0);
17958 if( p->traceOut==0 ){
17959 sqlite3_trace_v2(p->db, 0, 0, 0);
17961 if( mType==0 ) mType = SQLITE_TRACE_STMT;
17962 sqlite3_trace_v2(p->db, mType, sql_trace_callback, p);
17965 #endif /* !defined(SQLITE_OMIT_TRACE) */
17967 #if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_VIRTUALTABLE)
17968 if( c=='u' && strncmp(azArg[0], "unmodule", n)==0 ){
17973 raw_printf(stderr, "Usage: .unmodule [--allexcept] NAME ...\n");
17975 goto meta_command_exit;
17979 if( zOpt[0]=='-' && zOpt[1]=='-' && zOpt[2]!=0 ) zOpt++;
17980 lenOpt = (int)strlen(zOpt);
17981 if( lenOpt>=3 && strncmp(zOpt, "-allexcept",lenOpt)==0 ){
17982 assert( azArg[nArg]==0 );
17983 sqlite3_drop_modules(p->db, nArg>2 ? (const char**)(azArg+2) : 0);
17985 for(ii=1; ii<nArg; ii++){
17986 sqlite3_create_module(p->db, azArg[ii], 0, 0);
17992 #if SQLITE_USER_AUTHENTICATION
17993 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
17995 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
17997 goto meta_command_exit;
18000 if( strcmp(azArg[1],"login")==0 ){
18002 raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
18004 goto meta_command_exit;
18006 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
18007 strlen30(azArg[3]));
18009 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
18012 }else if( strcmp(azArg[1],"add")==0 ){
18014 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
18016 goto meta_command_exit;
18018 rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
18019 booleanValue(azArg[4]));
18021 raw_printf(stderr, "User-Add failed: %d\n", rc);
18024 }else if( strcmp(azArg[1],"edit")==0 ){
18026 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
18028 goto meta_command_exit;
18030 rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
18031 booleanValue(azArg[4]));
18033 raw_printf(stderr, "User-Edit failed: %d\n", rc);
18036 }else if( strcmp(azArg[1],"delete")==0 ){
18038 raw_printf(stderr, "Usage: .user delete USER\n");
18040 goto meta_command_exit;
18042 rc = sqlite3_user_delete(p->db, azArg[2]);
18044 raw_printf(stderr, "User-Delete failed: %d\n", rc);
18048 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n");
18050 goto meta_command_exit;
18053 #endif /* SQLITE_USER_AUTHENTICATION */
18055 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
18056 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
18057 sqlite3_libversion(), sqlite3_sourceid());
18058 #if SQLITE_HAVE_ZLIB
18059 utf8_printf(p->out, "zlib version %s\n", zlibVersion());
18061 #define CTIMEOPT_VAL_(opt) #opt
18062 #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
18063 #if defined(__clang__) && defined(__clang_major__)
18064 utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "."
18065 CTIMEOPT_VAL(__clang_minor__) "."
18066 CTIMEOPT_VAL(__clang_patchlevel__) "\n");
18067 #elif defined(_MSC_VER)
18068 utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) "\n");
18069 #elif defined(__GNUC__) && defined(__VERSION__)
18070 utf8_printf(p->out, "gcc-" __VERSION__ "\n");
18074 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){
18075 const char *zDbName = nArg==2 ? azArg[1] : "main";
18076 sqlite3_vfs *pVfs = 0;
18078 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
18080 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName);
18081 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
18082 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
18083 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
18088 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){
18090 sqlite3_vfs *pCurrent = 0;
18092 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
18094 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
18095 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName,
18096 pVfs==pCurrent ? " <--- CURRENT" : "");
18097 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
18098 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
18099 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
18101 raw_printf(p->out, "-----------------------------------\n");
18106 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
18107 const char *zDbName = nArg==2 ? azArg[1] : "main";
18108 char *zVfsName = 0;
18110 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
18112 utf8_printf(p->out, "%s\n", zVfsName);
18113 sqlite3_free(zVfsName);
18118 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
18119 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
18120 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
18124 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
18126 assert( nArg<=ArraySize(azArg) );
18127 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
18128 p->colWidth[j-1] = (int)integerValue(azArg[j]);
18133 utf8_printf(stderr, "Error: unknown command or invalid arguments: "
18134 " \"%s\". Enter \".help\" for help\n", azArg[0]);
18141 if( p->outCount==0 ) output_reset(p);
18147 ** Return TRUE if a semicolon occurs anywhere in the first N characters
18150 static int line_contains_semicolon(const char *z, int N){
18152 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
18157 ** Test to see if a line consists entirely of whitespace.
18159 static int _all_whitespace(const char *z){
18161 if( IsSpace(z[0]) ) continue;
18162 if( *z=='/' && z[1]=='*' ){
18164 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
18165 if( *z==0 ) return 0;
18169 if( *z=='-' && z[1]=='-' ){
18171 while( *z && *z!='\n' ){ z++; }
18172 if( *z==0 ) return 1;
18181 ** Return TRUE if the line typed in is an SQL command terminator other
18182 ** than a semi-colon. The SQL Server style "go" command is understood
18183 ** as is the Oracle "/".
18185 static int line_is_command_terminator(const char *zLine){
18186 while( IsSpace(zLine[0]) ){ zLine++; };
18187 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
18188 return 1; /* Oracle */
18190 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
18191 && _all_whitespace(&zLine[2]) ){
18192 return 1; /* SQL Server */
18198 ** We need a default sqlite3_complete() implementation to use in case
18199 ** the shell is compiled with SQLITE_OMIT_COMPLETE. The default assumes
18200 ** any arbitrary text is a complete SQL statement. This is not very
18201 ** user-friendly, but it does seem to work.
18203 #ifdef SQLITE_OMIT_COMPLETE
18204 #define sqlite3_complete(x) 1
18208 ** Return true if zSql is a complete SQL statement. Return false if it
18209 ** ends in the middle of a string literal or C-style comment.
18211 static int line_is_complete(char *zSql, int nSql){
18213 if( zSql==0 ) return 1;
18216 rc = sqlite3_complete(zSql);
18222 ** Run a single line of SQL. Return the number of errors.
18224 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
18229 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
18230 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
18232 rc = shell_exec(p, zSql, &zErrMsg);
18234 if( rc || zErrMsg ){
18236 if( in!=0 || !stdin_is_interactive ){
18237 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
18238 "Error: near line %d:", startline);
18240 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
18243 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg);
18244 sqlite3_free(zErrMsg);
18247 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
18250 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
18251 raw_printf(p->out, "changes: %3d total_changes: %d\n",
18252 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
18259 ** Read input from *in and process it. If *in==0 then input
18260 ** is interactive - the user is typing it it. Otherwise, input
18261 ** is coming from a file or device. A prompt is issued and history
18262 ** is saved only if input is interactive. An interrupt signal will
18263 ** cause this routine to exit immediately, unless input is interactive.
18265 ** Return the number of errors.
18267 static int process_input(ShellState *p){
18268 char *zLine = 0; /* A single input line */
18269 char *zSql = 0; /* Accumulated SQL text */
18270 int nLine; /* Length of current line */
18271 int nSql = 0; /* Bytes of zSql[] used */
18272 int nAlloc = 0; /* Allocated zSql[] space */
18273 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
18274 int rc; /* Error code */
18275 int errCnt = 0; /* Number of errors seen */
18276 int startline = 0; /* Line number for start of current input */
18279 while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){
18281 zLine = one_input_line(p->in, zLine, nSql>0);
18284 if( p->in==0 && stdin_is_interactive ) printf("\n");
18287 if( seenInterrupt ){
18288 if( p->in!=0 ) break;
18292 if( nSql==0 && _all_whitespace(zLine) ){
18293 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
18296 if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){
18297 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
18298 if( zLine[0]=='.' ){
18299 rc = do_meta_command(zLine, p);
18300 if( rc==2 ){ /* exit requested */
18308 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
18309 memcpy(zLine,";",2);
18311 nLine = strlen30(zLine);
18312 if( nSql+nLine+2>=nAlloc ){
18313 nAlloc = nSql+nLine+100;
18314 zSql = realloc(zSql, nAlloc);
18315 if( zSql==0 ) shell_out_of_memory();
18320 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
18321 assert( nAlloc>0 && zSql!=0 );
18322 memcpy(zSql, zLine+i, nLine+1-i);
18323 startline = p->lineno;
18326 zSql[nSql++] = '\n';
18327 memcpy(zSql+nSql, zLine, nLine+1);
18330 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
18331 && sqlite3_complete(zSql) ){
18332 errCnt += runOneSqlLine(p, zSql, p->in, startline);
18340 }else if( nSql && _all_whitespace(zSql) ){
18341 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
18345 if( nSql && !_all_whitespace(zSql) ){
18346 errCnt += runOneSqlLine(p, zSql, p->in, startline);
18354 ** Return a pathname which is the user's home directory. A
18355 ** 0 return indicates an error of some kind.
18357 static char *find_home_dir(int clearFlag){
18358 static char *home_dir = NULL;
18364 if( home_dir ) return home_dir;
18366 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
18367 && !defined(__RTP__) && !defined(_WRS_KERNEL)
18369 struct passwd *pwent;
18370 uid_t uid = getuid();
18371 if( (pwent=getpwuid(uid)) != NULL) {
18372 home_dir = pwent->pw_dir;
18377 #if defined(_WIN32_WCE)
18378 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
18383 #if defined(_WIN32) || defined(WIN32)
18385 home_dir = getenv("USERPROFILE");
18390 home_dir = getenv("HOME");
18393 #if defined(_WIN32) || defined(WIN32)
18395 char *zDrive, *zPath;
18397 zDrive = getenv("HOMEDRIVE");
18398 zPath = getenv("HOMEPATH");
18399 if( zDrive && zPath ){
18400 n = strlen30(zDrive) + strlen30(zPath) + 1;
18401 home_dir = malloc( n );
18402 if( home_dir==0 ) return 0;
18403 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
18410 #endif /* !_WIN32_WCE */
18413 int n = strlen30(home_dir) + 1;
18414 char *z = malloc( n );
18415 if( z ) memcpy(z, home_dir, n);
18423 ** Read input from the file given by sqliterc_override. Or if that
18424 ** parameter is NULL, take input from ~/.sqliterc
18426 ** Returns the number of errors.
18428 static void process_sqliterc(
18429 ShellState *p, /* Configuration data */
18430 const char *sqliterc_override /* Name of config file. NULL to use default */
18432 char *home_dir = NULL;
18433 const char *sqliterc = sqliterc_override;
18435 FILE *inSaved = p->in;
18436 int savedLineno = p->lineno;
18438 if (sqliterc == NULL) {
18439 home_dir = find_home_dir(0);
18441 raw_printf(stderr, "-- warning: cannot find home directory;"
18442 " cannot read ~/.sqliterc\n");
18445 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
18448 p->in = fopen(sqliterc,"rb");
18450 if( stdin_is_interactive ){
18451 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
18457 p->lineno = savedLineno;
18458 sqlite3_free(zBuf);
18462 ** Show available command line options
18464 static const char zOptions[] =
18465 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
18466 " -A ARGS... run \".archive ARGS\" and exit\n"
18468 " -append append the database to the end of the file\n"
18469 " -ascii set output mode to 'ascii'\n"
18470 " -bail stop after hitting an error\n"
18471 " -batch force batch I/O\n"
18472 " -column set output mode to 'column'\n"
18473 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
18474 " -csv set output mode to 'csv'\n"
18475 #if defined(SQLITE_ENABLE_DESERIALIZE)
18476 " -deserialize open the database using sqlite3_deserialize()\n"
18478 " -echo print commands before execution\n"
18479 " -init FILENAME read/process named file\n"
18480 " -[no]header turn headers on or off\n"
18481 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
18482 " -heap SIZE Size of heap for memsys3 or memsys5\n"
18484 " -help show this message\n"
18485 " -html set output mode to HTML\n"
18486 " -interactive force interactive I/O\n"
18487 " -line set output mode to 'line'\n"
18488 " -list set output mode to 'list'\n"
18489 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
18490 #if defined(SQLITE_ENABLE_DESERIALIZE)
18491 " -maxsize N maximum size for a --deserialize database\n"
18493 " -memtrace trace all memory allocations and deallocations\n"
18494 " -mmap N default mmap size set to N\n"
18495 #ifdef SQLITE_ENABLE_MULTIPLEX
18496 " -multiplex enable the multiplexor VFS\n"
18498 " -newline SEP set output row separator. Default: '\\n'\n"
18499 " -nullvalue TEXT set text string for NULL values. Default ''\n"
18500 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
18501 " -quote set output mode to 'quote'\n"
18502 " -readonly open the database read-only\n"
18503 " -separator SEP set output column separator. Default: '|'\n"
18504 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18505 " -sorterref SIZE sorter references threshold size\n"
18507 " -stats print memory stats before each finalize\n"
18508 " -version show SQLite version\n"
18509 " -vfs NAME use NAME as the default VFS\n"
18510 #ifdef SQLITE_ENABLE_VFSTRACE
18511 " -vfstrace enable tracing of all VFS calls\n"
18513 #ifdef SQLITE_HAVE_ZLIB
18514 " -zip open the file as a ZIP Archive\n"
18517 static void usage(int showDetail){
18518 utf8_printf(stderr,
18519 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
18520 "FILENAME is the name of an SQLite database. A new database is created\n"
18521 "if the file does not previously exist.\n", Argv0);
18523 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
18525 raw_printf(stderr, "Use the -help option for additional information\n");
18531 ** Internal check: Verify that the SQLite is uninitialized. Print a
18532 ** error message if it is initialized.
18534 static void verify_uninitialized(void){
18535 if( sqlite3_config(-1)==SQLITE_MISUSE ){
18536 utf8_printf(stdout, "WARNING: attempt to configure SQLite after"
18537 " initialization.\n");
18542 ** Initialize the state information in data
18544 static void main_init(ShellState *data) {
18545 memset(data, 0, sizeof(*data));
18546 data->normalMode = data->cMode = data->mode = MODE_List;
18547 data->autoExplain = 1;
18548 memcpy(data->colSeparator,SEP_Column, 2);
18549 memcpy(data->rowSeparator,SEP_Row, 2);
18550 data->showHeader = 0;
18551 data->shellFlgs = SHFLG_Lookaside;
18552 verify_uninitialized();
18553 sqlite3_config(SQLITE_CONFIG_URI, 1);
18554 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
18555 sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
18556 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
18557 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
18561 ** Output text to the console in a font that attracts extra attention.
18564 static void printBold(const char *zText){
18565 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
18566 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
18567 GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
18568 SetConsoleTextAttribute(out,
18569 FOREGROUND_RED|FOREGROUND_INTENSITY
18571 printf("%s", zText);
18572 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
18575 static void printBold(const char *zText){
18576 printf("\033[1m%s\033[0m", zText);
18581 ** Get the argument to an --option. Throw an error and die if no argument
18584 static char *cmdline_option_value(int argc, char **argv, int i){
18586 utf8_printf(stderr, "%s: Error: missing argument to %s\n",
18587 argv[0], argv[argc-1]);
18593 #ifndef SQLITE_SHELL_IS_UTF8
18594 # if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
18595 # define SQLITE_SHELL_IS_UTF8 (0)
18597 # define SQLITE_SHELL_IS_UTF8 (1)
18601 #if SQLITE_SHELL_IS_UTF8
18602 int SQLITE_CDECL main(int argc, char **argv){
18604 int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
18609 const char *zInitFile = 0;
18612 int warnInmemoryDb = 0;
18616 const char *zVfs = 0; /* Value of -vfs command-line option */
18617 #if !SQLITE_SHELL_IS_UTF8
18618 char **argvToFree = 0;
18619 int argcToFree = 0;
18622 setBinaryMode(stdin, 0);
18623 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
18624 stdin_is_interactive = isatty(0);
18625 stdout_is_console = isatty(1);
18627 #if !defined(_WIN32_WCE)
18628 if( getenv("SQLITE_DEBUG_BREAK") ){
18629 if( isatty(0) && isatty(2) ){
18631 "attach debugger to process %d and press any key to continue.\n",
18635 #if defined(_WIN32) || defined(WIN32)
18637 #elif defined(SIGTRAP)
18644 #if USE_SYSTEM_SQLITE+0!=1
18645 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
18646 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
18647 sqlite3_sourceid(), SQLITE_SOURCE_ID);
18653 /* On Windows, we must translate command-line arguments into UTF-8.
18654 ** The SQLite memory allocator subsystem has to be enabled in order to
18655 ** do this. But we want to run an sqlite3_shutdown() afterwards so that
18656 ** subsequent sqlite3_config() calls will work. So copy all results into
18657 ** memory that does not come from the SQLite memory allocator.
18659 #if !SQLITE_SHELL_IS_UTF8
18660 sqlite3_initialize();
18661 argvToFree = malloc(sizeof(argv[0])*argc*2);
18663 argv = argvToFree + argc;
18664 if( argv==0 ) shell_out_of_memory();
18665 for(i=0; i<argc; i++){
18666 char *z = sqlite3_win32_unicode_to_utf8(wargv[i]);
18668 if( z==0 ) shell_out_of_memory();
18669 n = (int)strlen(z);
18670 argv[i] = malloc( n+1 );
18671 if( argv[i]==0 ) shell_out_of_memory();
18672 memcpy(argv[i], z, n+1);
18673 argvToFree[i] = argv[i];
18676 sqlite3_shutdown();
18679 assert( argc>=1 && argv && argv[0] );
18682 /* Make sure we have a valid signal handler early, before anything
18686 signal(SIGINT, interrupt_handler);
18687 #elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE)
18688 SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
18691 #ifdef SQLITE_SHELL_DBNAME_PROC
18693 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
18694 ** of a C-function that will provide the name of the database file. Use
18695 ** this compile-time option to embed this shell program in larger
18696 ** applications. */
18697 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
18698 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
18699 warnInmemoryDb = 0;
18703 /* Do an initial pass through the command-line argument to locate
18704 ** the name of the database file, the name of the initialization file,
18705 ** the size of the alternative malloc heap,
18706 ** and the first command to execute.
18708 verify_uninitialized();
18709 for(i=1; i<argc; i++){
18713 if( data.zDbFilename==0 ){
18714 data.zDbFilename = z;
18716 /* Excesss arguments are interpreted as SQL (or dot-commands) and
18717 ** mean that nothing is read from stdin */
18720 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
18721 if( azCmd==0 ) shell_out_of_memory();
18725 if( z[1]=='-' ) z++;
18726 if( strcmp(z,"-separator")==0
18727 || strcmp(z,"-nullvalue")==0
18728 || strcmp(z,"-newline")==0
18729 || strcmp(z,"-cmd")==0
18731 (void)cmdline_option_value(argc, argv, ++i);
18732 }else if( strcmp(z,"-init")==0 ){
18733 zInitFile = cmdline_option_value(argc, argv, ++i);
18734 }else if( strcmp(z,"-batch")==0 ){
18735 /* Need to check for batch mode here to so we can avoid printing
18736 ** informational messages (like from process_sqliterc) before
18737 ** we do the actual processing of arguments later in a second pass.
18739 stdin_is_interactive = 0;
18740 }else if( strcmp(z,"-heap")==0 ){
18741 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
18743 sqlite3_int64 szHeap;
18745 zSize = cmdline_option_value(argc, argv, ++i);
18746 szHeap = integerValue(zSize);
18747 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
18748 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
18750 (void)cmdline_option_value(argc, argv, ++i);
18752 }else if( strcmp(z,"-pagecache")==0 ){
18754 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
18755 if( sz>70000 ) sz = 70000;
18757 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
18758 sqlite3_config(SQLITE_CONFIG_PAGECACHE,
18759 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
18760 data.shellFlgs |= SHFLG_Pagecache;
18761 }else if( strcmp(z,"-lookaside")==0 ){
18763 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
18765 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
18767 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
18768 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
18769 #ifdef SQLITE_ENABLE_VFSTRACE
18770 }else if( strcmp(z,"-vfstrace")==0 ){
18771 extern int vfstrace_register(
18772 const char *zTraceName,
18773 const char *zOldVfsName,
18774 int (*xOut)(const char*,void*),
18778 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
18780 #ifdef SQLITE_ENABLE_MULTIPLEX
18781 }else if( strcmp(z,"-multiplex")==0 ){
18782 extern int sqlite3_multiple_initialize(const char*,int);
18783 sqlite3_multiplex_initialize(0, 1);
18785 }else if( strcmp(z,"-mmap")==0 ){
18786 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
18787 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
18788 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18789 }else if( strcmp(z,"-sorterref")==0 ){
18790 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
18791 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz);
18793 }else if( strcmp(z,"-vfs")==0 ){
18794 zVfs = cmdline_option_value(argc, argv, ++i);
18795 #ifdef SQLITE_HAVE_ZLIB
18796 }else if( strcmp(z,"-zip")==0 ){
18797 data.openMode = SHELL_OPEN_ZIPFILE;
18799 }else if( strcmp(z,"-append")==0 ){
18800 data.openMode = SHELL_OPEN_APPENDVFS;
18801 #ifdef SQLITE_ENABLE_DESERIALIZE
18802 }else if( strcmp(z,"-deserialize")==0 ){
18803 data.openMode = SHELL_OPEN_DESERIALIZE;
18804 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){
18805 data.szMax = integerValue(argv[++i]);
18807 }else if( strcmp(z,"-readonly")==0 ){
18808 data.openMode = SHELL_OPEN_READONLY;
18809 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
18810 }else if( strncmp(z, "-A",2)==0 ){
18811 /* All remaining command-line arguments are passed to the ".archive"
18812 ** command, so ignore them */
18815 }else if( strcmp(z, "-memtrace")==0 ){
18816 sqlite3MemTraceActivate(stderr);
18819 verify_uninitialized();
18822 #ifdef SQLITE_SHELL_INIT_PROC
18824 /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name
18825 ** of a C-function that will perform initialization actions on SQLite that
18826 ** occur just before or after sqlite3_initialize(). Use this compile-time
18827 ** option to embed this shell program in larger applications. */
18828 extern void SQLITE_SHELL_INIT_PROC(void);
18829 SQLITE_SHELL_INIT_PROC();
18832 /* All the sqlite3_config() calls have now been made. So it is safe
18833 ** to call sqlite3_initialize() and process any command line -vfs option. */
18834 sqlite3_initialize();
18838 sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
18840 sqlite3_vfs_register(pVfs, 1);
18842 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]);
18847 if( data.zDbFilename==0 ){
18848 #ifndef SQLITE_OMIT_MEMORYDB
18849 data.zDbFilename = ":memory:";
18850 warnInmemoryDb = argc==1;
18852 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
18857 sqlite3_appendvfs_init(0,0,0);
18859 /* Go ahead and open the database file if it already exists. If the
18860 ** file does not exist, delay opening it. This prevents empty database
18861 ** files from being created if a user mistypes the database name argument
18862 ** to the sqlite command-line tool.
18864 if( access(data.zDbFilename, 0)==0 ){
18868 /* Process the initialization file if there is one. If no -init option
18869 ** is given on the command line, look for a file named ~/.sqliterc and
18870 ** try to process it.
18872 process_sqliterc(&data,zInitFile);
18874 /* Make a second pass through the command-line argument and set
18875 ** options. This second pass is delayed until after the initialization
18876 ** file is processed so that the command-line arguments will override
18877 ** settings in the initialization file.
18879 for(i=1; i<argc; i++){
18881 if( z[0]!='-' ) continue;
18882 if( z[1]=='-' ){ z++; }
18883 if( strcmp(z,"-init")==0 ){
18885 }else if( strcmp(z,"-html")==0 ){
18886 data.mode = MODE_Html;
18887 }else if( strcmp(z,"-list")==0 ){
18888 data.mode = MODE_List;
18889 }else if( strcmp(z,"-quote")==0 ){
18890 data.mode = MODE_Quote;
18891 }else if( strcmp(z,"-line")==0 ){
18892 data.mode = MODE_Line;
18893 }else if( strcmp(z,"-column")==0 ){
18894 data.mode = MODE_Column;
18895 }else if( strcmp(z,"-csv")==0 ){
18896 data.mode = MODE_Csv;
18897 memcpy(data.colSeparator,",",2);
18898 #ifdef SQLITE_HAVE_ZLIB
18899 }else if( strcmp(z,"-zip")==0 ){
18900 data.openMode = SHELL_OPEN_ZIPFILE;
18902 }else if( strcmp(z,"-append")==0 ){
18903 data.openMode = SHELL_OPEN_APPENDVFS;
18904 #ifdef SQLITE_ENABLE_DESERIALIZE
18905 }else if( strcmp(z,"-deserialize")==0 ){
18906 data.openMode = SHELL_OPEN_DESERIALIZE;
18907 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){
18908 data.szMax = integerValue(argv[++i]);
18910 }else if( strcmp(z,"-readonly")==0 ){
18911 data.openMode = SHELL_OPEN_READONLY;
18912 }else if( strcmp(z,"-ascii")==0 ){
18913 data.mode = MODE_Ascii;
18914 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
18916 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
18918 }else if( strcmp(z,"-separator")==0 ){
18919 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
18920 "%s",cmdline_option_value(argc,argv,++i));
18921 }else if( strcmp(z,"-newline")==0 ){
18922 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
18923 "%s",cmdline_option_value(argc,argv,++i));
18924 }else if( strcmp(z,"-nullvalue")==0 ){
18925 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
18926 "%s",cmdline_option_value(argc,argv,++i));
18927 }else if( strcmp(z,"-header")==0 ){
18928 data.showHeader = 1;
18929 }else if( strcmp(z,"-noheader")==0 ){
18930 data.showHeader = 0;
18931 }else if( strcmp(z,"-echo")==0 ){
18932 ShellSetFlag(&data, SHFLG_Echo);
18933 }else if( strcmp(z,"-eqp")==0 ){
18934 data.autoEQP = AUTOEQP_on;
18935 }else if( strcmp(z,"-eqpfull")==0 ){
18936 data.autoEQP = AUTOEQP_full;
18937 }else if( strcmp(z,"-stats")==0 ){
18939 }else if( strcmp(z,"-scanstats")==0 ){
18940 data.scanstatsOn = 1;
18941 }else if( strcmp(z,"-backslash")==0 ){
18942 /* Undocumented command-line option: -backslash
18943 ** Causes C-style backslash escapes to be evaluated in SQL statements
18944 ** prior to sending the SQL into SQLite. Useful for injecting
18945 ** crazy bytes in the middle of SQL statements for testing and debugging.
18947 ShellSetFlag(&data, SHFLG_Backslash);
18948 }else if( strcmp(z,"-bail")==0 ){
18950 }else if( strcmp(z,"-version")==0 ){
18951 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
18953 }else if( strcmp(z,"-interactive")==0 ){
18954 stdin_is_interactive = 1;
18955 }else if( strcmp(z,"-batch")==0 ){
18956 stdin_is_interactive = 0;
18957 }else if( strcmp(z,"-heap")==0 ){
18959 }else if( strcmp(z,"-pagecache")==0 ){
18961 }else if( strcmp(z,"-lookaside")==0 ){
18963 }else if( strcmp(z,"-mmap")==0 ){
18965 }else if( strcmp(z,"-memtrace")==0 ){
18967 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18968 }else if( strcmp(z,"-sorterref")==0 ){
18971 }else if( strcmp(z,"-vfs")==0 ){
18973 #ifdef SQLITE_ENABLE_VFSTRACE
18974 }else if( strcmp(z,"-vfstrace")==0 ){
18977 #ifdef SQLITE_ENABLE_MULTIPLEX
18978 }else if( strcmp(z,"-multiplex")==0 ){
18981 }else if( strcmp(z,"-help")==0 ){
18983 }else if( strcmp(z,"-cmd")==0 ){
18984 /* Run commands that follow -cmd first and separately from commands
18985 ** that simply appear on the command-line. This seems goofy. It would
18986 ** be better if all commands ran in the order that they appear. But
18987 ** we retain the goofy behavior for historical compatibility. */
18988 if( i==argc-1 ) break;
18989 z = cmdline_option_value(argc,argv,++i);
18991 rc = do_meta_command(z, &data);
18992 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
18995 rc = shell_exec(&data, z, &zErrMsg);
18997 utf8_printf(stderr,"Error: %s\n", zErrMsg);
18998 if( bail_on_error ) return rc!=0 ? rc : 1;
19000 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
19001 if( bail_on_error ) return rc;
19004 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
19005 }else if( strncmp(z, "-A", 2)==0 ){
19007 utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands"
19008 " with \"%s\"\n", z);
19011 open_db(&data, OPEN_DB_ZIPFILE);
19014 arDotCommand(&data, 1, argv+(i-1), argc-(i-1));
19016 arDotCommand(&data, 1, argv+i, argc-i);
19022 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
19023 raw_printf(stderr,"Use -help for a list of options.\n");
19026 data.cMode = data.mode;
19030 /* Run all arguments that do not begin with '-' as if they were separate
19031 ** command-line inputs, except for the argToSkip argument which contains
19032 ** the database filename.
19034 for(i=0; i<nCmd; i++){
19035 if( azCmd[i][0]=='.' ){
19036 rc = do_meta_command(azCmd[i], &data);
19037 if( rc ) return rc==2 ? 0 : rc;
19040 rc = shell_exec(&data, azCmd[i], &zErrMsg);
19042 utf8_printf(stderr,"Error: %s\n", zErrMsg);
19043 return rc!=0 ? rc : 1;
19045 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
19052 /* Run commands received from standard input
19054 if( stdin_is_interactive ){
19059 "SQLite version %s %.19s\n" /*extra-version-info*/
19060 "Enter \".help\" for usage hints.\n",
19061 sqlite3_libversion(), sqlite3_sourceid()
19063 if( warnInmemoryDb ){
19064 printf("Connected to a ");
19065 printBold("transient in-memory database");
19066 printf(".\nUse \".open FILENAME\" to reopen on a "
19067 "persistent database.\n");
19069 zHistory = getenv("SQLITE_HISTORY");
19071 zHistory = strdup(zHistory);
19072 }else if( (zHome = find_home_dir(0))!=0 ){
19073 nHistory = strlen30(zHome) + 20;
19074 if( (zHistory = malloc(nHistory))!=0 ){
19075 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
19078 if( zHistory ){ shell_read_history(zHistory); }
19079 #if HAVE_READLINE || HAVE_EDITLINE
19080 rl_attempted_completion_function = readline_completion;
19081 #elif HAVE_LINENOISE
19082 linenoiseSetCompletionCallback(linenoise_completion);
19085 rc = process_input(&data);
19087 shell_stifle_history(2000);
19088 shell_write_history(zHistory);
19093 rc = process_input(&data);
19096 set_table_name(&data, 0);
19098 session_close_all(&data);
19101 sqlite3_free(data.zFreeOnClose);
19103 output_reset(&data);
19104 data.doXdgOpen = 0;
19105 clearTempFile(&data);
19106 #if !SQLITE_SHELL_IS_UTF8
19107 for(i=0; i<argcToFree; i++) free(argvToFree[i]);
19110 /* Clear the global data structure so that valgrind will detect memory
19112 memset(&data, 0, sizeof(data));