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,
2011 SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
2013 if( rc==SQLITE_OK ){
2014 rc = sqlite3_create_function(db, "sha3", 2,
2015 SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
2018 if( rc==SQLITE_OK ){
2019 rc = sqlite3_create_function(db, "sha3_query", 1,
2020 SQLITE_UTF8 | SQLITE_DIRECTONLY,
2021 0, sha3QueryFunc, 0, 0);
2023 if( rc==SQLITE_OK ){
2024 rc = sqlite3_create_function(db, "sha3_query", 2,
2025 SQLITE_UTF8 | SQLITE_DIRECTONLY,
2026 0, sha3QueryFunc, 0, 0);
2031 /************************* End ../ext/misc/shathree.c ********************/
2032 /************************* Begin ../ext/misc/fileio.c ******************/
2036 ** The author disclaims copyright to this source code. In place of
2037 ** a legal notice, here is a blessing:
2039 ** May you do good and not evil.
2040 ** May you find forgiveness for yourself and forgive others.
2041 ** May you share freely, never taking more than you give.
2043 ******************************************************************************
2045 ** This SQLite extension implements SQL functions readfile() and
2046 ** writefile(), and eponymous virtual type "fsdir".
2048 ** WRITEFILE(FILE, DATA [, MODE [, MTIME]]):
2050 ** If neither of the optional arguments is present, then this UDF
2051 ** function writes blob DATA to file FILE. If successful, the number
2052 ** of bytes written is returned. If an error occurs, NULL is returned.
2054 ** If the first option argument - MODE - is present, then it must
2055 ** be passed an integer value that corresponds to a POSIX mode
2056 ** value (file type + permissions, as returned in the stat.st_mode
2057 ** field by the stat() system call). Three types of files may
2058 ** be written/created:
2060 ** regular files: (mode & 0170000)==0100000
2061 ** symbolic links: (mode & 0170000)==0120000
2062 ** directories: (mode & 0170000)==0040000
2064 ** For a directory, the DATA is ignored. For a symbolic link, it is
2065 ** interpreted as text and used as the target of the link. For a
2066 ** regular file, it is interpreted as a blob and written into the
2067 ** named file. Regardless of the type of file, its permissions are
2068 ** set to (mode & 0777) before returning.
2070 ** If the optional MTIME argument is present, then it is interpreted
2071 ** as an integer - the number of seconds since the unix epoch. The
2072 ** modification-time of the target file is set to this value before
2075 ** If three or more arguments are passed to this function and an
2076 ** error is encountered, an exception is raised.
2080 ** Read and return the contents of file FILE (type blob) from disk.
2086 ** SELECT * FROM fsdir($path [, $dir]);
2088 ** Parameter $path is an absolute or relative pathname. If the file that it
2089 ** refers to does not exist, it is an error. If the path refers to a regular
2090 ** file or symbolic link, it returns a single row. Or, if the path refers
2091 ** to a directory, it returns one row for the directory, and one row for each
2092 ** file within the hierarchy rooted at $path.
2094 ** Each row has the following columns:
2096 ** name: Path to file or directory (text value).
2097 ** mode: Value of stat.st_mode for directory entry (an integer).
2098 ** mtime: Value of stat.st_mtime for directory entry (an integer).
2099 ** data: For a regular file, a blob containing the file data. For a
2100 ** symlink, a text value containing the text of the link. For a
2103 ** If a non-NULL value is specified for the optional $dir parameter and
2104 ** $path is a relative path, then $path is interpreted relative to $dir.
2105 ** And the paths returned in the "name" column of the table are also
2106 ** relative to directory $dir.
2108 /* #include "sqlite3ext.h" */
2109 SQLITE_EXTENSION_INIT1
2114 #include <sys/types.h>
2115 #include <sys/stat.h>
2117 #if !defined(_WIN32) && !defined(WIN32)
2118 # include <unistd.h>
2119 # include <dirent.h>
2121 # include <sys/time.h>
2123 # include "windows.h"
2125 # include <direct.h>
2126 /* # include "test_windirent.h" */
2127 # define dirent DIRENT
2129 # define chmod _chmod
2134 # define mkdir(path,mode) _mkdir(path)
2135 # define lstat(path,buf) stat(path,buf)
2142 ** Structure of the fsdir() table-valued function
2145 #define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"
2146 #define FSDIR_COLUMN_NAME 0 /* Name of the file */
2147 #define FSDIR_COLUMN_MODE 1 /* Access mode */
2148 #define FSDIR_COLUMN_MTIME 2 /* Last modification time */
2149 #define FSDIR_COLUMN_DATA 3 /* File content */
2150 #define FSDIR_COLUMN_PATH 4 /* Path to top of search */
2151 #define FSDIR_COLUMN_DIR 5 /* Path is relative to this directory */
2155 ** Set the result stored by context ctx to a blob containing the
2156 ** contents of file zName. Or, leave the result unchanged (NULL)
2157 ** if the file does not exist or is unreadable.
2159 ** If the file exceeds the SQLite blob size limit, through an
2160 ** SQLITE_TOOBIG error.
2162 ** Throw an SQLITE_IOERR if there are difficulties pulling the file
2165 static void readFileContents(sqlite3_context *ctx, const char *zName){
2172 in = fopen(zName, "rb");
2174 /* File does not exist or is unreadable. Leave the result set to NULL. */
2177 fseek(in, 0, SEEK_END);
2180 db = sqlite3_context_db_handle(ctx);
2181 mxBlob = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1);
2183 sqlite3_result_error_code(ctx, SQLITE_TOOBIG);
2187 pBuf = sqlite3_malloc64( nIn ? nIn : 1 );
2189 sqlite3_result_error_nomem(ctx);
2193 if( nIn==(sqlite3_int64)fread(pBuf, 1, (size_t)nIn, in) ){
2194 sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free);
2196 sqlite3_result_error_code(ctx, SQLITE_IOERR);
2203 ** Implementation of the "readfile(X)" SQL function. The entire content
2204 ** of the file named X is read and returned as a BLOB. NULL is returned
2205 ** if the file does not exist or is unreadable.
2207 static void readfileFunc(
2208 sqlite3_context *context,
2210 sqlite3_value **argv
2213 (void)(argc); /* Unused parameter */
2214 zName = (const char*)sqlite3_value_text(argv[0]);
2215 if( zName==0 ) return;
2216 readFileContents(context, zName);
2220 ** Set the error message contained in context ctx to the results of
2221 ** vprintf(zFmt, ...).
2223 static void ctxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){
2227 zMsg = sqlite3_vmprintf(zFmt, ap);
2228 sqlite3_result_error(ctx, zMsg, -1);
2235 ** This function is designed to convert a Win32 FILETIME structure into the
2236 ** number of seconds since the Unix Epoch (1970-01-01 00:00:00 UTC).
2238 static sqlite3_uint64 fileTimeToUnixTime(
2239 LPFILETIME pFileTime
2241 SYSTEMTIME epochSystemTime;
2242 ULARGE_INTEGER epochIntervals;
2243 FILETIME epochFileTime;
2244 ULARGE_INTEGER fileIntervals;
2246 memset(&epochSystemTime, 0, sizeof(SYSTEMTIME));
2247 epochSystemTime.wYear = 1970;
2248 epochSystemTime.wMonth = 1;
2249 epochSystemTime.wDay = 1;
2250 SystemTimeToFileTime(&epochSystemTime, &epochFileTime);
2251 epochIntervals.LowPart = epochFileTime.dwLowDateTime;
2252 epochIntervals.HighPart = epochFileTime.dwHighDateTime;
2254 fileIntervals.LowPart = pFileTime->dwLowDateTime;
2255 fileIntervals.HighPart = pFileTime->dwHighDateTime;
2257 return (fileIntervals.QuadPart - epochIntervals.QuadPart) / 10000000;
2261 ** This function attempts to normalize the time values found in the stat()
2262 ** buffer to UTC. This is necessary on Win32, where the runtime library
2263 ** appears to return these values as local times.
2265 static void statTimesToUtc(
2267 struct stat *pStatBuf
2270 WIN32_FIND_DATAW fd;
2271 LPWSTR zUnicodeName;
2272 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
2273 zUnicodeName = sqlite3_win32_utf8_to_unicode(zPath);
2275 memset(&fd, 0, sizeof(WIN32_FIND_DATAW));
2276 hFindFile = FindFirstFileW(zUnicodeName, &fd);
2277 if( hFindFile!=NULL ){
2278 pStatBuf->st_ctime = (time_t)fileTimeToUnixTime(&fd.ftCreationTime);
2279 pStatBuf->st_atime = (time_t)fileTimeToUnixTime(&fd.ftLastAccessTime);
2280 pStatBuf->st_mtime = (time_t)fileTimeToUnixTime(&fd.ftLastWriteTime);
2281 FindClose(hFindFile);
2283 sqlite3_free(zUnicodeName);
2289 ** This function is used in place of stat(). On Windows, special handling
2290 ** is required in order for the included time to be returned as UTC. On all
2291 ** other systems, this function simply calls stat().
2293 static int fileStat(
2295 struct stat *pStatBuf
2298 int rc = stat(zPath, pStatBuf);
2299 if( rc==0 ) statTimesToUtc(zPath, pStatBuf);
2302 return stat(zPath, pStatBuf);
2307 ** This function is used in place of lstat(). On Windows, special handling
2308 ** is required in order for the included time to be returned as UTC. On all
2309 ** other systems, this function simply calls lstat().
2311 static int fileLinkStat(
2313 struct stat *pStatBuf
2316 int rc = lstat(zPath, pStatBuf);
2317 if( rc==0 ) statTimesToUtc(zPath, pStatBuf);
2320 return lstat(zPath, pStatBuf);
2325 ** Argument zFile is the name of a file that will be created and/or written
2326 ** by SQL function writefile(). This function ensures that the directory
2327 ** zFile will be written to exists, creating it if required. The permissions
2328 ** for any path components created by this function are set in accordance
2329 ** with the current umask.
2331 ** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise,
2332 ** SQLITE_OK is returned if the directory is successfully created, or
2333 ** SQLITE_ERROR otherwise.
2335 static int makeDirectory(
2338 char *zCopy = sqlite3_mprintf("%s", zFile);
2344 int nCopy = (int)strlen(zCopy);
2347 while( rc==SQLITE_OK ){
2351 for(; zCopy[i]!='/' && i<nCopy; i++);
2352 if( i==nCopy ) break;
2355 rc2 = fileStat(zCopy, &sStat);
2357 if( mkdir(zCopy, 0777) ) rc = SQLITE_ERROR;
2359 if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR;
2365 sqlite3_free(zCopy);
2372 ** This function does the work for the writefile() UDF. Refer to
2373 ** header comments at the top of this file for details.
2375 static int writeFile(
2376 sqlite3_context *pCtx, /* Context to return bytes written in */
2377 const char *zFile, /* File to write */
2378 sqlite3_value *pData, /* Data to write */
2379 mode_t mode, /* MODE parameter passed to writefile() */
2380 sqlite3_int64 mtime /* MTIME parameter (or -1 to not set time) */
2382 #if !defined(_WIN32) && !defined(WIN32)
2383 if( S_ISLNK(mode) ){
2384 const char *zTo = (const char*)sqlite3_value_text(pData);
2385 if( symlink(zTo, zFile)<0 ) return 1;
2389 if( S_ISDIR(mode) ){
2390 if( mkdir(zFile, mode) ){
2391 /* The mkdir() call to create the directory failed. This might not
2392 ** be an error though - if there is already a directory at the same
2393 ** path and either the permissions already match or can be changed
2394 ** to do so using chmod(), it is not an error. */
2397 || 0!=fileStat(zFile, &sStat)
2398 || !S_ISDIR(sStat.st_mode)
2399 || ((sStat.st_mode&0777)!=(mode&0777) && 0!=chmod(zFile, mode&0777))
2405 sqlite3_int64 nWrite = 0;
2408 FILE *out = fopen(zFile, "wb");
2409 if( out==0 ) return 1;
2410 z = (const char*)sqlite3_value_blob(pData);
2412 sqlite3_int64 n = fwrite(z, 1, sqlite3_value_bytes(pData), out);
2413 nWrite = sqlite3_value_bytes(pData);
2419 if( rc==0 && mode && chmod(zFile, mode & 0777) ){
2423 sqlite3_result_int64(pCtx, nWrite);
2430 FILETIME lastAccess;
2432 SYSTEMTIME currentTime;
2435 LPWSTR zUnicodeName;
2436 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
2438 GetSystemTime(¤tTime);
2439 SystemTimeToFileTime(¤tTime, &lastAccess);
2440 intervals = Int32x32To64(mtime, 10000000) + 116444736000000000;
2441 lastWrite.dwLowDateTime = (DWORD)intervals;
2442 lastWrite.dwHighDateTime = intervals >> 32;
2443 zUnicodeName = sqlite3_win32_utf8_to_unicode(zFile);
2444 if( zUnicodeName==0 ){
2447 hFile = CreateFileW(
2448 zUnicodeName, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING,
2449 FILE_FLAG_BACKUP_SEMANTICS, NULL
2451 sqlite3_free(zUnicodeName);
2452 if( hFile!=INVALID_HANDLE_VALUE ){
2453 BOOL bResult = SetFileTime(hFile, NULL, &lastAccess, &lastWrite);
2459 #elif defined(AT_FDCWD) && 0 /* utimensat() is not universally available */
2461 struct timespec times[2];
2462 times[0].tv_nsec = times[1].tv_nsec = 0;
2463 times[0].tv_sec = time(0);
2464 times[1].tv_sec = mtime;
2465 if( utimensat(AT_FDCWD, zFile, times, AT_SYMLINK_NOFOLLOW) ){
2470 struct timeval times[2];
2471 times[0].tv_usec = times[1].tv_usec = 0;
2472 times[0].tv_sec = time(0);
2473 times[1].tv_sec = mtime;
2474 if( utimes(zFile, times) ){
2484 ** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function.
2485 ** Refer to header comments at the top of this file for details.
2487 static void writefileFunc(
2488 sqlite3_context *context,
2490 sqlite3_value **argv
2495 sqlite3_int64 mtime = -1;
2497 if( argc<2 || argc>4 ){
2498 sqlite3_result_error(context,
2499 "wrong number of arguments to function writefile()", -1
2504 zFile = (const char*)sqlite3_value_text(argv[0]);
2505 if( zFile==0 ) return;
2507 mode = (mode_t)sqlite3_value_int(argv[2]);
2510 mtime = sqlite3_value_int64(argv[3]);
2513 res = writeFile(context, zFile, argv[1], mode, mtime);
2514 if( res==1 && errno==ENOENT ){
2515 if( makeDirectory(zFile)==SQLITE_OK ){
2516 res = writeFile(context, zFile, argv[1], mode, mtime);
2520 if( argc>2 && res!=0 ){
2521 if( S_ISLNK(mode) ){
2522 ctxErrorMsg(context, "failed to create symlink: %s", zFile);
2523 }else if( S_ISDIR(mode) ){
2524 ctxErrorMsg(context, "failed to create directory: %s", zFile);
2526 ctxErrorMsg(context, "failed to write file: %s", zFile);
2532 ** SQL function: lsmode(MODE)
2534 ** Given a numberic st_mode from stat(), convert it into a human-readable
2535 ** text string in the style of "ls -l".
2537 static void lsModeFunc(
2538 sqlite3_context *context,
2540 sqlite3_value **argv
2543 int iMode = sqlite3_value_int(argv[0]);
2546 if( S_ISLNK(iMode) ){
2548 }else if( S_ISREG(iMode) ){
2550 }else if( S_ISDIR(iMode) ){
2556 int m = (iMode >> ((2-i)*3));
2557 char *a = &z[1 + i*3];
2558 a[0] = (m & 0x4) ? 'r' : '-';
2559 a[1] = (m & 0x2) ? 'w' : '-';
2560 a[2] = (m & 0x1) ? 'x' : '-';
2563 sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT);
2566 #ifndef SQLITE_OMIT_VIRTUALTABLE
2569 ** Cursor type for recursively iterating through a directory structure.
2571 typedef struct fsdir_cursor fsdir_cursor;
2572 typedef struct FsdirLevel FsdirLevel;
2575 DIR *pDir; /* From opendir() */
2576 char *zDir; /* Name of directory (nul-terminated) */
2579 struct fsdir_cursor {
2580 sqlite3_vtab_cursor base; /* Base class - must be first */
2582 int nLvl; /* Number of entries in aLvl[] array */
2583 int iLvl; /* Index of current entry */
2584 FsdirLevel *aLvl; /* Hierarchy of directories being traversed */
2589 struct stat sStat; /* Current lstat() results */
2590 char *zPath; /* Path to current entry */
2591 sqlite3_int64 iRowid; /* Current rowid */
2594 typedef struct fsdir_tab fsdir_tab;
2596 sqlite3_vtab base; /* Base class - must be first */
2600 ** Construct a new fsdir virtual table object.
2602 static int fsdirConnect(
2605 int argc, const char *const*argv,
2606 sqlite3_vtab **ppVtab,
2609 fsdir_tab *pNew = 0;
2615 rc = sqlite3_declare_vtab(db, "CREATE TABLE x" FSDIR_SCHEMA);
2616 if( rc==SQLITE_OK ){
2617 pNew = (fsdir_tab*)sqlite3_malloc( sizeof(*pNew) );
2618 if( pNew==0 ) return SQLITE_NOMEM;
2619 memset(pNew, 0, sizeof(*pNew));
2620 sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);
2622 *ppVtab = (sqlite3_vtab*)pNew;
2627 ** This method is the destructor for fsdir vtab objects.
2629 static int fsdirDisconnect(sqlite3_vtab *pVtab){
2630 sqlite3_free(pVtab);
2635 ** Constructor for a new fsdir_cursor object.
2637 static int fsdirOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
2640 pCur = sqlite3_malloc( sizeof(*pCur) );
2641 if( pCur==0 ) return SQLITE_NOMEM;
2642 memset(pCur, 0, sizeof(*pCur));
2644 *ppCursor = &pCur->base;
2649 ** Reset a cursor back to the state it was in when first returned
2652 static void fsdirResetCursor(fsdir_cursor *pCur){
2654 for(i=0; i<=pCur->iLvl; i++){
2655 FsdirLevel *pLvl = &pCur->aLvl[i];
2656 if( pLvl->pDir ) closedir(pLvl->pDir);
2657 sqlite3_free(pLvl->zDir);
2659 sqlite3_free(pCur->zPath);
2660 sqlite3_free(pCur->aLvl);
2671 ** Destructor for an fsdir_cursor.
2673 static int fsdirClose(sqlite3_vtab_cursor *cur){
2674 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2676 fsdirResetCursor(pCur);
2682 ** Set the error message for the virtual table associated with cursor
2683 ** pCur to the results of vprintf(zFmt, ...).
2685 static void fsdirSetErrmsg(fsdir_cursor *pCur, const char *zFmt, ...){
2688 pCur->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap);
2694 ** Advance an fsdir_cursor to its next row of output.
2696 static int fsdirNext(sqlite3_vtab_cursor *cur){
2697 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2698 mode_t m = pCur->sStat.st_mode;
2702 /* Descend into this directory */
2703 int iNew = pCur->iLvl + 1;
2705 if( iNew>=pCur->nLvl ){
2707 sqlite3_int64 nByte = nNew*sizeof(FsdirLevel);
2708 FsdirLevel *aNew = (FsdirLevel*)sqlite3_realloc64(pCur->aLvl, nByte);
2709 if( aNew==0 ) return SQLITE_NOMEM;
2710 memset(&aNew[pCur->nLvl], 0, sizeof(FsdirLevel)*(nNew-pCur->nLvl));
2715 pLvl = &pCur->aLvl[iNew];
2717 pLvl->zDir = pCur->zPath;
2719 pLvl->pDir = opendir(pLvl->zDir);
2720 if( pLvl->pDir==0 ){
2721 fsdirSetErrmsg(pCur, "cannot read directory: %s", pCur->zPath);
2722 return SQLITE_ERROR;
2726 while( pCur->iLvl>=0 ){
2727 FsdirLevel *pLvl = &pCur->aLvl[pCur->iLvl];
2728 struct dirent *pEntry = readdir(pLvl->pDir);
2730 if( pEntry->d_name[0]=='.' ){
2731 if( pEntry->d_name[1]=='.' && pEntry->d_name[2]=='\0' ) continue;
2732 if( pEntry->d_name[1]=='\0' ) continue;
2734 sqlite3_free(pCur->zPath);
2735 pCur->zPath = sqlite3_mprintf("%s/%s", pLvl->zDir, pEntry->d_name);
2736 if( pCur->zPath==0 ) return SQLITE_NOMEM;
2737 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){
2738 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath);
2739 return SQLITE_ERROR;
2743 closedir(pLvl->pDir);
2744 sqlite3_free(pLvl->zDir);
2751 sqlite3_free(pCur->zPath);
2757 ** Return values of columns for the row at which the series_cursor
2758 ** is currently pointing.
2760 static int fsdirColumn(
2761 sqlite3_vtab_cursor *cur, /* The cursor */
2762 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
2763 int i /* Which column to return */
2765 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2767 case FSDIR_COLUMN_NAME: {
2768 sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT);
2772 case FSDIR_COLUMN_MODE:
2773 sqlite3_result_int64(ctx, pCur->sStat.st_mode);
2776 case FSDIR_COLUMN_MTIME:
2777 sqlite3_result_int64(ctx, pCur->sStat.st_mtime);
2780 case FSDIR_COLUMN_DATA: {
2781 mode_t m = pCur->sStat.st_mode;
2783 sqlite3_result_null(ctx);
2784 #if !defined(_WIN32) && !defined(WIN32)
2785 }else if( S_ISLNK(m) ){
2787 char *aBuf = aStatic;
2788 sqlite3_int64 nBuf = 64;
2792 n = readlink(pCur->zPath, aBuf, nBuf);
2794 if( aBuf!=aStatic ) sqlite3_free(aBuf);
2796 aBuf = sqlite3_malloc64(nBuf);
2798 sqlite3_result_error_nomem(ctx);
2799 return SQLITE_NOMEM;
2803 sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT);
2804 if( aBuf!=aStatic ) sqlite3_free(aBuf);
2807 readFileContents(ctx, pCur->zPath);
2810 case FSDIR_COLUMN_PATH:
2812 /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters.
2813 ** always return their values as NULL */
2821 ** Return the rowid for the current row. In this implementation, the
2822 ** first row returned is assigned rowid value 1, and each subsequent
2823 ** row a value 1 more than that of the previous.
2825 static int fsdirRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
2826 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2827 *pRowid = pCur->iRowid;
2832 ** Return TRUE if the cursor has been moved off of the last
2835 static int fsdirEof(sqlite3_vtab_cursor *cur){
2836 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2837 return (pCur->zPath==0);
2841 ** xFilter callback.
2843 ** idxNum==1 PATH parameter only
2844 ** idxNum==2 Both PATH and DIR supplied
2846 static int fsdirFilter(
2847 sqlite3_vtab_cursor *cur,
2848 int idxNum, const char *idxStr,
2849 int argc, sqlite3_value **argv
2851 const char *zDir = 0;
2852 fsdir_cursor *pCur = (fsdir_cursor*)cur;
2854 fsdirResetCursor(pCur);
2857 fsdirSetErrmsg(pCur, "table function fsdir requires an argument");
2858 return SQLITE_ERROR;
2861 assert( argc==idxNum && (argc==1 || argc==2) );
2862 zDir = (const char*)sqlite3_value_text(argv[0]);
2864 fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument");
2865 return SQLITE_ERROR;
2868 pCur->zBase = (const char*)sqlite3_value_text(argv[1]);
2871 pCur->nBase = (int)strlen(pCur->zBase)+1;
2872 pCur->zPath = sqlite3_mprintf("%s/%s", pCur->zBase, zDir);
2874 pCur->zPath = sqlite3_mprintf("%s", zDir);
2877 if( pCur->zPath==0 ){
2878 return SQLITE_NOMEM;
2880 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){
2881 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath);
2882 return SQLITE_ERROR;
2889 ** SQLite will invoke this method one or more times while planning a query
2890 ** that uses the generate_series virtual table. This routine needs to create
2891 ** a query plan for each invocation and compute an estimated cost for that
2894 ** In this implementation idxNum is used to represent the
2895 ** query plan. idxStr is unused.
2897 ** The query plan is represented by values of idxNum:
2899 ** (1) The path value is supplied by argv[0]
2900 ** (2) Path is in argv[0] and dir is in argv[1]
2902 static int fsdirBestIndex(
2904 sqlite3_index_info *pIdxInfo
2906 int i; /* Loop over constraints */
2907 int idxPath = -1; /* Index in pIdxInfo->aConstraint of PATH= */
2908 int idxDir = -1; /* Index in pIdxInfo->aConstraint of DIR= */
2909 int seenPath = 0; /* True if an unusable PATH= constraint is seen */
2910 int seenDir = 0; /* True if an unusable DIR= constraint is seen */
2911 const struct sqlite3_index_constraint *pConstraint;
2914 pConstraint = pIdxInfo->aConstraint;
2915 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
2916 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
2917 switch( pConstraint->iColumn ){
2918 case FSDIR_COLUMN_PATH: {
2919 if( pConstraint->usable ){
2922 }else if( idxPath<0 ){
2927 case FSDIR_COLUMN_DIR: {
2928 if( pConstraint->usable ){
2931 }else if( idxDir<0 ){
2938 if( seenPath || seenDir ){
2939 /* If input parameters are unusable, disallow this plan */
2940 return SQLITE_CONSTRAINT;
2944 pIdxInfo->idxNum = 0;
2945 /* The pIdxInfo->estimatedCost should have been initialized to a huge
2946 ** number. Leave it unchanged. */
2947 pIdxInfo->estimatedRows = 0x7fffffff;
2949 pIdxInfo->aConstraintUsage[idxPath].omit = 1;
2950 pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1;
2952 pIdxInfo->aConstraintUsage[idxDir].omit = 1;
2953 pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2;
2954 pIdxInfo->idxNum = 2;
2955 pIdxInfo->estimatedCost = 10.0;
2957 pIdxInfo->idxNum = 1;
2958 pIdxInfo->estimatedCost = 100.0;
2966 ** Register the "fsdir" virtual table.
2968 static int fsdirRegister(sqlite3 *db){
2969 static sqlite3_module fsdirModule = {
2972 fsdirConnect, /* xConnect */
2973 fsdirBestIndex, /* xBestIndex */
2974 fsdirDisconnect, /* xDisconnect */
2976 fsdirOpen, /* xOpen - open a cursor */
2977 fsdirClose, /* xClose - close a cursor */
2978 fsdirFilter, /* xFilter - configure scan constraints */
2979 fsdirNext, /* xNext - advance a cursor */
2980 fsdirEof, /* xEof - check for end of scan */
2981 fsdirColumn, /* xColumn - read data */
2982 fsdirRowid, /* xRowid - read data */
2988 0, /* xFindMethod */
2992 0, /* xRollbackTo */
2993 0, /* xShadowName */
2996 int rc = sqlite3_create_module(db, "fsdir", &fsdirModule, 0);
2999 #else /* SQLITE_OMIT_VIRTUALTABLE */
3000 # define fsdirRegister(x) SQLITE_OK
3006 int sqlite3_fileio_init(
3009 const sqlite3_api_routines *pApi
3012 SQLITE_EXTENSION_INIT2(pApi);
3013 (void)pzErrMsg; /* Unused parameter */
3014 rc = sqlite3_create_function(db, "readfile", 1,
3015 SQLITE_UTF8|SQLITE_DIRECTONLY, 0,
3016 readfileFunc, 0, 0);
3017 if( rc==SQLITE_OK ){
3018 rc = sqlite3_create_function(db, "writefile", -1,
3019 SQLITE_UTF8|SQLITE_DIRECTONLY, 0,
3020 writefileFunc, 0, 0);
3022 if( rc==SQLITE_OK ){
3023 rc = sqlite3_create_function(db, "lsmode", 1, SQLITE_UTF8, 0,
3026 if( rc==SQLITE_OK ){
3027 rc = fsdirRegister(db);
3032 /************************* End ../ext/misc/fileio.c ********************/
3033 /************************* Begin ../ext/misc/completion.c ******************/
3037 ** The author disclaims copyright to this source code. In place of
3038 ** a legal notice, here is a blessing:
3040 ** May you do good and not evil.
3041 ** May you find forgiveness for yourself and forgive others.
3042 ** May you share freely, never taking more than you give.
3044 *************************************************************************
3046 ** This file implements an eponymous virtual table that returns suggested
3047 ** completions for a partial SQL input.
3051 ** SELECT DISTINCT candidate COLLATE nocase
3052 ** FROM completion($prefix,$wholeline)
3055 ** The two query parameters are optional. $prefix is the text of the
3056 ** current word being typed and that is to be completed. $wholeline is
3057 ** the complete input line, used for context.
3059 ** The raw completion() table might return the same candidate multiple
3060 ** times, for example if the same column name is used to two or more
3061 ** tables. And the candidates are returned in an arbitrary order. Hence,
3062 ** the DISTINCT and ORDER BY are recommended.
3064 ** This virtual table operates at the speed of human typing, and so there
3065 ** is no attempt to make it fast. Even a slow implementation will be much
3066 ** faster than any human can type.
3069 /* #include "sqlite3ext.h" */
3070 SQLITE_EXTENSION_INIT1
3075 #ifndef SQLITE_OMIT_VIRTUALTABLE
3077 /* completion_vtab is a subclass of sqlite3_vtab which will
3078 ** serve as the underlying representation of a completion virtual table
3080 typedef struct completion_vtab completion_vtab;
3081 struct completion_vtab {
3082 sqlite3_vtab base; /* Base class - must be first */
3083 sqlite3 *db; /* Database connection for this completion vtab */
3086 /* completion_cursor is a subclass of sqlite3_vtab_cursor which will
3087 ** serve as the underlying representation of a cursor that scans
3088 ** over rows of the result
3090 typedef struct completion_cursor completion_cursor;
3091 struct completion_cursor {
3092 sqlite3_vtab_cursor base; /* Base class - must be first */
3093 sqlite3 *db; /* Database connection for this cursor */
3094 int nPrefix, nLine; /* Number of bytes in zPrefix and zLine */
3095 char *zPrefix; /* The prefix for the word we want to complete */
3096 char *zLine; /* The whole that we want to complete */
3097 const char *zCurrentRow; /* Current output row */
3098 int szRow; /* Length of the zCurrentRow string */
3099 sqlite3_stmt *pStmt; /* Current statement */
3100 sqlite3_int64 iRowid; /* The rowid */
3101 int ePhase; /* Current phase */
3102 int j; /* inter-phase counter */
3105 /* Values for ePhase:
3107 #define COMPLETION_FIRST_PHASE 1
3108 #define COMPLETION_KEYWORDS 1
3109 #define COMPLETION_PRAGMAS 2
3110 #define COMPLETION_FUNCTIONS 3
3111 #define COMPLETION_COLLATIONS 4
3112 #define COMPLETION_INDEXES 5
3113 #define COMPLETION_TRIGGERS 6
3114 #define COMPLETION_DATABASES 7
3115 #define COMPLETION_TABLES 8 /* Also VIEWs and TRIGGERs */
3116 #define COMPLETION_COLUMNS 9
3117 #define COMPLETION_MODULES 10
3118 #define COMPLETION_EOF 11
3121 ** The completionConnect() method is invoked to create a new
3122 ** completion_vtab that describes the completion virtual table.
3124 ** Think of this routine as the constructor for completion_vtab objects.
3126 ** All this routine needs to do is:
3128 ** (1) Allocate the completion_vtab object and initialize all fields.
3130 ** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
3131 ** result set of queries against completion will look like.
3133 static int completionConnect(
3136 int argc, const char *const*argv,
3137 sqlite3_vtab **ppVtab,
3140 completion_vtab *pNew;
3143 (void)(pAux); /* Unused parameter */
3144 (void)(argc); /* Unused parameter */
3145 (void)(argv); /* Unused parameter */
3146 (void)(pzErr); /* Unused parameter */
3148 /* Column numbers */
3149 #define COMPLETION_COLUMN_CANDIDATE 0 /* Suggested completion of the input */
3150 #define COMPLETION_COLUMN_PREFIX 1 /* Prefix of the word to be completed */
3151 #define COMPLETION_COLUMN_WHOLELINE 2 /* Entire line seen so far */
3152 #define COMPLETION_COLUMN_PHASE 3 /* ePhase - used for debugging only */
3154 sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
3155 rc = sqlite3_declare_vtab(db,
3158 " prefix TEXT HIDDEN,"
3159 " wholeline TEXT HIDDEN,"
3160 " phase INT HIDDEN" /* Used for debugging only */
3162 if( rc==SQLITE_OK ){
3163 pNew = sqlite3_malloc( sizeof(*pNew) );
3164 *ppVtab = (sqlite3_vtab*)pNew;
3165 if( pNew==0 ) return SQLITE_NOMEM;
3166 memset(pNew, 0, sizeof(*pNew));
3173 ** This method is the destructor for completion_cursor objects.
3175 static int completionDisconnect(sqlite3_vtab *pVtab){
3176 sqlite3_free(pVtab);
3181 ** Constructor for a new completion_cursor object.
3183 static int completionOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
3184 completion_cursor *pCur;
3185 pCur = sqlite3_malloc( sizeof(*pCur) );
3186 if( pCur==0 ) return SQLITE_NOMEM;
3187 memset(pCur, 0, sizeof(*pCur));
3188 pCur->db = ((completion_vtab*)p)->db;
3189 *ppCursor = &pCur->base;
3194 ** Reset the completion_cursor.
3196 static void completionCursorReset(completion_cursor *pCur){
3197 sqlite3_free(pCur->zPrefix); pCur->zPrefix = 0; pCur->nPrefix = 0;
3198 sqlite3_free(pCur->zLine); pCur->zLine = 0; pCur->nLine = 0;
3199 sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0;
3204 ** Destructor for a completion_cursor.
3206 static int completionClose(sqlite3_vtab_cursor *cur){
3207 completionCursorReset((completion_cursor*)cur);
3213 ** Advance a completion_cursor to its next row of output.
3215 ** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object
3216 ** record the current state of the scan. This routine sets ->zCurrentRow
3217 ** to the current row of output and then returns. If no more rows remain,
3218 ** then ->ePhase is set to COMPLETION_EOF which will signal the virtual
3219 ** table that has reached the end of its scan.
3221 ** The current implementation just lists potential identifiers and
3222 ** keywords and filters them by zPrefix. Future enhancements should
3223 ** take zLine into account to try to restrict the set of identifiers and
3224 ** keywords based on what would be legal at the current point of input.
3226 static int completionNext(sqlite3_vtab_cursor *cur){
3227 completion_cursor *pCur = (completion_cursor*)cur;
3228 int eNextPhase = 0; /* Next phase to try if current phase reaches end */
3229 int iCol = -1; /* If >=0, step pCur->pStmt and use the i-th column */
3231 while( pCur->ePhase!=COMPLETION_EOF ){
3232 switch( pCur->ePhase ){
3233 case COMPLETION_KEYWORDS: {
3234 if( pCur->j >= sqlite3_keyword_count() ){
3235 pCur->zCurrentRow = 0;
3236 pCur->ePhase = COMPLETION_DATABASES;
3238 sqlite3_keyword_name(pCur->j++, &pCur->zCurrentRow, &pCur->szRow);
3243 case COMPLETION_DATABASES: {
3244 if( pCur->pStmt==0 ){
3245 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1,
3249 eNextPhase = COMPLETION_TABLES;
3252 case COMPLETION_TABLES: {
3253 if( pCur->pStmt==0 ){
3256 const char *zSep = "";
3257 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
3258 while( sqlite3_step(pS2)==SQLITE_ROW ){
3259 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
3260 zSql = sqlite3_mprintf(
3262 "SELECT name FROM \"%w\".sqlite_master",
3265 if( zSql==0 ) return SQLITE_NOMEM;
3268 sqlite3_finalize(pS2);
3269 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
3273 eNextPhase = COMPLETION_COLUMNS;
3276 case COMPLETION_COLUMNS: {
3277 if( pCur->pStmt==0 ){
3280 const char *zSep = "";
3281 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
3282 while( sqlite3_step(pS2)==SQLITE_ROW ){
3283 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
3284 zSql = sqlite3_mprintf(
3286 "SELECT pti.name FROM \"%w\".sqlite_master AS sm"
3287 " JOIN pragma_table_info(sm.name,%Q) AS pti"
3288 " WHERE sm.type='table'",
3289 zSql, zSep, zDb, zDb
3291 if( zSql==0 ) return SQLITE_NOMEM;
3294 sqlite3_finalize(pS2);
3295 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
3299 eNextPhase = COMPLETION_EOF;
3304 /* This case is when the phase presets zCurrentRow */
3305 if( pCur->zCurrentRow==0 ) continue;
3307 if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){
3308 /* Extract the next row of content */
3309 pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol);
3310 pCur->szRow = sqlite3_column_bytes(pCur->pStmt, iCol);
3312 /* When all rows are finished, advance to the next phase */
3313 sqlite3_finalize(pCur->pStmt);
3315 pCur->ePhase = eNextPhase;
3319 if( pCur->nPrefix==0 ) break;
3320 if( pCur->nPrefix<=pCur->szRow
3321 && sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0
3331 ** Return values of columns for the row at which the completion_cursor
3332 ** is currently pointing.
3334 static int completionColumn(
3335 sqlite3_vtab_cursor *cur, /* The cursor */
3336 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
3337 int i /* Which column to return */
3339 completion_cursor *pCur = (completion_cursor*)cur;
3341 case COMPLETION_COLUMN_CANDIDATE: {
3342 sqlite3_result_text(ctx, pCur->zCurrentRow, pCur->szRow,SQLITE_TRANSIENT);
3345 case COMPLETION_COLUMN_PREFIX: {
3346 sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT);
3349 case COMPLETION_COLUMN_WHOLELINE: {
3350 sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT);
3353 case COMPLETION_COLUMN_PHASE: {
3354 sqlite3_result_int(ctx, pCur->ePhase);
3362 ** Return the rowid for the current row. In this implementation, the
3363 ** rowid is the same as the output value.
3365 static int completionRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
3366 completion_cursor *pCur = (completion_cursor*)cur;
3367 *pRowid = pCur->iRowid;
3372 ** Return TRUE if the cursor has been moved off of the last
3375 static int completionEof(sqlite3_vtab_cursor *cur){
3376 completion_cursor *pCur = (completion_cursor*)cur;
3377 return pCur->ePhase >= COMPLETION_EOF;
3381 ** This method is called to "rewind" the completion_cursor object back
3382 ** to the first row of output. This method is always called at least
3383 ** once prior to any call to completionColumn() or completionRowid() or
3386 static int completionFilter(
3387 sqlite3_vtab_cursor *pVtabCursor,
3388 int idxNum, const char *idxStr,
3389 int argc, sqlite3_value **argv
3391 completion_cursor *pCur = (completion_cursor *)pVtabCursor;
3393 (void)(idxStr); /* Unused parameter */
3394 (void)(argc); /* Unused parameter */
3395 completionCursorReset(pCur);
3397 pCur->nPrefix = sqlite3_value_bytes(argv[iArg]);
3398 if( pCur->nPrefix>0 ){
3399 pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
3400 if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
3405 pCur->nLine = sqlite3_value_bytes(argv[iArg]);
3406 if( pCur->nLine>0 ){
3407 pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
3408 if( pCur->zLine==0 ) return SQLITE_NOMEM;
3411 if( pCur->zLine!=0 && pCur->zPrefix==0 ){
3412 int i = pCur->nLine;
3413 while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){
3416 pCur->nPrefix = pCur->nLine - i;
3417 if( pCur->nPrefix>0 ){
3418 pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i);
3419 if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
3423 pCur->ePhase = COMPLETION_FIRST_PHASE;
3424 return completionNext(pVtabCursor);
3428 ** SQLite will invoke this method one or more times while planning a query
3429 ** that uses the completion virtual table. This routine needs to create
3430 ** a query plan for each invocation and compute an estimated cost for that
3433 ** There are two hidden parameters that act as arguments to the table-valued
3434 ** function: "prefix" and "wholeline". Bit 0 of idxNum is set if "prefix"
3435 ** is available and bit 1 is set if "wholeline" is available.
3437 static int completionBestIndex(
3439 sqlite3_index_info *pIdxInfo
3441 int i; /* Loop over constraints */
3442 int idxNum = 0; /* The query plan bitmask */
3443 int prefixIdx = -1; /* Index of the start= constraint, or -1 if none */
3444 int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */
3445 int nArg = 0; /* Number of arguments that completeFilter() expects */
3446 const struct sqlite3_index_constraint *pConstraint;
3448 (void)(tab); /* Unused parameter */
3449 pConstraint = pIdxInfo->aConstraint;
3450 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
3451 if( pConstraint->usable==0 ) continue;
3452 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
3453 switch( pConstraint->iColumn ){
3454 case COMPLETION_COLUMN_PREFIX:
3458 case COMPLETION_COLUMN_WHOLELINE:
3465 pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg;
3466 pIdxInfo->aConstraintUsage[prefixIdx].omit = 1;
3468 if( wholelineIdx>=0 ){
3469 pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg;
3470 pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1;
3472 pIdxInfo->idxNum = idxNum;
3473 pIdxInfo->estimatedCost = (double)5000 - 1000*nArg;
3474 pIdxInfo->estimatedRows = 500 - 100*nArg;
3479 ** This following structure defines all the methods for the
3480 ** completion virtual table.
3482 static sqlite3_module completionModule = {
3485 completionConnect, /* xConnect */
3486 completionBestIndex, /* xBestIndex */
3487 completionDisconnect, /* xDisconnect */
3489 completionOpen, /* xOpen - open a cursor */
3490 completionClose, /* xClose - close a cursor */
3491 completionFilter, /* xFilter - configure scan constraints */
3492 completionNext, /* xNext - advance a cursor */
3493 completionEof, /* xEof - check for end of scan */
3494 completionColumn, /* xColumn - read data */
3495 completionRowid, /* xRowid - read data */
3501 0, /* xFindMethod */
3505 0, /* xRollbackTo */
3509 #endif /* SQLITE_OMIT_VIRTUALTABLE */
3511 int sqlite3CompletionVtabInit(sqlite3 *db){
3513 #ifndef SQLITE_OMIT_VIRTUALTABLE
3514 rc = sqlite3_create_module(db, "completion", &completionModule, 0);
3522 int sqlite3_completion_init(
3525 const sqlite3_api_routines *pApi
3528 SQLITE_EXTENSION_INIT2(pApi);
3529 (void)(pzErrMsg); /* Unused parameter */
3530 #ifndef SQLITE_OMIT_VIRTUALTABLE
3531 rc = sqlite3CompletionVtabInit(db);
3536 /************************* End ../ext/misc/completion.c ********************/
3537 /************************* Begin ../ext/misc/appendvfs.c ******************/
3541 ** The author disclaims copyright to this source code. In place of
3542 ** a legal notice, here is a blessing:
3544 ** May you do good and not evil.
3545 ** May you find forgiveness for yourself and forgive others.
3546 ** May you share freely, never taking more than you give.
3548 ******************************************************************************
3550 ** This file implements a VFS shim that allows an SQLite database to be
3551 ** appended onto the end of some other file, such as an executable.
3553 ** A special record must appear at the end of the file that identifies the
3554 ** file as an appended database and provides an offset to page 1. For
3555 ** best performance page 1 should be located at a disk page boundary, though
3556 ** that is not required.
3558 ** When opening a database using this VFS, the connection might treat
3559 ** the file as an ordinary SQLite database, or it might treat is as a
3560 ** database appended onto some other file. Here are the rules:
3562 ** (1) When opening a new empty file, that file is treated as an ordinary
3565 ** (2) When opening a file that begins with the standard SQLite prefix
3566 ** string "SQLite format 3", that file is treated as an ordinary
3569 ** (3) When opening a file that ends with the appendvfs trailer string
3570 ** "Start-Of-SQLite3-NNNNNNNN" that file is treated as an appended
3573 ** (4) If none of the above apply and the SQLITE_OPEN_CREATE flag is
3574 ** set, then a new database is appended to the already existing file.
3576 ** (5) Otherwise, SQLITE_CANTOPEN is returned.
3578 ** To avoid unnecessary complications with the PENDING_BYTE, the size of
3579 ** the file containing the database is limited to 1GB. This VFS will refuse
3580 ** to read or write past the 1GB mark. This restriction might be lifted in
3581 ** future versions. For now, if you need a large database, then keep the
3582 ** database in a separate file.
3584 ** If the file being opened is not an appended database, then this shim is
3585 ** a pass-through into the default underlying VFS.
3587 /* #include "sqlite3ext.h" */
3588 SQLITE_EXTENSION_INIT1
3592 /* The append mark at the end of the database is:
3594 ** Start-Of-SQLite3-NNNNNNNN
3595 ** 123456789 123456789 12345
3597 ** The NNNNNNNN represents a 64-bit big-endian unsigned integer which is
3598 ** the offset to page 1.
3600 #define APND_MARK_PREFIX "Start-Of-SQLite3-"
3601 #define APND_MARK_PREFIX_SZ 17
3602 #define APND_MARK_SIZE 25
3605 ** Maximum size of the combined prefix + database + append-mark. This
3606 ** must be less than 0x40000000 to avoid locking issues on Windows.
3608 #define APND_MAX_SIZE (65536*15259)
3611 ** Forward declaration of objects used by this utility
3613 typedef struct sqlite3_vfs ApndVfs;
3614 typedef struct ApndFile ApndFile;
3616 /* Access to a lower-level VFS that (might) implement dynamic loading,
3617 ** access to randomness, etc.
3619 #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData))
3620 #define ORIGFILE(p) ((sqlite3_file*)(((ApndFile*)(p))+1))
3624 sqlite3_file base; /* IO methods */
3625 sqlite3_int64 iPgOne; /* File offset to page 1 */
3626 sqlite3_int64 iMark; /* Start of the append-mark */
3630 ** Methods for ApndFile
3632 static int apndClose(sqlite3_file*);
3633 static int apndRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
3634 static int apndWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
3635 static int apndTruncate(sqlite3_file*, sqlite3_int64 size);
3636 static int apndSync(sqlite3_file*, int flags);
3637 static int apndFileSize(sqlite3_file*, sqlite3_int64 *pSize);
3638 static int apndLock(sqlite3_file*, int);
3639 static int apndUnlock(sqlite3_file*, int);
3640 static int apndCheckReservedLock(sqlite3_file*, int *pResOut);
3641 static int apndFileControl(sqlite3_file*, int op, void *pArg);
3642 static int apndSectorSize(sqlite3_file*);
3643 static int apndDeviceCharacteristics(sqlite3_file*);
3644 static int apndShmMap(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
3645 static int apndShmLock(sqlite3_file*, int offset, int n, int flags);
3646 static void apndShmBarrier(sqlite3_file*);
3647 static int apndShmUnmap(sqlite3_file*, int deleteFlag);
3648 static int apndFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
3649 static int apndUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p);
3652 ** Methods for ApndVfs
3654 static int apndOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
3655 static int apndDelete(sqlite3_vfs*, const char *zName, int syncDir);
3656 static int apndAccess(sqlite3_vfs*, const char *zName, int flags, int *);
3657 static int apndFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
3658 static void *apndDlOpen(sqlite3_vfs*, const char *zFilename);
3659 static void apndDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
3660 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
3661 static void apndDlClose(sqlite3_vfs*, void*);
3662 static int apndRandomness(sqlite3_vfs*, int nByte, char *zOut);
3663 static int apndSleep(sqlite3_vfs*, int microseconds);
3664 static int apndCurrentTime(sqlite3_vfs*, double*);
3665 static int apndGetLastError(sqlite3_vfs*, int, char *);
3666 static int apndCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
3667 static int apndSetSystemCall(sqlite3_vfs*, const char*,sqlite3_syscall_ptr);
3668 static sqlite3_syscall_ptr apndGetSystemCall(sqlite3_vfs*, const char *z);
3669 static const char *apndNextSystemCall(sqlite3_vfs*, const char *zName);
3671 static sqlite3_vfs apnd_vfs = {
3672 3, /* iVersion (set when registered) */
3673 0, /* szOsFile (set when registered) */
3674 1024, /* mxPathname */
3676 "apndvfs", /* zName */
3677 0, /* pAppData (set when registered) */
3678 apndOpen, /* xOpen */
3679 apndDelete, /* xDelete */
3680 apndAccess, /* xAccess */
3681 apndFullPathname, /* xFullPathname */
3682 apndDlOpen, /* xDlOpen */
3683 apndDlError, /* xDlError */
3684 apndDlSym, /* xDlSym */
3685 apndDlClose, /* xDlClose */
3686 apndRandomness, /* xRandomness */
3687 apndSleep, /* xSleep */
3688 apndCurrentTime, /* xCurrentTime */
3689 apndGetLastError, /* xGetLastError */
3690 apndCurrentTimeInt64, /* xCurrentTimeInt64 */
3691 apndSetSystemCall, /* xSetSystemCall */
3692 apndGetSystemCall, /* xGetSystemCall */
3693 apndNextSystemCall /* xNextSystemCall */
3696 static const sqlite3_io_methods apnd_io_methods = {
3698 apndClose, /* xClose */
3699 apndRead, /* xRead */
3700 apndWrite, /* xWrite */
3701 apndTruncate, /* xTruncate */
3702 apndSync, /* xSync */
3703 apndFileSize, /* xFileSize */
3704 apndLock, /* xLock */
3705 apndUnlock, /* xUnlock */
3706 apndCheckReservedLock, /* xCheckReservedLock */
3707 apndFileControl, /* xFileControl */
3708 apndSectorSize, /* xSectorSize */
3709 apndDeviceCharacteristics, /* xDeviceCharacteristics */
3710 apndShmMap, /* xShmMap */
3711 apndShmLock, /* xShmLock */
3712 apndShmBarrier, /* xShmBarrier */
3713 apndShmUnmap, /* xShmUnmap */
3714 apndFetch, /* xFetch */
3715 apndUnfetch /* xUnfetch */
3721 ** Close an apnd-file.
3723 static int apndClose(sqlite3_file *pFile){
3724 pFile = ORIGFILE(pFile);
3725 return pFile->pMethods->xClose(pFile);
3729 ** Read data from an apnd-file.
3731 static int apndRead(
3732 sqlite3_file *pFile,
3737 ApndFile *p = (ApndFile *)pFile;
3738 pFile = ORIGFILE(pFile);
3739 return pFile->pMethods->xRead(pFile, zBuf, iAmt, iOfst+p->iPgOne);
3743 ** Add the append-mark onto the end of the file.
3745 static int apndWriteMark(ApndFile *p, sqlite3_file *pFile){
3747 unsigned char a[APND_MARK_SIZE];
3748 memcpy(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ);
3750 a[APND_MARK_PREFIX_SZ+i] = (p->iPgOne >> (56 - i*8)) & 0xff;
3752 return pFile->pMethods->xWrite(pFile, a, APND_MARK_SIZE, p->iMark);
3756 ** Write data to an apnd-file.
3758 static int apndWrite(
3759 sqlite3_file *pFile,
3765 ApndFile *p = (ApndFile *)pFile;
3766 pFile = ORIGFILE(pFile);
3767 if( iOfst+iAmt>=APND_MAX_SIZE ) return SQLITE_FULL;
3768 rc = pFile->pMethods->xWrite(pFile, zBuf, iAmt, iOfst+p->iPgOne);
3769 if( rc==SQLITE_OK && iOfst + iAmt + p->iPgOne > p->iMark ){
3770 sqlite3_int64 sz = 0;
3771 rc = pFile->pMethods->xFileSize(pFile, &sz);
3772 if( rc==SQLITE_OK ){
3773 p->iMark = sz - APND_MARK_SIZE;
3774 if( iOfst + iAmt + p->iPgOne > p->iMark ){
3775 p->iMark = p->iPgOne + iOfst + iAmt;
3776 rc = apndWriteMark(p, pFile);
3784 ** Truncate an apnd-file.
3786 static int apndTruncate(sqlite3_file *pFile, sqlite_int64 size){
3788 ApndFile *p = (ApndFile *)pFile;
3789 pFile = ORIGFILE(pFile);
3790 rc = pFile->pMethods->xTruncate(pFile, size+p->iPgOne+APND_MARK_SIZE);
3791 if( rc==SQLITE_OK ){
3792 p->iMark = p->iPgOne+size;
3793 rc = apndWriteMark(p, pFile);
3799 ** Sync an apnd-file.
3801 static int apndSync(sqlite3_file *pFile, int flags){
3802 pFile = ORIGFILE(pFile);
3803 return pFile->pMethods->xSync(pFile, flags);
3807 ** Return the current file-size of an apnd-file.
3809 static int apndFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
3810 ApndFile *p = (ApndFile *)pFile;
3812 pFile = ORIGFILE(p);
3813 rc = pFile->pMethods->xFileSize(pFile, pSize);
3814 if( rc==SQLITE_OK && p->iPgOne ){
3815 *pSize -= p->iPgOne + APND_MARK_SIZE;
3821 ** Lock an apnd-file.
3823 static int apndLock(sqlite3_file *pFile, int eLock){
3824 pFile = ORIGFILE(pFile);
3825 return pFile->pMethods->xLock(pFile, eLock);
3829 ** Unlock an apnd-file.
3831 static int apndUnlock(sqlite3_file *pFile, int eLock){
3832 pFile = ORIGFILE(pFile);
3833 return pFile->pMethods->xUnlock(pFile, eLock);
3837 ** Check if another file-handle holds a RESERVED lock on an apnd-file.
3839 static int apndCheckReservedLock(sqlite3_file *pFile, int *pResOut){
3840 pFile = ORIGFILE(pFile);
3841 return pFile->pMethods->xCheckReservedLock(pFile, pResOut);
3845 ** File control method. For custom operations on an apnd-file.
3847 static int apndFileControl(sqlite3_file *pFile, int op, void *pArg){
3848 ApndFile *p = (ApndFile *)pFile;
3850 pFile = ORIGFILE(pFile);
3851 rc = pFile->pMethods->xFileControl(pFile, op, pArg);
3852 if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
3853 *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", p->iPgOne, *(char**)pArg);
3859 ** Return the sector-size in bytes for an apnd-file.
3861 static int apndSectorSize(sqlite3_file *pFile){
3862 pFile = ORIGFILE(pFile);
3863 return pFile->pMethods->xSectorSize(pFile);
3867 ** Return the device characteristic flags supported by an apnd-file.
3869 static int apndDeviceCharacteristics(sqlite3_file *pFile){
3870 pFile = ORIGFILE(pFile);
3871 return pFile->pMethods->xDeviceCharacteristics(pFile);
3874 /* Create a shared memory file mapping */
3875 static int apndShmMap(
3876 sqlite3_file *pFile,
3882 pFile = ORIGFILE(pFile);
3883 return pFile->pMethods->xShmMap(pFile,iPg,pgsz,bExtend,pp);
3886 /* Perform locking on a shared-memory segment */
3887 static int apndShmLock(sqlite3_file *pFile, int offset, int n, int flags){
3888 pFile = ORIGFILE(pFile);
3889 return pFile->pMethods->xShmLock(pFile,offset,n,flags);
3892 /* Memory barrier operation on shared memory */
3893 static void apndShmBarrier(sqlite3_file *pFile){
3894 pFile = ORIGFILE(pFile);
3895 pFile->pMethods->xShmBarrier(pFile);
3898 /* Unmap a shared memory segment */
3899 static int apndShmUnmap(sqlite3_file *pFile, int deleteFlag){
3900 pFile = ORIGFILE(pFile);
3901 return pFile->pMethods->xShmUnmap(pFile,deleteFlag);
3904 /* Fetch a page of a memory-mapped file */
3905 static int apndFetch(
3906 sqlite3_file *pFile,
3907 sqlite3_int64 iOfst,
3911 ApndFile *p = (ApndFile *)pFile;
3912 pFile = ORIGFILE(pFile);
3913 return pFile->pMethods->xFetch(pFile, iOfst+p->iPgOne, iAmt, pp);
3916 /* Release a memory-mapped page */
3917 static int apndUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
3918 ApndFile *p = (ApndFile *)pFile;
3919 pFile = ORIGFILE(pFile);
3920 return pFile->pMethods->xUnfetch(pFile, iOfst+p->iPgOne, pPage);
3924 ** Check to see if the file is an ordinary SQLite database file.
3926 static int apndIsOrdinaryDatabaseFile(sqlite3_int64 sz, sqlite3_file *pFile){
3929 static const char aSqliteHdr[] = "SQLite format 3";
3930 if( sz<512 ) return 0;
3931 rc = pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), 0);
3933 return memcmp(zHdr, aSqliteHdr, sizeof(zHdr))==0;
3937 ** Try to read the append-mark off the end of a file. Return the
3938 ** start of the appended database if the append-mark is present. If
3939 ** there is no append-mark, return -1;
3941 static sqlite3_int64 apndReadMark(sqlite3_int64 sz, sqlite3_file *pFile){
3943 sqlite3_int64 iMark;
3944 unsigned char a[APND_MARK_SIZE];
3946 if( sz<=APND_MARK_SIZE ) return -1;
3947 rc = pFile->pMethods->xRead(pFile, a, APND_MARK_SIZE, sz-APND_MARK_SIZE);
3949 if( memcmp(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ)!=0 ) return -1;
3950 iMark = ((sqlite3_int64)(a[APND_MARK_PREFIX_SZ]&0x7f))<<56;
3952 iMark += (sqlite3_int64)a[APND_MARK_PREFIX_SZ+i]<<(56-8*i);
3958 ** Open an apnd file handle.
3960 static int apndOpen(
3963 sqlite3_file *pFile,
3968 sqlite3_file *pSubFile;
3969 sqlite3_vfs *pSubVfs;
3972 pSubVfs = ORIGVFS(pVfs);
3973 if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){
3974 return pSubVfs->xOpen(pSubVfs, zName, pFile, flags, pOutFlags);
3976 p = (ApndFile*)pFile;
3977 memset(p, 0, sizeof(*p));
3978 pSubFile = ORIGFILE(pFile);
3979 p->base.pMethods = &apnd_io_methods;
3980 rc = pSubVfs->xOpen(pSubVfs, zName, pSubFile, flags, pOutFlags);
3981 if( rc ) goto apnd_open_done;
3982 rc = pSubFile->pMethods->xFileSize(pSubFile, &sz);
3984 pSubFile->pMethods->xClose(pSubFile);
3985 goto apnd_open_done;
3987 if( apndIsOrdinaryDatabaseFile(sz, pSubFile) ){
3988 memmove(pFile, pSubFile, pSubVfs->szOsFile);
3992 p->iPgOne = apndReadMark(sz, pFile);
3996 if( (flags & SQLITE_OPEN_CREATE)==0 ){
3997 pSubFile->pMethods->xClose(pSubFile);
3998 rc = SQLITE_CANTOPEN;
4000 p->iPgOne = (sz+0xfff) & ~(sqlite3_int64)0xfff;
4002 if( rc ) pFile->pMethods = 0;
4007 ** All other VFS methods are pass-thrus.
4009 static int apndDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
4010 return ORIGVFS(pVfs)->xDelete(ORIGVFS(pVfs), zPath, dirSync);
4012 static int apndAccess(
4018 return ORIGVFS(pVfs)->xAccess(ORIGVFS(pVfs), zPath, flags, pResOut);
4020 static int apndFullPathname(
4026 return ORIGVFS(pVfs)->xFullPathname(ORIGVFS(pVfs),zPath,nOut,zOut);
4028 static void *apndDlOpen(sqlite3_vfs *pVfs, const char *zPath){
4029 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
4031 static void apndDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
4032 ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
4034 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
4035 return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym);
4037 static void apndDlClose(sqlite3_vfs *pVfs, void *pHandle){
4038 ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
4040 static int apndRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
4041 return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
4043 static int apndSleep(sqlite3_vfs *pVfs, int nMicro){
4044 return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
4046 static int apndCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
4047 return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
4049 static int apndGetLastError(sqlite3_vfs *pVfs, int a, char *b){
4050 return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
4052 static int apndCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
4053 return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
4055 static int apndSetSystemCall(
4058 sqlite3_syscall_ptr pCall
4060 return ORIGVFS(pVfs)->xSetSystemCall(ORIGVFS(pVfs),zName,pCall);
4062 static sqlite3_syscall_ptr apndGetSystemCall(
4066 return ORIGVFS(pVfs)->xGetSystemCall(ORIGVFS(pVfs),zName);
4068 static const char *apndNextSystemCall(sqlite3_vfs *pVfs, const char *zName){
4069 return ORIGVFS(pVfs)->xNextSystemCall(ORIGVFS(pVfs), zName);
4077 ** This routine is called when the extension is loaded.
4078 ** Register the new VFS.
4080 int sqlite3_appendvfs_init(
4083 const sqlite3_api_routines *pApi
4087 SQLITE_EXTENSION_INIT2(pApi);
4090 pOrig = sqlite3_vfs_find(0);
4091 apnd_vfs.iVersion = pOrig->iVersion;
4092 apnd_vfs.pAppData = pOrig;
4093 apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile);
4094 rc = sqlite3_vfs_register(&apnd_vfs, 0);
4095 #ifdef APPENDVFS_TEST
4096 if( rc==SQLITE_OK ){
4097 rc = sqlite3_auto_extension((void(*)(void))apndvfsRegister);
4100 if( rc==SQLITE_OK ) rc = SQLITE_OK_LOAD_PERMANENTLY;
4104 /************************* End ../ext/misc/appendvfs.c ********************/
4105 /************************* Begin ../ext/misc/memtrace.c ******************/
4109 ** The author disclaims copyright to this source code. In place of
4110 ** a legal notice, here is a blessing:
4112 ** May you do good and not evil.
4113 ** May you find forgiveness for yourself and forgive others.
4114 ** May you share freely, never taking more than you give.
4116 *************************************************************************
4118 ** This file implements an extension that uses the SQLITE_CONFIG_MALLOC
4119 ** mechanism to add a tracing layer on top of SQLite. If this extension
4120 ** is registered prior to sqlite3_initialize(), it will cause all memory
4121 ** allocation activities to be logged on standard output, or to some other
4122 ** FILE specified by the initializer.
4124 ** This file needs to be compiled into the application that uses it.
4126 ** This extension is used to implement the --memtrace option of the
4127 ** command-line shell.
4133 /* The original memory allocation routines */
4134 static sqlite3_mem_methods memtraceBase;
4135 static FILE *memtraceOut;
4137 /* Methods that trace memory allocations */
4138 static void *memtraceMalloc(int n){
4140 fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n",
4141 memtraceBase.xRoundup(n));
4143 return memtraceBase.xMalloc(n);
4145 static void memtraceFree(void *p){
4148 fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p));
4150 memtraceBase.xFree(p);
4152 static void *memtraceRealloc(void *p, int n){
4153 if( p==0 ) return memtraceMalloc(n);
4159 fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n",
4160 memtraceBase.xSize(p), memtraceBase.xRoundup(n));
4162 return memtraceBase.xRealloc(p, n);
4164 static int memtraceSize(void *p){
4165 return memtraceBase.xSize(p);
4167 static int memtraceRoundup(int n){
4168 return memtraceBase.xRoundup(n);
4170 static int memtraceInit(void *p){
4171 return memtraceBase.xInit(p);
4173 static void memtraceShutdown(void *p){
4174 memtraceBase.xShutdown(p);
4177 /* The substitute memory allocator */
4178 static sqlite3_mem_methods ersaztMethods = {
4189 /* Begin tracing memory allocations to out. */
4190 int sqlite3MemTraceActivate(FILE *out){
4192 if( memtraceBase.xMalloc==0 ){
4193 rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase);
4194 if( rc==SQLITE_OK ){
4195 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods);
4202 /* Deactivate memory tracing */
4203 int sqlite3MemTraceDeactivate(void){
4205 if( memtraceBase.xMalloc!=0 ){
4206 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase);
4207 if( rc==SQLITE_OK ){
4208 memset(&memtraceBase, 0, sizeof(memtraceBase));
4215 /************************* End ../ext/misc/memtrace.c ********************/
4216 #ifdef SQLITE_HAVE_ZLIB
4217 /************************* Begin ../ext/misc/zipfile.c ******************/
4221 ** The author disclaims copyright to this source code. In place of
4222 ** a legal notice, here is a blessing:
4224 ** May you do good and not evil.
4225 ** May you find forgiveness for yourself and forgive others.
4226 ** May you share freely, never taking more than you give.
4228 ******************************************************************************
4230 ** This file implements a virtual table for reading and writing ZIP archive
4235 ** SELECT name, sz, datetime(mtime,'unixepoch') FROM zipfile($filename);
4237 ** Current limitations:
4239 ** * No support for encryption
4240 ** * No support for ZIP archives spanning multiple files
4241 ** * No support for zip64 extensions
4242 ** * Only the "inflate/deflate" (zlib) compression method is supported
4244 /* #include "sqlite3ext.h" */
4245 SQLITE_EXTENSION_INIT1
4252 #ifndef SQLITE_OMIT_VIRTUALTABLE
4254 #ifndef SQLITE_AMALGAMATION
4256 /* typedef sqlite3_int64 i64; */
4257 /* typedef unsigned char u8; */
4258 typedef unsigned short u16;
4259 typedef unsigned long u32;
4260 #define MIN(a,b) ((a)<(b) ? (a) : (b))
4262 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
4263 # define ALWAYS(X) (1)
4264 # define NEVER(X) (0)
4265 #elif !defined(NDEBUG)
4266 # define ALWAYS(X) ((X)?1:(assert(0),0))
4267 # define NEVER(X) ((X)?(assert(0),1):0)
4269 # define ALWAYS(X) (X)
4270 # define NEVER(X) (X)
4273 #endif /* SQLITE_AMALGAMATION */
4276 ** Definitions for mode bitmasks S_IFDIR, S_IFREG and S_IFLNK.
4278 ** In some ways it would be better to obtain these values from system
4279 ** header files. But, the dependency is undesirable and (a) these
4280 ** have been stable for decades, (b) the values are part of POSIX and
4281 ** are also made explicit in [man stat], and (c) are part of the
4282 ** file format for zip archives.
4285 # define S_IFDIR 0040000
4288 # define S_IFREG 0100000
4291 # define S_IFLNK 0120000
4294 static const char ZIPFILE_SCHEMA[] =
4296 "name PRIMARY KEY," /* 0: Name of file in zip archive */
4297 "mode," /* 1: POSIX mode for file */
4298 "mtime," /* 2: Last modification time (secs since 1970)*/
4299 "sz," /* 3: Size of object */
4300 "rawdata," /* 4: Raw data */
4301 "data," /* 5: Uncompressed data */
4302 "method," /* 6: Compression method (integer) */
4303 "z HIDDEN" /* 7: Name of zip file */
4306 #define ZIPFILE_F_COLUMN_IDX 7 /* Index of column "file" in the above */
4307 #define ZIPFILE_BUFFER_SIZE (64*1024)
4311 ** Magic numbers used to read and write zip files.
4313 ** ZIPFILE_NEWENTRY_MADEBY:
4314 ** Use this value for the "version-made-by" field in new zip file
4315 ** entries. The upper byte indicates "unix", and the lower byte
4316 ** indicates that the zip file matches pkzip specification 3.0.
4317 ** This is what info-zip seems to do.
4319 ** ZIPFILE_NEWENTRY_REQUIRED:
4320 ** Value for "version-required-to-extract" field of new entries.
4321 ** Version 2.0 is required to support folders and deflate compression.
4323 ** ZIPFILE_NEWENTRY_FLAGS:
4324 ** Value for "general-purpose-bit-flags" field of new entries. Bit
4325 ** 11 means "utf-8 filename and comment".
4327 ** ZIPFILE_SIGNATURE_CDS:
4328 ** First 4 bytes of a valid CDS record.
4330 ** ZIPFILE_SIGNATURE_LFH:
4331 ** First 4 bytes of a valid LFH record.
4333 ** ZIPFILE_SIGNATURE_EOCD
4334 ** First 4 bytes of a valid EOCD record.
4336 #define ZIPFILE_EXTRA_TIMESTAMP 0x5455
4337 #define ZIPFILE_NEWENTRY_MADEBY ((3<<8) + 30)
4338 #define ZIPFILE_NEWENTRY_REQUIRED 20
4339 #define ZIPFILE_NEWENTRY_FLAGS 0x800
4340 #define ZIPFILE_SIGNATURE_CDS 0x02014b50
4341 #define ZIPFILE_SIGNATURE_LFH 0x04034b50
4342 #define ZIPFILE_SIGNATURE_EOCD 0x06054b50
4345 ** The sizes of the fixed-size part of each of the three main data
4346 ** structures in a zip archive.
4348 #define ZIPFILE_LFH_FIXED_SZ 30
4349 #define ZIPFILE_EOCD_FIXED_SZ 22
4350 #define ZIPFILE_CDS_FIXED_SZ 46
4353 *** 4.3.16 End of central directory record:
4355 *** end of central dir signature 4 bytes (0x06054b50)
4356 *** number of this disk 2 bytes
4357 *** number of the disk with the
4358 *** start of the central directory 2 bytes
4359 *** total number of entries in the
4360 *** central directory on this disk 2 bytes
4361 *** total number of entries in
4362 *** the central directory 2 bytes
4363 *** size of the central directory 4 bytes
4364 *** offset of start of central
4365 *** directory with respect to
4366 *** the starting disk number 4 bytes
4367 *** .ZIP file comment length 2 bytes
4368 *** .ZIP file comment (variable size)
4370 typedef struct ZipfileEOCD ZipfileEOCD;
4371 struct ZipfileEOCD {
4381 *** 4.3.12 Central directory structure:
4385 *** central file header signature 4 bytes (0x02014b50)
4386 *** version made by 2 bytes
4387 *** version needed to extract 2 bytes
4388 *** general purpose bit flag 2 bytes
4389 *** compression method 2 bytes
4390 *** last mod file time 2 bytes
4391 *** last mod file date 2 bytes
4393 *** compressed size 4 bytes
4394 *** uncompressed size 4 bytes
4395 *** file name length 2 bytes
4396 *** extra field length 2 bytes
4397 *** file comment length 2 bytes
4398 *** disk number start 2 bytes
4399 *** internal file attributes 2 bytes
4400 *** external file attributes 4 bytes
4401 *** relative offset of local header 4 bytes
4403 typedef struct ZipfileCDS ZipfileCDS;
4406 u16 iVersionExtract;
4421 char *zFile; /* Filename (sqlite3_malloc()) */
4425 *** 4.3.7 Local file header:
4427 *** local file header signature 4 bytes (0x04034b50)
4428 *** version needed to extract 2 bytes
4429 *** general purpose bit flag 2 bytes
4430 *** compression method 2 bytes
4431 *** last mod file time 2 bytes
4432 *** last mod file date 2 bytes
4434 *** compressed size 4 bytes
4435 *** uncompressed size 4 bytes
4436 *** file name length 2 bytes
4437 *** extra field length 2 bytes
4440 typedef struct ZipfileLFH ZipfileLFH;
4442 u16 iVersionExtract;
4454 typedef struct ZipfileEntry ZipfileEntry;
4455 struct ZipfileEntry {
4456 ZipfileCDS cds; /* Parsed CDS record */
4457 u32 mUnixTime; /* Modification time, in UNIX format */
4458 u8 *aExtra; /* cds.nExtra+cds.nComment bytes of extra data */
4459 i64 iDataOff; /* Offset to data in file (if aData==0) */
4460 u8 *aData; /* cds.szCompressed bytes of compressed data */
4461 ZipfileEntry *pNext; /* Next element in in-memory CDS */
4465 ** Cursor type for zipfile tables.
4467 typedef struct ZipfileCsr ZipfileCsr;
4469 sqlite3_vtab_cursor base; /* Base class - must be first */
4470 i64 iId; /* Cursor ID */
4471 u8 bEof; /* True when at EOF */
4472 u8 bNoop; /* If next xNext() call is no-op */
4474 /* Used outside of write transactions */
4475 FILE *pFile; /* Zip file */
4476 i64 iNextOff; /* Offset of next record in central directory */
4477 ZipfileEOCD eocd; /* Parse of central directory record */
4479 ZipfileEntry *pFreeEntry; /* Free this list when cursor is closed or reset */
4480 ZipfileEntry *pCurrent; /* Current entry */
4481 ZipfileCsr *pCsrNext; /* Next cursor on same virtual table */
4484 typedef struct ZipfileTab ZipfileTab;
4486 sqlite3_vtab base; /* Base class - must be first */
4487 char *zFile; /* Zip file this table accesses (may be NULL) */
4488 sqlite3 *db; /* Host database connection */
4489 u8 *aBuffer; /* Temporary buffer used for various tasks */
4491 ZipfileCsr *pCsrList; /* List of cursors */
4494 /* The following are used by write transactions only */
4495 ZipfileEntry *pFirstEntry; /* Linked list of all files (if pWriteFd!=0) */
4496 ZipfileEntry *pLastEntry; /* Last element in pFirstEntry list */
4497 FILE *pWriteFd; /* File handle open on zip archive */
4498 i64 szCurrent; /* Current size of zip archive */
4499 i64 szOrig; /* Size of archive at start of transaction */
4503 ** Set the error message contained in context ctx to the results of
4504 ** vprintf(zFmt, ...).
4506 static void zipfileCtxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){
4510 zMsg = sqlite3_vmprintf(zFmt, ap);
4511 sqlite3_result_error(ctx, zMsg, -1);
4517 ** If string zIn is quoted, dequote it in place. Otherwise, if the string
4518 ** is not quoted, do nothing.
4520 static void zipfileDequote(char *zIn){
4522 if( q=='"' || q=='\'' || q=='`' || q=='[' ){
4525 if( q=='[' ) q = ']';
4526 while( ALWAYS(zIn[iIn]) ){
4527 char c = zIn[iIn++];
4528 if( c==q && zIn[iIn++]!=q ) break;
4536 ** Construct a new ZipfileTab virtual table object.
4538 ** argv[0] -> module name ("zipfile")
4539 ** argv[1] -> database name
4540 ** argv[2] -> table name
4541 ** argv[...] -> "column name" and other module argument fields.
4543 static int zipfileConnect(
4546 int argc, const char *const*argv,
4547 sqlite3_vtab **ppVtab,
4550 int nByte = sizeof(ZipfileTab) + ZIPFILE_BUFFER_SIZE;
4552 const char *zFile = 0;
4553 ZipfileTab *pNew = 0;
4556 /* If the table name is not "zipfile", require that the argument be
4557 ** specified. This stops zipfile tables from being created as:
4559 ** CREATE VIRTUAL TABLE zzz USING zipfile();
4561 ** It does not prevent:
4563 ** CREATE VIRTUAL TABLE zipfile USING zipfile();
4565 assert( 0==sqlite3_stricmp(argv[0], "zipfile") );
4566 if( (0!=sqlite3_stricmp(argv[2], "zipfile") && argc<4) || argc>4 ){
4567 *pzErr = sqlite3_mprintf("zipfile constructor requires one argument");
4568 return SQLITE_ERROR;
4573 nFile = (int)strlen(zFile)+1;
4576 rc = sqlite3_declare_vtab(db, ZIPFILE_SCHEMA);
4577 if( rc==SQLITE_OK ){
4578 pNew = (ZipfileTab*)sqlite3_malloc64((sqlite3_int64)nByte+nFile);
4579 if( pNew==0 ) return SQLITE_NOMEM;
4580 memset(pNew, 0, nByte+nFile);
4582 pNew->aBuffer = (u8*)&pNew[1];
4584 pNew->zFile = (char*)&pNew->aBuffer[ZIPFILE_BUFFER_SIZE];
4585 memcpy(pNew->zFile, zFile, nFile);
4586 zipfileDequote(pNew->zFile);
4589 sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);
4590 *ppVtab = (sqlite3_vtab*)pNew;
4595 ** Free the ZipfileEntry structure indicated by the only argument.
4597 static void zipfileEntryFree(ZipfileEntry *p){
4599 sqlite3_free(p->cds.zFile);
4605 ** Release resources that should be freed at the end of a write
4608 static void zipfileCleanupTransaction(ZipfileTab *pTab){
4609 ZipfileEntry *pEntry;
4610 ZipfileEntry *pNext;
4612 if( pTab->pWriteFd ){
4613 fclose(pTab->pWriteFd);
4616 for(pEntry=pTab->pFirstEntry; pEntry; pEntry=pNext){
4617 pNext = pEntry->pNext;
4618 zipfileEntryFree(pEntry);
4620 pTab->pFirstEntry = 0;
4621 pTab->pLastEntry = 0;
4622 pTab->szCurrent = 0;
4627 ** This method is the destructor for zipfile vtab objects.
4629 static int zipfileDisconnect(sqlite3_vtab *pVtab){
4630 zipfileCleanupTransaction((ZipfileTab*)pVtab);
4631 sqlite3_free(pVtab);
4636 ** Constructor for a new ZipfileCsr object.
4638 static int zipfileOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCsr){
4639 ZipfileTab *pTab = (ZipfileTab*)p;
4641 pCsr = sqlite3_malloc(sizeof(*pCsr));
4642 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
4644 return SQLITE_NOMEM;
4646 memset(pCsr, 0, sizeof(*pCsr));
4647 pCsr->iId = ++pTab->iNextCsrid;
4648 pCsr->pCsrNext = pTab->pCsrList;
4649 pTab->pCsrList = pCsr;
4654 ** Reset a cursor back to the state it was in when first returned
4655 ** by zipfileOpen().
4657 static void zipfileResetCursor(ZipfileCsr *pCsr){
4659 ZipfileEntry *pNext;
4663 fclose(pCsr->pFile);
4665 zipfileEntryFree(pCsr->pCurrent);
4669 for(p=pCsr->pFreeEntry; p; p=pNext){
4671 zipfileEntryFree(p);
4676 ** Destructor for an ZipfileCsr.
4678 static int zipfileClose(sqlite3_vtab_cursor *cur){
4679 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
4680 ZipfileTab *pTab = (ZipfileTab*)(pCsr->base.pVtab);
4682 zipfileResetCursor(pCsr);
4684 /* Remove this cursor from the ZipfileTab.pCsrList list. */
4685 for(pp=&pTab->pCsrList; *pp!=pCsr; pp=&((*pp)->pCsrNext));
4686 *pp = pCsr->pCsrNext;
4693 ** Set the error message for the virtual table associated with cursor
4694 ** pCsr to the results of vprintf(zFmt, ...).
4696 static void zipfileTableErr(ZipfileTab *pTab, const char *zFmt, ...){
4699 sqlite3_free(pTab->base.zErrMsg);
4700 pTab->base.zErrMsg = sqlite3_vmprintf(zFmt, ap);
4703 static void zipfileCursorErr(ZipfileCsr *pCsr, const char *zFmt, ...){
4706 sqlite3_free(pCsr->base.pVtab->zErrMsg);
4707 pCsr->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap);
4712 ** Read nRead bytes of data from offset iOff of file pFile into buffer
4713 ** aRead[]. Return SQLITE_OK if successful, or an SQLite error code
4716 ** If an error does occur, output variable (*pzErrmsg) may be set to point
4717 ** to an English language error message. It is the responsibility of the
4718 ** caller to eventually free this buffer using
4721 static int zipfileReadData(
4722 FILE *pFile, /* Read from this file */
4723 u8 *aRead, /* Read into this buffer */
4724 int nRead, /* Number of bytes to read */
4725 i64 iOff, /* Offset to read from */
4726 char **pzErrmsg /* OUT: Error message (from sqlite3_malloc) */
4729 fseek(pFile, (long)iOff, SEEK_SET);
4730 n = fread(aRead, 1, nRead, pFile);
4731 if( (int)n!=nRead ){
4732 *pzErrmsg = sqlite3_mprintf("error in fread()");
4733 return SQLITE_ERROR;
4738 static int zipfileAppendData(
4744 fseek(pTab->pWriteFd, (long)pTab->szCurrent, SEEK_SET);
4745 n = fwrite(aWrite, 1, nWrite, pTab->pWriteFd);
4746 if( (int)n!=nWrite ){
4747 pTab->base.zErrMsg = sqlite3_mprintf("error in fwrite()");
4748 return SQLITE_ERROR;
4750 pTab->szCurrent += nWrite;
4755 ** Read and return a 16-bit little-endian unsigned integer from buffer aBuf.
4757 static u16 zipfileGetU16(const u8 *aBuf){
4758 return (aBuf[1] << 8) + aBuf[0];
4762 ** Read and return a 32-bit little-endian unsigned integer from buffer aBuf.
4764 static u32 zipfileGetU32(const u8 *aBuf){
4765 return ((u32)(aBuf[3]) << 24)
4766 + ((u32)(aBuf[2]) << 16)
4767 + ((u32)(aBuf[1]) << 8)
4768 + ((u32)(aBuf[0]) << 0);
4772 ** Write a 16-bit little endiate integer into buffer aBuf.
4774 static void zipfilePutU16(u8 *aBuf, u16 val){
4775 aBuf[0] = val & 0xFF;
4776 aBuf[1] = (val>>8) & 0xFF;
4780 ** Write a 32-bit little endiate integer into buffer aBuf.
4782 static void zipfilePutU32(u8 *aBuf, u32 val){
4783 aBuf[0] = val & 0xFF;
4784 aBuf[1] = (val>>8) & 0xFF;
4785 aBuf[2] = (val>>16) & 0xFF;
4786 aBuf[3] = (val>>24) & 0xFF;
4789 #define zipfileRead32(aBuf) ( aBuf+=4, zipfileGetU32(aBuf-4) )
4790 #define zipfileRead16(aBuf) ( aBuf+=2, zipfileGetU16(aBuf-2) )
4792 #define zipfileWrite32(aBuf,val) { zipfilePutU32(aBuf,val); aBuf+=4; }
4793 #define zipfileWrite16(aBuf,val) { zipfilePutU16(aBuf,val); aBuf+=2; }
4796 ** Magic numbers used to read CDS records.
4798 #define ZIPFILE_CDS_NFILE_OFF 28
4799 #define ZIPFILE_CDS_SZCOMPRESSED_OFF 20
4802 ** Decode the CDS record in buffer aBuf into (*pCDS). Return SQLITE_ERROR
4803 ** if the record is not well-formed, or SQLITE_OK otherwise.
4805 static int zipfileReadCDS(u8 *aBuf, ZipfileCDS *pCDS){
4807 u32 sig = zipfileRead32(aRead);
4809 if( sig!=ZIPFILE_SIGNATURE_CDS ){
4812 pCDS->iVersionMadeBy = zipfileRead16(aRead);
4813 pCDS->iVersionExtract = zipfileRead16(aRead);
4814 pCDS->flags = zipfileRead16(aRead);
4815 pCDS->iCompression = zipfileRead16(aRead);
4816 pCDS->mTime = zipfileRead16(aRead);
4817 pCDS->mDate = zipfileRead16(aRead);
4818 pCDS->crc32 = zipfileRead32(aRead);
4819 pCDS->szCompressed = zipfileRead32(aRead);
4820 pCDS->szUncompressed = zipfileRead32(aRead);
4821 assert( aRead==&aBuf[ZIPFILE_CDS_NFILE_OFF] );
4822 pCDS->nFile = zipfileRead16(aRead);
4823 pCDS->nExtra = zipfileRead16(aRead);
4824 pCDS->nComment = zipfileRead16(aRead);
4825 pCDS->iDiskStart = zipfileRead16(aRead);
4826 pCDS->iInternalAttr = zipfileRead16(aRead);
4827 pCDS->iExternalAttr = zipfileRead32(aRead);
4828 pCDS->iOffset = zipfileRead32(aRead);
4829 assert( aRead==&aBuf[ZIPFILE_CDS_FIXED_SZ] );
4836 ** Decode the LFH record in buffer aBuf into (*pLFH). Return SQLITE_ERROR
4837 ** if the record is not well-formed, or SQLITE_OK otherwise.
4839 static int zipfileReadLFH(
4843 u8 *aRead = aBuffer;
4846 u32 sig = zipfileRead32(aRead);
4847 if( sig!=ZIPFILE_SIGNATURE_LFH ){
4850 pLFH->iVersionExtract = zipfileRead16(aRead);
4851 pLFH->flags = zipfileRead16(aRead);
4852 pLFH->iCompression = zipfileRead16(aRead);
4853 pLFH->mTime = zipfileRead16(aRead);
4854 pLFH->mDate = zipfileRead16(aRead);
4855 pLFH->crc32 = zipfileRead32(aRead);
4856 pLFH->szCompressed = zipfileRead32(aRead);
4857 pLFH->szUncompressed = zipfileRead32(aRead);
4858 pLFH->nFile = zipfileRead16(aRead);
4859 pLFH->nExtra = zipfileRead16(aRead);
4866 ** Buffer aExtra (size nExtra bytes) contains zip archive "extra" fields.
4867 ** Scan through this buffer to find an "extra-timestamp" field. If one
4868 ** exists, extract the 32-bit modification-timestamp from it and store
4869 ** the value in output parameter *pmTime.
4871 ** Zero is returned if no extra-timestamp record could be found (and so
4872 ** *pmTime is left unchanged), or non-zero otherwise.
4874 ** The general format of an extra field is:
4876 ** Header ID 2 bytes
4877 ** Data Size 2 bytes
4880 static int zipfileScanExtra(u8 *aExtra, int nExtra, u32 *pmTime){
4883 u8 *pEnd = &aExtra[nExtra];
4886 u16 id = zipfileRead16(p);
4887 u16 nByte = zipfileRead16(p);
4890 case ZIPFILE_EXTRA_TIMESTAMP: {
4892 if( b & 0x01 ){ /* 0x01 -> modtime is present */
4893 *pmTime = zipfileGetU32(&p[1]);
4906 ** Convert the standard MS-DOS timestamp stored in the mTime and mDate
4907 ** fields of the CDS structure passed as the only argument to a 32-bit
4908 ** UNIX seconds-since-the-epoch timestamp. Return the result.
4910 ** "Standard" MS-DOS time format:
4912 ** File modification time:
4913 ** Bits 00-04: seconds divided by 2
4914 ** Bits 05-10: minute
4916 ** File modification date:
4918 ** Bits 05-08: month (1-12)
4919 ** Bits 09-15: years from 1980
4921 ** https://msdn.microsoft.com/en-us/library/9kkf9tah.aspx
4923 static u32 zipfileMtime(ZipfileCDS *pCDS){
4924 int Y = (1980 + ((pCDS->mDate >> 9) & 0x7F));
4925 int M = ((pCDS->mDate >> 5) & 0x0F);
4926 int D = (pCDS->mDate & 0x1F);
4929 int sec = (pCDS->mTime & 0x1F)*2;
4930 int min = (pCDS->mTime >> 5) & 0x3F;
4931 int hr = (pCDS->mTime >> 11) & 0x1F;
4934 /* JD = INT(365.25 * (Y+4716)) + INT(30.6001 * (M+1)) + D + B - 1524.5 */
4936 /* Calculate the JD in seconds for noon on the day in question */
4941 JD = (i64)(24*60*60) * (
4942 (int)(365.25 * (Y + 4716))
4943 + (int)(30.6001 * (M + 1))
4947 /* Correct the JD for the time within the day */
4948 JD += (hr-12) * 3600 + min * 60 + sec;
4950 /* Convert JD to unix timestamp (the JD epoch is 2440587.5) */
4951 return (u32)(JD - (i64)(24405875) * 24*60*6);
4955 ** The opposite of zipfileMtime(). This function populates the mTime and
4956 ** mDate fields of the CDS structure passed as the first argument according
4957 ** to the UNIX timestamp value passed as the second.
4959 static void zipfileMtimeToDos(ZipfileCDS *pCds, u32 mUnixTime){
4960 /* Convert unix timestamp to JD (2440588 is noon on 1/1/1970) */
4961 i64 JD = (i64)2440588 + mUnixTime / (24*60*60);
4967 A = (int)((JD - 1867216.25)/36524.25);
4968 A = (int)(JD + 1 + A - (A/4));
4970 C = (int)((B - 122.1)/365.25);
4971 D = (36525*(C&32767))/100;
4972 E = (int)((B-D)/30.6001);
4974 day = B - D - (int)(30.6001*E);
4975 mon = (E<14 ? E-1 : E-13);
4976 yr = mon>2 ? C-4716 : C-4715;
4978 hr = (mUnixTime % (24*60*60)) / (60*60);
4979 min = (mUnixTime % (60*60)) / 60;
4980 sec = (mUnixTime % 60);
4983 pCds->mDate = (u16)(day + (mon << 5) + ((yr-1980) << 9));
4984 pCds->mTime = (u16)(sec/2 + (min<<5) + (hr<<11));
4986 pCds->mDate = pCds->mTime = 0;
4989 assert( mUnixTime<315507600
4990 || mUnixTime==zipfileMtime(pCds)
4991 || ((mUnixTime % 2) && mUnixTime-1==zipfileMtime(pCds))
4992 /* || (mUnixTime % 2) */
4997 ** If aBlob is not NULL, then it is a pointer to a buffer (nBlob bytes in
4998 ** size) containing an entire zip archive image. Or, if aBlob is NULL,
4999 ** then pFile is a file-handle open on a zip file. In either case, this
5000 ** function creates a ZipfileEntry object based on the zip archive entry
5001 ** for which the CDS record is at offset iOff.
5003 ** If successful, SQLITE_OK is returned and (*ppEntry) set to point to
5004 ** the new object. Otherwise, an SQLite error code is returned and the
5005 ** final value of (*ppEntry) undefined.
5007 static int zipfileGetEntry(
5008 ZipfileTab *pTab, /* Store any error message here */
5009 const u8 *aBlob, /* Pointer to in-memory file image */
5010 int nBlob, /* Size of aBlob[] in bytes */
5011 FILE *pFile, /* If aBlob==0, read from this file */
5012 i64 iOff, /* Offset of CDS record */
5013 ZipfileEntry **ppEntry /* OUT: Pointer to new object */
5016 char **pzErr = &pTab->base.zErrMsg;
5020 aRead = pTab->aBuffer;
5021 rc = zipfileReadData(pFile, aRead, ZIPFILE_CDS_FIXED_SZ, iOff, pzErr);
5023 aRead = (u8*)&aBlob[iOff];
5026 if( rc==SQLITE_OK ){
5027 sqlite3_int64 nAlloc;
5030 int nFile = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF]);
5031 int nExtra = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+2]);
5032 nExtra += zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+4]);
5034 nAlloc = sizeof(ZipfileEntry) + nExtra;
5036 nAlloc += zipfileGetU32(&aRead[ZIPFILE_CDS_SZCOMPRESSED_OFF]);
5039 pNew = (ZipfileEntry*)sqlite3_malloc64(nAlloc);
5043 memset(pNew, 0, sizeof(ZipfileEntry));
5044 rc = zipfileReadCDS(aRead, &pNew->cds);
5045 if( rc!=SQLITE_OK ){
5046 *pzErr = sqlite3_mprintf("failed to read CDS at offset %lld", iOff);
5047 }else if( aBlob==0 ){
5048 rc = zipfileReadData(
5049 pFile, aRead, nExtra+nFile, iOff+ZIPFILE_CDS_FIXED_SZ, pzErr
5052 aRead = (u8*)&aBlob[iOff + ZIPFILE_CDS_FIXED_SZ];
5056 if( rc==SQLITE_OK ){
5057 u32 *pt = &pNew->mUnixTime;
5058 pNew->cds.zFile = sqlite3_mprintf("%.*s", nFile, aRead);
5059 pNew->aExtra = (u8*)&pNew[1];
5060 memcpy(pNew->aExtra, &aRead[nFile], nExtra);
5061 if( pNew->cds.zFile==0 ){
5063 }else if( 0==zipfileScanExtra(&aRead[nFile], pNew->cds.nExtra, pt) ){
5064 pNew->mUnixTime = zipfileMtime(&pNew->cds);
5068 if( rc==SQLITE_OK ){
5069 static const int szFix = ZIPFILE_LFH_FIXED_SZ;
5072 rc = zipfileReadData(pFile, aRead, szFix, pNew->cds.iOffset, pzErr);
5074 aRead = (u8*)&aBlob[pNew->cds.iOffset];
5077 rc = zipfileReadLFH(aRead, &lfh);
5078 if( rc==SQLITE_OK ){
5079 pNew->iDataOff = pNew->cds.iOffset + ZIPFILE_LFH_FIXED_SZ;
5080 pNew->iDataOff += lfh.nFile + lfh.nExtra;
5081 if( aBlob && pNew->cds.szCompressed ){
5082 pNew->aData = &pNew->aExtra[nExtra];
5083 memcpy(pNew->aData, &aBlob[pNew->iDataOff], pNew->cds.szCompressed);
5086 *pzErr = sqlite3_mprintf("failed to read LFH at offset %d",
5087 (int)pNew->cds.iOffset
5092 if( rc!=SQLITE_OK ){
5093 zipfileEntryFree(pNew);
5103 ** Advance an ZipfileCsr to its next row of output.
5105 static int zipfileNext(sqlite3_vtab_cursor *cur){
5106 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5110 i64 iEof = pCsr->eocd.iOffset + pCsr->eocd.nSize;
5111 zipfileEntryFree(pCsr->pCurrent);
5113 if( pCsr->iNextOff>=iEof ){
5116 ZipfileEntry *p = 0;
5117 ZipfileTab *pTab = (ZipfileTab*)(cur->pVtab);
5118 rc = zipfileGetEntry(pTab, 0, 0, pCsr->pFile, pCsr->iNextOff, &p);
5119 if( rc==SQLITE_OK ){
5120 pCsr->iNextOff += ZIPFILE_CDS_FIXED_SZ;
5121 pCsr->iNextOff += (int)p->cds.nExtra + p->cds.nFile + p->cds.nComment;
5127 pCsr->pCurrent = pCsr->pCurrent->pNext;
5129 if( pCsr->pCurrent==0 ){
5138 static void zipfileFree(void *p) {
5143 ** Buffer aIn (size nIn bytes) contains compressed data. Uncompressed, the
5144 ** size is nOut bytes. This function uncompresses the data and sets the
5145 ** return value in context pCtx to the result (a blob).
5147 ** If an error occurs, an error code is left in pCtx instead.
5149 static void zipfileInflate(
5150 sqlite3_context *pCtx, /* Store result here */
5151 const u8 *aIn, /* Compressed data */
5152 int nIn, /* Size of buffer aIn[] in bytes */
5153 int nOut /* Expected output size */
5155 u8 *aRes = sqlite3_malloc(nOut);
5157 sqlite3_result_error_nomem(pCtx);
5161 memset(&str, 0, sizeof(str));
5163 str.next_in = (Byte*)aIn;
5165 str.next_out = (Byte*)aRes;
5166 str.avail_out = nOut;
5168 err = inflateInit2(&str, -15);
5170 zipfileCtxErrorMsg(pCtx, "inflateInit2() failed (%d)", err);
5172 err = inflate(&str, Z_NO_FLUSH);
5173 if( err!=Z_STREAM_END ){
5174 zipfileCtxErrorMsg(pCtx, "inflate() failed (%d)", err);
5176 sqlite3_result_blob(pCtx, aRes, nOut, zipfileFree);
5186 ** Buffer aIn (size nIn bytes) contains uncompressed data. This function
5187 ** compresses it and sets (*ppOut) to point to a buffer containing the
5188 ** compressed data. The caller is responsible for eventually calling
5189 ** sqlite3_free() to release buffer (*ppOut). Before returning, (*pnOut)
5190 ** is set to the size of buffer (*ppOut) in bytes.
5192 ** If no error occurs, SQLITE_OK is returned. Otherwise, an SQLite error
5193 ** code is returned and an error message left in virtual-table handle
5194 ** pTab. The values of (*ppOut) and (*pnOut) are left unchanged in this
5197 static int zipfileDeflate(
5198 const u8 *aIn, int nIn, /* Input */
5199 u8 **ppOut, int *pnOut, /* Output */
5200 char **pzErr /* OUT: Error message */
5203 sqlite3_int64 nAlloc;
5207 memset(&str, 0, sizeof(str));
5208 str.next_in = (Bytef*)aIn;
5210 deflateInit2(&str, 9, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
5212 nAlloc = deflateBound(&str, nIn);
5213 aOut = (u8*)sqlite3_malloc64(nAlloc);
5218 str.next_out = aOut;
5219 str.avail_out = nAlloc;
5220 res = deflate(&str, Z_FINISH);
5221 if( res==Z_STREAM_END ){
5223 *pnOut = (int)str.total_out;
5226 *pzErr = sqlite3_mprintf("zipfile: deflate() error");
5237 ** Return values of columns for the row at which the series_cursor
5238 ** is currently pointing.
5240 static int zipfileColumn(
5241 sqlite3_vtab_cursor *cur, /* The cursor */
5242 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
5243 int i /* Which column to return */
5245 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5246 ZipfileCDS *pCDS = &pCsr->pCurrent->cds;
5250 sqlite3_result_text(ctx, pCDS->zFile, -1, SQLITE_TRANSIENT);
5253 /* TODO: Whether or not the following is correct surely depends on
5254 ** the platform on which the archive was created. */
5255 sqlite3_result_int(ctx, pCDS->iExternalAttr >> 16);
5257 case 2: { /* mtime */
5258 sqlite3_result_int64(ctx, pCsr->pCurrent->mUnixTime);
5262 if( sqlite3_vtab_nochange(ctx)==0 ){
5263 sqlite3_result_int64(ctx, pCDS->szUncompressed);
5267 case 4: /* rawdata */
5268 if( sqlite3_vtab_nochange(ctx) ) break;
5269 case 5: { /* data */
5270 if( i==4 || pCDS->iCompression==0 || pCDS->iCompression==8 ){
5271 int sz = pCDS->szCompressed;
5272 int szFinal = pCDS->szUncompressed;
5276 if( pCsr->pCurrent->aData ){
5277 aBuf = pCsr->pCurrent->aData;
5279 aBuf = aFree = sqlite3_malloc64(sz);
5283 FILE *pFile = pCsr->pFile;
5285 pFile = ((ZipfileTab*)(pCsr->base.pVtab))->pWriteFd;
5287 rc = zipfileReadData(pFile, aBuf, sz, pCsr->pCurrent->iDataOff,
5288 &pCsr->base.pVtab->zErrMsg
5292 if( rc==SQLITE_OK ){
5293 if( i==5 && pCDS->iCompression ){
5294 zipfileInflate(ctx, aBuf, sz, szFinal);
5296 sqlite3_result_blob(ctx, aBuf, sz, SQLITE_TRANSIENT);
5299 sqlite3_free(aFree);
5301 /* Figure out if this is a directory or a zero-sized file. Consider
5302 ** it to be a directory either if the mode suggests so, or if
5303 ** the final character in the name is '/'. */
5304 u32 mode = pCDS->iExternalAttr >> 16;
5305 if( !(mode & S_IFDIR) && pCDS->zFile[pCDS->nFile-1]!='/' ){
5306 sqlite3_result_blob(ctx, "", 0, SQLITE_STATIC);
5312 case 6: /* method */
5313 sqlite3_result_int(ctx, pCDS->iCompression);
5317 sqlite3_result_int64(ctx, pCsr->iId);
5325 ** Return TRUE if the cursor is at EOF.
5327 static int zipfileEof(sqlite3_vtab_cursor *cur){
5328 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5333 ** If aBlob is not NULL, then it points to a buffer nBlob bytes in size
5334 ** containing an entire zip archive image. Or, if aBlob is NULL, then pFile
5335 ** is guaranteed to be a file-handle open on a zip file.
5337 ** This function attempts to locate the EOCD record within the zip archive
5338 ** and populate *pEOCD with the results of decoding it. SQLITE_OK is
5339 ** returned if successful. Otherwise, an SQLite error code is returned and
5340 ** an English language error message may be left in virtual-table pTab.
5342 static int zipfileReadEOCD(
5343 ZipfileTab *pTab, /* Return errors here */
5344 const u8 *aBlob, /* Pointer to in-memory file image */
5345 int nBlob, /* Size of aBlob[] in bytes */
5346 FILE *pFile, /* Read from this file if aBlob==0 */
5347 ZipfileEOCD *pEOCD /* Object to populate */
5349 u8 *aRead = pTab->aBuffer; /* Temporary buffer */
5350 int nRead; /* Bytes to read from file */
5354 i64 iOff; /* Offset to read from */
5355 i64 szFile; /* Total size of file in bytes */
5356 fseek(pFile, 0, SEEK_END);
5357 szFile = (i64)ftell(pFile);
5359 memset(pEOCD, 0, sizeof(ZipfileEOCD));
5362 nRead = (int)(MIN(szFile, ZIPFILE_BUFFER_SIZE));
5363 iOff = szFile - nRead;
5364 rc = zipfileReadData(pFile, aRead, nRead, iOff, &pTab->base.zErrMsg);
5366 nRead = (int)(MIN(nBlob, ZIPFILE_BUFFER_SIZE));
5367 aRead = (u8*)&aBlob[nBlob-nRead];
5370 if( rc==SQLITE_OK ){
5373 /* Scan backwards looking for the signature bytes */
5374 for(i=nRead-20; i>=0; i--){
5375 if( aRead[i]==0x50 && aRead[i+1]==0x4b
5376 && aRead[i+2]==0x05 && aRead[i+3]==0x06
5382 pTab->base.zErrMsg = sqlite3_mprintf(
5383 "cannot find end of central directory record"
5385 return SQLITE_ERROR;
5389 pEOCD->iDisk = zipfileRead16(aRead);
5390 pEOCD->iFirstDisk = zipfileRead16(aRead);
5391 pEOCD->nEntry = zipfileRead16(aRead);
5392 pEOCD->nEntryTotal = zipfileRead16(aRead);
5393 pEOCD->nSize = zipfileRead32(aRead);
5394 pEOCD->iOffset = zipfileRead32(aRead);
5401 ** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry
5402 ** and ends with pLastEntry. If argument pBefore is NULL, then pNew is added
5403 ** to the end of the list. Otherwise, it is added to the list immediately
5404 ** before pBefore (which is guaranteed to be a part of said list).
5406 static void zipfileAddEntry(
5408 ZipfileEntry *pBefore,
5411 assert( (pTab->pFirstEntry==0)==(pTab->pLastEntry==0) );
5412 assert( pNew->pNext==0 );
5414 if( pTab->pFirstEntry==0 ){
5415 pTab->pFirstEntry = pTab->pLastEntry = pNew;
5417 assert( pTab->pLastEntry->pNext==0 );
5418 pTab->pLastEntry->pNext = pNew;
5419 pTab->pLastEntry = pNew;
5423 for(pp=&pTab->pFirstEntry; *pp!=pBefore; pp=&((*pp)->pNext));
5424 pNew->pNext = pBefore;
5429 static int zipfileLoadDirectory(ZipfileTab *pTab, const u8 *aBlob, int nBlob){
5435 rc = zipfileReadEOCD(pTab, aBlob, nBlob, pTab->pWriteFd, &eocd);
5436 iOff = eocd.iOffset;
5437 for(i=0; rc==SQLITE_OK && i<eocd.nEntry; i++){
5438 ZipfileEntry *pNew = 0;
5439 rc = zipfileGetEntry(pTab, aBlob, nBlob, pTab->pWriteFd, iOff, &pNew);
5441 if( rc==SQLITE_OK ){
5442 zipfileAddEntry(pTab, 0, pNew);
5443 iOff += ZIPFILE_CDS_FIXED_SZ;
5444 iOff += (int)pNew->cds.nExtra + pNew->cds.nFile + pNew->cds.nComment;
5451 ** xFilter callback.
5453 static int zipfileFilter(
5454 sqlite3_vtab_cursor *cur,
5455 int idxNum, const char *idxStr,
5456 int argc, sqlite3_value **argv
5458 ZipfileTab *pTab = (ZipfileTab*)cur->pVtab;
5459 ZipfileCsr *pCsr = (ZipfileCsr*)cur;
5460 const char *zFile = 0; /* Zip file to scan */
5461 int rc = SQLITE_OK; /* Return Code */
5462 int bInMemory = 0; /* True for an in-memory zipfile */
5464 zipfileResetCursor(pCsr);
5467 zFile = pTab->zFile;
5468 }else if( idxNum==0 ){
5469 zipfileCursorErr(pCsr, "zipfile() function requires an argument");
5470 return SQLITE_ERROR;
5471 }else if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){
5472 const u8 *aBlob = (const u8*)sqlite3_value_blob(argv[0]);
5473 int nBlob = sqlite3_value_bytes(argv[0]);
5474 assert( pTab->pFirstEntry==0 );
5475 rc = zipfileLoadDirectory(pTab, aBlob, nBlob);
5476 pCsr->pFreeEntry = pTab->pFirstEntry;
5477 pTab->pFirstEntry = pTab->pLastEntry = 0;
5478 if( rc!=SQLITE_OK ) return rc;
5481 zFile = (const char*)sqlite3_value_text(argv[0]);
5484 if( 0==pTab->pWriteFd && 0==bInMemory ){
5485 pCsr->pFile = fopen(zFile, "rb");
5486 if( pCsr->pFile==0 ){
5487 zipfileCursorErr(pCsr, "cannot open file: %s", zFile);
5490 rc = zipfileReadEOCD(pTab, 0, 0, pCsr->pFile, &pCsr->eocd);
5491 if( rc==SQLITE_OK ){
5492 if( pCsr->eocd.nEntry==0 ){
5495 pCsr->iNextOff = pCsr->eocd.iOffset;
5496 rc = zipfileNext(cur);
5502 pCsr->pCurrent = pCsr->pFreeEntry ? pCsr->pFreeEntry : pTab->pFirstEntry;
5503 rc = zipfileNext(cur);
5510 ** xBestIndex callback.
5512 static int zipfileBestIndex(
5514 sqlite3_index_info *pIdxInfo
5520 for(i=0; i<pIdxInfo->nConstraint; i++){
5521 const struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i];
5522 if( pCons->iColumn!=ZIPFILE_F_COLUMN_IDX ) continue;
5523 if( pCons->usable==0 ){
5525 }else if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){
5529 pIdxInfo->estimatedCost = 1000.0;
5531 pIdxInfo->aConstraintUsage[idx].argvIndex = 1;
5532 pIdxInfo->aConstraintUsage[idx].omit = 1;
5533 pIdxInfo->idxNum = 1;
5534 }else if( unusable ){
5535 return SQLITE_CONSTRAINT;
5540 static ZipfileEntry *zipfileNewEntry(const char *zPath){
5542 pNew = sqlite3_malloc(sizeof(ZipfileEntry));
5544 memset(pNew, 0, sizeof(ZipfileEntry));
5545 pNew->cds.zFile = sqlite3_mprintf("%s", zPath);
5546 if( pNew->cds.zFile==0 ){
5554 static int zipfileSerializeLFH(ZipfileEntry *pEntry, u8 *aBuf){
5555 ZipfileCDS *pCds = &pEntry->cds;
5560 /* Write the LFH itself */
5561 zipfileWrite32(a, ZIPFILE_SIGNATURE_LFH);
5562 zipfileWrite16(a, pCds->iVersionExtract);
5563 zipfileWrite16(a, pCds->flags);
5564 zipfileWrite16(a, pCds->iCompression);
5565 zipfileWrite16(a, pCds->mTime);
5566 zipfileWrite16(a, pCds->mDate);
5567 zipfileWrite32(a, pCds->crc32);
5568 zipfileWrite32(a, pCds->szCompressed);
5569 zipfileWrite32(a, pCds->szUncompressed);
5570 zipfileWrite16(a, (u16)pCds->nFile);
5571 zipfileWrite16(a, pCds->nExtra);
5572 assert( a==&aBuf[ZIPFILE_LFH_FIXED_SZ] );
5574 /* Add the file name */
5575 memcpy(a, pCds->zFile, (int)pCds->nFile);
5576 a += (int)pCds->nFile;
5578 /* The "extra" data */
5579 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP);
5580 zipfileWrite16(a, 5);
5582 zipfileWrite32(a, pEntry->mUnixTime);
5587 static int zipfileAppendEntry(
5589 ZipfileEntry *pEntry,
5593 u8 *aBuf = pTab->aBuffer;
5597 nBuf = zipfileSerializeLFH(pEntry, aBuf);
5598 rc = zipfileAppendData(pTab, aBuf, nBuf);
5599 if( rc==SQLITE_OK ){
5600 pEntry->iDataOff = pTab->szCurrent;
5601 rc = zipfileAppendData(pTab, pData, nData);
5607 static int zipfileGetMode(
5608 sqlite3_value *pVal,
5609 int bIsDir, /* If true, default to directory */
5610 u32 *pMode, /* OUT: Mode value */
5611 char **pzErr /* OUT: Error message */
5613 const char *z = (const char*)sqlite3_value_text(pVal);
5616 mode = (bIsDir ? (S_IFDIR + 0755) : (S_IFREG + 0644));
5617 }else if( z[0]>='0' && z[0]<='9' ){
5618 mode = (unsigned int)sqlite3_value_int(pVal);
5620 const char zTemplate[11] = "-rwxrwxrwx";
5622 if( strlen(z)!=10 ) goto parse_error;
5624 case '-': mode |= S_IFREG; break;
5625 case 'd': mode |= S_IFDIR; break;
5626 case 'l': mode |= S_IFLNK; break;
5627 default: goto parse_error;
5629 for(i=1; i<10; i++){
5630 if( z[i]==zTemplate[i] ) mode |= 1 << (9-i);
5631 else if( z[i]!='-' ) goto parse_error;
5634 if( ((mode & S_IFDIR)==0)==bIsDir ){
5635 /* The "mode" attribute is a directory, but data has been specified.
5636 ** Or vice-versa - no data but "mode" is a file or symlink. */
5637 *pzErr = sqlite3_mprintf("zipfile: mode does not match data");
5638 return SQLITE_CONSTRAINT;
5644 *pzErr = sqlite3_mprintf("zipfile: parse error in mode: %s", z);
5645 return SQLITE_ERROR;
5649 ** Both (const char*) arguments point to nul-terminated strings. Argument
5650 ** nB is the value of strlen(zB). This function returns 0 if the strings are
5651 ** identical, ignoring any trailing '/' character in either path. */
5652 static int zipfileComparePath(const char *zA, const char *zB, int nB){
5653 int nA = (int)strlen(zA);
5654 if( nA>0 && zA[nA-1]=='/' ) nA--;
5655 if( nB>0 && zB[nB-1]=='/' ) nB--;
5656 if( nA==nB && memcmp(zA, zB, nA)==0 ) return 0;
5660 static int zipfileBegin(sqlite3_vtab *pVtab){
5661 ZipfileTab *pTab = (ZipfileTab*)pVtab;
5664 assert( pTab->pWriteFd==0 );
5665 if( pTab->zFile==0 || pTab->zFile[0]==0 ){
5666 pTab->base.zErrMsg = sqlite3_mprintf("zipfile: missing filename");
5667 return SQLITE_ERROR;
5670 /* Open a write fd on the file. Also load the entire central directory
5671 ** structure into memory. During the transaction any new file data is
5672 ** appended to the archive file, but the central directory is accumulated
5673 ** in main-memory until the transaction is committed. */
5674 pTab->pWriteFd = fopen(pTab->zFile, "ab+");
5675 if( pTab->pWriteFd==0 ){
5676 pTab->base.zErrMsg = sqlite3_mprintf(
5677 "zipfile: failed to open file %s for writing", pTab->zFile
5681 fseek(pTab->pWriteFd, 0, SEEK_END);
5682 pTab->szCurrent = pTab->szOrig = (i64)ftell(pTab->pWriteFd);
5683 rc = zipfileLoadDirectory(pTab, 0, 0);
5686 if( rc!=SQLITE_OK ){
5687 zipfileCleanupTransaction(pTab);
5694 ** Return the current time as a 32-bit timestamp in UNIX epoch format (like
5697 static u32 zipfileTime(void){
5698 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
5700 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
5702 pVfs->xCurrentTimeInt64(pVfs, &ms);
5703 ret = (u32)((ms/1000) - ((i64)24405875 * 8640));
5706 pVfs->xCurrentTime(pVfs, &day);
5707 ret = (u32)((day - 2440587.5) * 86400);
5713 ** Return a 32-bit timestamp in UNIX epoch format.
5715 ** If the value passed as the only argument is either NULL or an SQL NULL,
5716 ** return the current time. Otherwise, return the value stored in (*pVal)
5717 ** cast to a 32-bit unsigned integer.
5719 static u32 zipfileGetTime(sqlite3_value *pVal){
5720 if( pVal==0 || sqlite3_value_type(pVal)==SQLITE_NULL ){
5721 return zipfileTime();
5723 return (u32)sqlite3_value_int64(pVal);
5727 ** Unless it is NULL, entry pOld is currently part of the pTab->pFirstEntry
5728 ** linked list. Remove it from the list and free the object.
5730 static void zipfileRemoveEntryFromList(ZipfileTab *pTab, ZipfileEntry *pOld){
5733 for(pp=&pTab->pFirstEntry; (*pp)!=pOld; pp=&((*pp)->pNext));
5735 zipfileEntryFree(pOld);
5742 static int zipfileUpdate(
5743 sqlite3_vtab *pVtab,
5745 sqlite3_value **apVal,
5746 sqlite_int64 *pRowid
5748 ZipfileTab *pTab = (ZipfileTab*)pVtab;
5749 int rc = SQLITE_OK; /* Return Code */
5750 ZipfileEntry *pNew = 0; /* New in-memory CDS entry */
5752 u32 mode = 0; /* Mode for new entry */
5753 u32 mTime = 0; /* Modification time for new entry */
5754 i64 sz = 0; /* Uncompressed size */
5755 const char *zPath = 0; /* Path for new entry */
5756 int nPath = 0; /* strlen(zPath) */
5757 const u8 *pData = 0; /* Pointer to buffer containing content */
5758 int nData = 0; /* Size of pData buffer in bytes */
5759 int iMethod = 0; /* Compression method for new entry */
5760 u8 *pFree = 0; /* Free this */
5761 char *zFree = 0; /* Also free this */
5762 ZipfileEntry *pOld = 0;
5763 ZipfileEntry *pOld2 = 0;
5764 int bUpdate = 0; /* True for an update that modifies "name" */
5768 if( pTab->pWriteFd==0 ){
5769 rc = zipfileBegin(pVtab);
5770 if( rc!=SQLITE_OK ) return rc;
5773 /* If this is a DELETE or UPDATE, find the archive entry to delete. */
5774 if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){
5775 const char *zDelete = (const char*)sqlite3_value_text(apVal[0]);
5776 int nDelete = (int)strlen(zDelete);
5778 const char *zUpdate = (const char*)sqlite3_value_text(apVal[1]);
5779 if( zUpdate && zipfileComparePath(zUpdate, zDelete, nDelete)!=0 ){
5783 for(pOld=pTab->pFirstEntry; 1; pOld=pOld->pNext){
5784 if( zipfileComparePath(pOld->cds.zFile, zDelete, nDelete)==0 ){
5787 assert( pOld->pNext );
5792 /* Check that "sz" and "rawdata" are both NULL: */
5793 if( sqlite3_value_type(apVal[5])!=SQLITE_NULL ){
5794 zipfileTableErr(pTab, "sz must be NULL");
5795 rc = SQLITE_CONSTRAINT;
5797 if( sqlite3_value_type(apVal[6])!=SQLITE_NULL ){
5798 zipfileTableErr(pTab, "rawdata must be NULL");
5799 rc = SQLITE_CONSTRAINT;
5802 if( rc==SQLITE_OK ){
5803 if( sqlite3_value_type(apVal[7])==SQLITE_NULL ){
5804 /* data=NULL. A directory */
5807 /* Value specified for "data", and possibly "method". This must be
5808 ** a regular file or a symlink. */
5809 const u8 *aIn = sqlite3_value_blob(apVal[7]);
5810 int nIn = sqlite3_value_bytes(apVal[7]);
5811 int bAuto = sqlite3_value_type(apVal[8])==SQLITE_NULL;
5813 iMethod = sqlite3_value_int(apVal[8]);
5817 if( iMethod!=0 && iMethod!=8 ){
5818 zipfileTableErr(pTab, "unknown compression method: %d", iMethod);
5819 rc = SQLITE_CONSTRAINT;
5821 if( bAuto || iMethod ){
5823 rc = zipfileDeflate(aIn, nIn, &pFree, &nCmp, &pTab->base.zErrMsg);
5824 if( rc==SQLITE_OK ){
5825 if( iMethod || nCmp<nIn ){
5832 iCrc32 = crc32(0, aIn, nIn);
5837 if( rc==SQLITE_OK ){
5838 rc = zipfileGetMode(apVal[3], bIsDir, &mode, &pTab->base.zErrMsg);
5841 if( rc==SQLITE_OK ){
5842 zPath = (const char*)sqlite3_value_text(apVal[2]);
5843 if( zPath==0 ) zPath = "";
5844 nPath = (int)strlen(zPath);
5845 mTime = zipfileGetTime(apVal[4]);
5848 if( rc==SQLITE_OK && bIsDir ){
5849 /* For a directory, check that the last character in the path is a
5850 ** '/'. This appears to be required for compatibility with info-zip
5851 ** (the unzip command on unix). It does not create directories
5853 if( nPath<=0 || zPath[nPath-1]!='/' ){
5854 zFree = sqlite3_mprintf("%s/", zPath);
5855 zPath = (const char*)zFree;
5860 nPath = (int)strlen(zPath);
5865 /* Check that we're not inserting a duplicate entry -OR- updating an
5866 ** entry with a path, thereby making it into a duplicate. */
5867 if( (pOld==0 || bUpdate) && rc==SQLITE_OK ){
5869 for(p=pTab->pFirstEntry; p; p=p->pNext){
5870 if( zipfileComparePath(p->cds.zFile, zPath, nPath)==0 ){
5871 switch( sqlite3_vtab_on_conflict(pTab->db) ){
5872 case SQLITE_IGNORE: {
5873 goto zipfile_update_done;
5875 case SQLITE_REPLACE: {
5880 zipfileTableErr(pTab, "duplicate name: \"%s\"", zPath);
5881 rc = SQLITE_CONSTRAINT;
5890 if( rc==SQLITE_OK ){
5891 /* Create the new CDS record. */
5892 pNew = zipfileNewEntry(zPath);
5896 pNew->cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY;
5897 pNew->cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED;
5898 pNew->cds.flags = ZIPFILE_NEWENTRY_FLAGS;
5899 pNew->cds.iCompression = (u16)iMethod;
5900 zipfileMtimeToDos(&pNew->cds, mTime);
5901 pNew->cds.crc32 = iCrc32;
5902 pNew->cds.szCompressed = nData;
5903 pNew->cds.szUncompressed = (u32)sz;
5904 pNew->cds.iExternalAttr = (mode<<16);
5905 pNew->cds.iOffset = (u32)pTab->szCurrent;
5906 pNew->cds.nFile = (u16)nPath;
5907 pNew->mUnixTime = (u32)mTime;
5908 rc = zipfileAppendEntry(pTab, pNew, pData, nData);
5909 zipfileAddEntry(pTab, pOld, pNew);
5914 if( rc==SQLITE_OK && (pOld || pOld2) ){
5916 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){
5917 if( pCsr->pCurrent && (pCsr->pCurrent==pOld || pCsr->pCurrent==pOld2) ){
5918 pCsr->pCurrent = pCsr->pCurrent->pNext;
5923 zipfileRemoveEntryFromList(pTab, pOld);
5924 zipfileRemoveEntryFromList(pTab, pOld2);
5927 zipfile_update_done:
5928 sqlite3_free(pFree);
5929 sqlite3_free(zFree);
5933 static int zipfileSerializeEOCD(ZipfileEOCD *p, u8 *aBuf){
5935 zipfileWrite32(a, ZIPFILE_SIGNATURE_EOCD);
5936 zipfileWrite16(a, p->iDisk);
5937 zipfileWrite16(a, p->iFirstDisk);
5938 zipfileWrite16(a, p->nEntry);
5939 zipfileWrite16(a, p->nEntryTotal);
5940 zipfileWrite32(a, p->nSize);
5941 zipfileWrite32(a, p->iOffset);
5942 zipfileWrite16(a, 0); /* Size of trailing comment in bytes*/
5947 static int zipfileAppendEOCD(ZipfileTab *pTab, ZipfileEOCD *p){
5948 int nBuf = zipfileSerializeEOCD(p, pTab->aBuffer);
5949 assert( nBuf==ZIPFILE_EOCD_FIXED_SZ );
5950 return zipfileAppendData(pTab, pTab->aBuffer, nBuf);
5954 ** Serialize the CDS structure into buffer aBuf[]. Return the number
5955 ** of bytes written.
5957 static int zipfileSerializeCDS(ZipfileEntry *pEntry, u8 *aBuf){
5959 ZipfileCDS *pCDS = &pEntry->cds;
5961 if( pEntry->aExtra==0 ){
5965 zipfileWrite32(a, ZIPFILE_SIGNATURE_CDS);
5966 zipfileWrite16(a, pCDS->iVersionMadeBy);
5967 zipfileWrite16(a, pCDS->iVersionExtract);
5968 zipfileWrite16(a, pCDS->flags);
5969 zipfileWrite16(a, pCDS->iCompression);
5970 zipfileWrite16(a, pCDS->mTime);
5971 zipfileWrite16(a, pCDS->mDate);
5972 zipfileWrite32(a, pCDS->crc32);
5973 zipfileWrite32(a, pCDS->szCompressed);
5974 zipfileWrite32(a, pCDS->szUncompressed);
5975 assert( a==&aBuf[ZIPFILE_CDS_NFILE_OFF] );
5976 zipfileWrite16(a, pCDS->nFile);
5977 zipfileWrite16(a, pCDS->nExtra);
5978 zipfileWrite16(a, pCDS->nComment);
5979 zipfileWrite16(a, pCDS->iDiskStart);
5980 zipfileWrite16(a, pCDS->iInternalAttr);
5981 zipfileWrite32(a, pCDS->iExternalAttr);
5982 zipfileWrite32(a, pCDS->iOffset);
5984 memcpy(a, pCDS->zFile, pCDS->nFile);
5987 if( pEntry->aExtra ){
5988 int n = (int)pCDS->nExtra + (int)pCDS->nComment;
5989 memcpy(a, pEntry->aExtra, n);
5992 assert( pCDS->nExtra==9 );
5993 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP);
5994 zipfileWrite16(a, 5);
5996 zipfileWrite32(a, pEntry->mUnixTime);
6002 static int zipfileCommit(sqlite3_vtab *pVtab){
6003 ZipfileTab *pTab = (ZipfileTab*)pVtab;
6005 if( pTab->pWriteFd ){
6006 i64 iOffset = pTab->szCurrent;
6011 /* Write out all entries */
6012 for(p=pTab->pFirstEntry; rc==SQLITE_OK && p; p=p->pNext){
6013 int n = zipfileSerializeCDS(p, pTab->aBuffer);
6014 rc = zipfileAppendData(pTab, pTab->aBuffer, n);
6018 /* Write out the EOCD record */
6020 eocd.iFirstDisk = 0;
6021 eocd.nEntry = (u16)nEntry;
6022 eocd.nEntryTotal = (u16)nEntry;
6023 eocd.nSize = (u32)(pTab->szCurrent - iOffset);
6024 eocd.iOffset = (u32)iOffset;
6025 rc = zipfileAppendEOCD(pTab, &eocd);
6027 zipfileCleanupTransaction(pTab);
6032 static int zipfileRollback(sqlite3_vtab *pVtab){
6033 return zipfileCommit(pVtab);
6036 static ZipfileCsr *zipfileFindCursor(ZipfileTab *pTab, i64 iId){
6038 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){
6039 if( iId==pCsr->iId ) break;
6044 static void zipfileFunctionCds(
6045 sqlite3_context *context,
6047 sqlite3_value **argv
6050 ZipfileTab *pTab = (ZipfileTab*)sqlite3_user_data(context);
6053 pCsr = zipfileFindCursor(pTab, sqlite3_value_int64(argv[0]));
6055 ZipfileCDS *p = &pCsr->pCurrent->cds;
6056 char *zRes = sqlite3_mprintf("{"
6057 "\"version-made-by\" : %u, "
6058 "\"version-to-extract\" : %u, "
6060 "\"compression\" : %u, "
6064 "\"compressed-size\" : %u, "
6065 "\"uncompressed-size\" : %u, "
6066 "\"file-name-length\" : %u, "
6067 "\"extra-field-length\" : %u, "
6068 "\"file-comment-length\" : %u, "
6069 "\"disk-number-start\" : %u, "
6070 "\"internal-attr\" : %u, "
6071 "\"external-attr\" : %u, "
6072 "\"offset\" : %u }",
6073 (u32)p->iVersionMadeBy, (u32)p->iVersionExtract,
6074 (u32)p->flags, (u32)p->iCompression,
6075 (u32)p->mTime, (u32)p->mDate,
6076 (u32)p->crc32, (u32)p->szCompressed,
6077 (u32)p->szUncompressed, (u32)p->nFile,
6078 (u32)p->nExtra, (u32)p->nComment,
6079 (u32)p->iDiskStart, (u32)p->iInternalAttr,
6080 (u32)p->iExternalAttr, (u32)p->iOffset
6084 sqlite3_result_error_nomem(context);
6086 sqlite3_result_text(context, zRes, -1, SQLITE_TRANSIENT);
6093 ** xFindFunction method.
6095 static int zipfileFindFunction(
6096 sqlite3_vtab *pVtab, /* Virtual table handle */
6097 int nArg, /* Number of SQL function arguments */
6098 const char *zName, /* Name of SQL function */
6099 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
6100 void **ppArg /* OUT: User data for *pxFunc */
6102 if( sqlite3_stricmp("zipfile_cds", zName)==0 ){
6103 *pxFunc = zipfileFunctionCds;
6104 *ppArg = (void*)pVtab;
6110 typedef struct ZipfileBuffer ZipfileBuffer;
6111 struct ZipfileBuffer {
6112 u8 *a; /* Pointer to buffer */
6113 int n; /* Size of buffer in bytes */
6114 int nAlloc; /* Byte allocated at a[] */
6117 typedef struct ZipfileCtx ZipfileCtx;
6124 static int zipfileBufferGrow(ZipfileBuffer *pBuf, int nByte){
6125 if( pBuf->n+nByte>pBuf->nAlloc ){
6127 sqlite3_int64 nNew = pBuf->n ? pBuf->n*2 : 512;
6128 int nReq = pBuf->n + nByte;
6130 while( nNew<nReq ) nNew = nNew*2;
6131 aNew = sqlite3_realloc64(pBuf->a, nNew);
6132 if( aNew==0 ) return SQLITE_NOMEM;
6134 pBuf->nAlloc = (int)nNew;
6140 ** xStep() callback for the zipfile() aggregate. This can be called in
6141 ** any of the following ways:
6143 ** SELECT zipfile(name,data) ...
6144 ** SELECT zipfile(name,mode,mtime,data) ...
6145 ** SELECT zipfile(name,mode,mtime,data,method) ...
6147 void zipfileStep(sqlite3_context *pCtx, int nVal, sqlite3_value **apVal){
6148 ZipfileCtx *p; /* Aggregate function context */
6149 ZipfileEntry e; /* New entry to add to zip archive */
6151 sqlite3_value *pName = 0;
6152 sqlite3_value *pMode = 0;
6153 sqlite3_value *pMtime = 0;
6154 sqlite3_value *pData = 0;
6155 sqlite3_value *pMethod = 0;
6162 int iMethod = -1; /* Compression method to use (0 or 8) */
6164 const u8 *aData = 0; /* Possibly compressed data for new entry */
6165 int nData = 0; /* Size of aData[] in bytes */
6166 int szUncompressed = 0; /* Size of data before compression */
6167 u8 *aFree = 0; /* Free this before returning */
6168 u32 iCrc32 = 0; /* crc32 of uncompressed data */
6170 char *zName = 0; /* Path (name) of new entry */
6171 int nName = 0; /* Size of zName in bytes */
6172 char *zFree = 0; /* Free this before returning */
6175 memset(&e, 0, sizeof(e));
6176 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx));
6179 /* Martial the arguments into stack variables */
6180 if( nVal!=2 && nVal!=4 && nVal!=5 ){
6181 zErr = sqlite3_mprintf("wrong number of arguments to function zipfile()");
6183 goto zipfile_step_out;
6197 /* Check that the 'name' parameter looks ok. */
6198 zName = (char*)sqlite3_value_text(pName);
6199 nName = sqlite3_value_bytes(pName);
6201 zErr = sqlite3_mprintf("first argument to zipfile() must be non-NULL");
6203 goto zipfile_step_out;
6206 /* Inspect the 'method' parameter. This must be either 0 (store), 8 (use
6207 ** deflate compression) or NULL (choose automatically). */
6208 if( pMethod && SQLITE_NULL!=sqlite3_value_type(pMethod) ){
6209 iMethod = (int)sqlite3_value_int64(pMethod);
6210 if( iMethod!=0 && iMethod!=8 ){
6211 zErr = sqlite3_mprintf("illegal method value: %d", iMethod);
6213 goto zipfile_step_out;
6217 /* Now inspect the data. If this is NULL, then the new entry must be a
6218 ** directory. Otherwise, figure out whether or not the data should
6219 ** be deflated or simply stored in the zip archive. */
6220 if( sqlite3_value_type(pData)==SQLITE_NULL ){
6224 aData = sqlite3_value_blob(pData);
6225 szUncompressed = nData = sqlite3_value_bytes(pData);
6226 iCrc32 = crc32(0, aData, nData);
6227 if( iMethod<0 || iMethod==8 ){
6229 rc = zipfileDeflate(aData, nData, &aFree, &nOut, &zErr);
6230 if( rc!=SQLITE_OK ){
6231 goto zipfile_step_out;
6233 if( iMethod==8 || nOut<nData ){
6243 /* Decode the "mode" argument. */
6244 rc = zipfileGetMode(pMode, bIsDir, &mode, &zErr);
6245 if( rc ) goto zipfile_step_out;
6247 /* Decode the "mtime" argument. */
6248 e.mUnixTime = zipfileGetTime(pMtime);
6250 /* If this is a directory entry, ensure that there is exactly one '/'
6251 ** at the end of the path. Or, if this is not a directory and the path
6252 ** ends in '/' it is an error. */
6254 if( nName>0 && zName[nName-1]=='/' ){
6255 zErr = sqlite3_mprintf("non-directory name must not end with /");
6257 goto zipfile_step_out;
6260 if( nName==0 || zName[nName-1]!='/' ){
6261 zName = zFree = sqlite3_mprintf("%s/", zName);
6264 goto zipfile_step_out;
6266 nName = (int)strlen(zName);
6268 while( nName>1 && zName[nName-2]=='/' ) nName--;
6272 /* Assemble the ZipfileEntry object for the new zip archive entry */
6273 e.cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY;
6274 e.cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED;
6275 e.cds.flags = ZIPFILE_NEWENTRY_FLAGS;
6276 e.cds.iCompression = (u16)iMethod;
6277 zipfileMtimeToDos(&e.cds, (u32)e.mUnixTime);
6278 e.cds.crc32 = iCrc32;
6279 e.cds.szCompressed = nData;
6280 e.cds.szUncompressed = szUncompressed;
6281 e.cds.iExternalAttr = (mode<<16);
6282 e.cds.iOffset = p->body.n;
6283 e.cds.nFile = (u16)nName;
6284 e.cds.zFile = zName;
6286 /* Append the LFH to the body of the new archive */
6287 nByte = ZIPFILE_LFH_FIXED_SZ + e.cds.nFile + 9;
6288 if( (rc = zipfileBufferGrow(&p->body, nByte)) ) goto zipfile_step_out;
6289 p->body.n += zipfileSerializeLFH(&e, &p->body.a[p->body.n]);
6291 /* Append the data to the body of the new archive */
6293 if( (rc = zipfileBufferGrow(&p->body, nData)) ) goto zipfile_step_out;
6294 memcpy(&p->body.a[p->body.n], aData, nData);
6298 /* Append the CDS record to the directory of the new archive */
6299 nByte = ZIPFILE_CDS_FIXED_SZ + e.cds.nFile + 9;
6300 if( (rc = zipfileBufferGrow(&p->cds, nByte)) ) goto zipfile_step_out;
6301 p->cds.n += zipfileSerializeCDS(&e, &p->cds.a[p->cds.n]);
6303 /* Increment the count of entries in the archive */
6307 sqlite3_free(aFree);
6308 sqlite3_free(zFree);
6311 sqlite3_result_error(pCtx, zErr, -1);
6313 sqlite3_result_error_code(pCtx, rc);
6320 ** xFinalize() callback for zipfile aggregate function.
6322 void zipfileFinal(sqlite3_context *pCtx){
6328 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx));
6331 memset(&eocd, 0, sizeof(eocd));
6332 eocd.nEntry = (u16)p->nEntry;
6333 eocd.nEntryTotal = (u16)p->nEntry;
6334 eocd.nSize = p->cds.n;
6335 eocd.iOffset = p->body.n;
6337 nZip = p->body.n + p->cds.n + ZIPFILE_EOCD_FIXED_SZ;
6338 aZip = (u8*)sqlite3_malloc64(nZip);
6340 sqlite3_result_error_nomem(pCtx);
6342 memcpy(aZip, p->body.a, p->body.n);
6343 memcpy(&aZip[p->body.n], p->cds.a, p->cds.n);
6344 zipfileSerializeEOCD(&eocd, &aZip[p->body.n + p->cds.n]);
6345 sqlite3_result_blob(pCtx, aZip, (int)nZip, zipfileFree);
6349 sqlite3_free(p->body.a);
6350 sqlite3_free(p->cds.a);
6355 ** Register the "zipfile" virtual table.
6357 static int zipfileRegister(sqlite3 *db){
6358 static sqlite3_module zipfileModule = {
6360 zipfileConnect, /* xCreate */
6361 zipfileConnect, /* xConnect */
6362 zipfileBestIndex, /* xBestIndex */
6363 zipfileDisconnect, /* xDisconnect */
6364 zipfileDisconnect, /* xDestroy */
6365 zipfileOpen, /* xOpen - open a cursor */
6366 zipfileClose, /* xClose - close a cursor */
6367 zipfileFilter, /* xFilter - configure scan constraints */
6368 zipfileNext, /* xNext - advance a cursor */
6369 zipfileEof, /* xEof - check for end of scan */
6370 zipfileColumn, /* xColumn - read data */
6371 0, /* xRowid - read data */
6372 zipfileUpdate, /* xUpdate */
6373 zipfileBegin, /* xBegin */
6375 zipfileCommit, /* xCommit */
6376 zipfileRollback, /* xRollback */
6377 zipfileFindFunction, /* xFindMethod */
6381 int rc = sqlite3_create_module(db, "zipfile" , &zipfileModule, 0);
6382 if( rc==SQLITE_OK ) rc = sqlite3_overload_function(db, "zipfile_cds", -1);
6383 if( rc==SQLITE_OK ){
6384 rc = sqlite3_create_function(db, "zipfile", -1, SQLITE_UTF8, 0, 0,
6385 zipfileStep, zipfileFinal
6390 #else /* SQLITE_OMIT_VIRTUALTABLE */
6391 # define zipfileRegister(x) SQLITE_OK
6397 int sqlite3_zipfile_init(
6400 const sqlite3_api_routines *pApi
6402 SQLITE_EXTENSION_INIT2(pApi);
6403 (void)pzErrMsg; /* Unused parameter */
6404 return zipfileRegister(db);
6407 /************************* End ../ext/misc/zipfile.c ********************/
6408 /************************* Begin ../ext/misc/sqlar.c ******************/
6412 ** The author disclaims copyright to this source code. In place of
6413 ** a legal notice, here is a blessing:
6415 ** May you do good and not evil.
6416 ** May you find forgiveness for yourself and forgive others.
6417 ** May you share freely, never taking more than you give.
6419 ******************************************************************************
6421 ** Utility functions sqlar_compress() and sqlar_uncompress(). Useful
6422 ** for working with sqlar archives and used by the shell tool's built-in
6425 /* #include "sqlite3ext.h" */
6426 SQLITE_EXTENSION_INIT1
6430 ** Implementation of the "sqlar_compress(X)" SQL function.
6432 ** If the type of X is SQLITE_BLOB, and compressing that blob using
6433 ** zlib utility function compress() yields a smaller blob, return the
6434 ** compressed blob. Otherwise, return a copy of X.
6436 ** SQLar uses the "zlib format" for compressed content. The zlib format
6437 ** contains a two-byte identification header and a four-byte checksum at
6438 ** the end. This is different from ZIP which uses the raw deflate format.
6440 ** Future enhancements to SQLar might add support for new compression formats.
6441 ** If so, those new formats will be identified by alternative headers in the
6444 static void sqlarCompressFunc(
6445 sqlite3_context *context,
6447 sqlite3_value **argv
6450 if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){
6451 const Bytef *pData = sqlite3_value_blob(argv[0]);
6452 uLong nData = sqlite3_value_bytes(argv[0]);
6453 uLongf nOut = compressBound(nData);
6456 pOut = (Bytef*)sqlite3_malloc(nOut);
6458 sqlite3_result_error_nomem(context);
6461 if( Z_OK!=compress(pOut, &nOut, pData, nData) ){
6462 sqlite3_result_error(context, "error in compress()", -1);
6463 }else if( nOut<nData ){
6464 sqlite3_result_blob(context, pOut, nOut, SQLITE_TRANSIENT);
6466 sqlite3_result_value(context, argv[0]);
6471 sqlite3_result_value(context, argv[0]);
6476 ** Implementation of the "sqlar_uncompress(X,SZ)" SQL function
6478 ** Parameter SZ is interpreted as an integer. If it is less than or
6479 ** equal to zero, then this function returns a copy of X. Or, if
6480 ** SZ is equal to the size of X when interpreted as a blob, also
6481 ** return a copy of X. Otherwise, decompress blob X using zlib
6482 ** utility function uncompress() and return the results (another
6485 static void sqlarUncompressFunc(
6486 sqlite3_context *context,
6488 sqlite3_value **argv
6494 sz = sqlite3_value_int(argv[1]);
6496 if( sz<=0 || sz==(nData = sqlite3_value_bytes(argv[0])) ){
6497 sqlite3_result_value(context, argv[0]);
6499 const Bytef *pData= sqlite3_value_blob(argv[0]);
6500 Bytef *pOut = sqlite3_malloc(sz);
6501 if( Z_OK!=uncompress(pOut, &sz, pData, nData) ){
6502 sqlite3_result_error(context, "error in uncompress()", -1);
6504 sqlite3_result_blob(context, pOut, sz, SQLITE_TRANSIENT);
6514 int sqlite3_sqlar_init(
6517 const sqlite3_api_routines *pApi
6520 SQLITE_EXTENSION_INIT2(pApi);
6521 (void)pzErrMsg; /* Unused parameter */
6522 rc = sqlite3_create_function(db, "sqlar_compress", 1,
6523 SQLITE_UTF8|SQLITE_INNOCUOUS, 0,
6524 sqlarCompressFunc, 0, 0);
6525 if( rc==SQLITE_OK ){
6526 rc = sqlite3_create_function(db, "sqlar_uncompress", 2,
6527 SQLITE_UTF8|SQLITE_INNOCUOUS, 0,
6528 sqlarUncompressFunc, 0, 0);
6533 /************************* End ../ext/misc/sqlar.c ********************/
6535 /************************* Begin ../ext/expert/sqlite3expert.h ******************/
6539 ** The author disclaims copyright to this source code. In place of
6540 ** a legal notice, here is a blessing:
6542 ** May you do good and not evil.
6543 ** May you find forgiveness for yourself and forgive others.
6544 ** May you share freely, never taking more than you give.
6546 *************************************************************************
6548 #if !defined(SQLITEEXPERT_H)
6549 #define SQLITEEXPERT_H 1
6550 /* #include "sqlite3.h" */
6552 typedef struct sqlite3expert sqlite3expert;
6555 ** Create a new sqlite3expert object.
6557 ** If successful, a pointer to the new object is returned and (*pzErr) set
6558 ** to NULL. Or, if an error occurs, NULL is returned and (*pzErr) set to
6559 ** an English-language error message. In this case it is the responsibility
6560 ** of the caller to eventually free the error message buffer using
6563 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErr);
6566 ** Configure an sqlite3expert object.
6568 ** EXPERT_CONFIG_SAMPLE:
6569 ** By default, sqlite3_expert_analyze() generates sqlite_stat1 data for
6570 ** each candidate index. This involves scanning and sorting the entire
6571 ** contents of each user database table once for each candidate index
6572 ** associated with the table. For large databases, this can be
6573 ** prohibitively slow. This option allows the sqlite3expert object to
6574 ** be configured so that sqlite_stat1 data is instead generated based on a
6575 ** subset of each table, or so that no sqlite_stat1 data is used at all.
6577 ** A single integer argument is passed to this option. If the value is less
6578 ** than or equal to zero, then no sqlite_stat1 data is generated or used by
6579 ** the analysis - indexes are recommended based on the database schema only.
6580 ** Or, if the value is 100 or greater, complete sqlite_stat1 data is
6581 ** generated for each candidate index (this is the default). Finally, if the
6582 ** value falls between 0 and 100, then it represents the percentage of user
6583 ** table rows that should be considered when generating sqlite_stat1 data.
6587 ** // Do not generate any sqlite_stat1 data
6588 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 0);
6590 ** // Generate sqlite_stat1 data based on 10% of the rows in each table.
6591 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 10);
6593 int sqlite3_expert_config(sqlite3expert *p, int op, ...);
6595 #define EXPERT_CONFIG_SAMPLE 1 /* int */
6598 ** Specify zero or more SQL statements to be included in the analysis.
6600 ** Buffer zSql must contain zero or more complete SQL statements. This
6601 ** function parses all statements contained in the buffer and adds them
6602 ** to the internal list of statements to analyze. If successful, SQLITE_OK
6603 ** is returned and (*pzErr) set to NULL. Or, if an error occurs - for example
6604 ** due to a error in the SQL - an SQLite error code is returned and (*pzErr)
6605 ** may be set to point to an English language error message. In this case
6606 ** the caller is responsible for eventually freeing the error message buffer
6607 ** using sqlite3_free().
6609 ** If an error does occur while processing one of the statements in the
6610 ** buffer passed as the second argument, none of the statements in the
6611 ** buffer are added to the analysis.
6613 ** This function must be called before sqlite3_expert_analyze(). If a call
6614 ** to this function is made on an sqlite3expert object that has already
6615 ** been passed to sqlite3_expert_analyze() SQLITE_MISUSE is returned
6616 ** immediately and no statements are added to the analysis.
6618 int sqlite3_expert_sql(
6619 sqlite3expert *p, /* From a successful sqlite3_expert_new() */
6620 const char *zSql, /* SQL statement(s) to add */
6621 char **pzErr /* OUT: Error message (if any) */
6626 ** This function is called after the sqlite3expert object has been configured
6627 ** with all SQL statements using sqlite3_expert_sql() to actually perform
6628 ** the analysis. Once this function has been called, it is not possible to
6629 ** add further SQL statements to the analysis.
6631 ** If successful, SQLITE_OK is returned and (*pzErr) is set to NULL. Or, if
6632 ** an error occurs, an SQLite error code is returned and (*pzErr) set to
6633 ** point to a buffer containing an English language error message. In this
6634 ** case it is the responsibility of the caller to eventually free the buffer
6635 ** using sqlite3_free().
6637 ** If an error does occur within this function, the sqlite3expert object
6638 ** is no longer useful for any purpose. At that point it is no longer
6639 ** possible to add further SQL statements to the object or to re-attempt
6640 ** the analysis. The sqlite3expert object must still be freed using a call
6641 ** sqlite3_expert_destroy().
6643 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr);
6646 ** Return the total number of statements loaded using sqlite3_expert_sql().
6647 ** The total number of SQL statements may be different from the total number
6648 ** to calls to sqlite3_expert_sql().
6650 int sqlite3_expert_count(sqlite3expert*);
6653 ** Return a component of the report.
6655 ** This function is called after sqlite3_expert_analyze() to extract the
6656 ** results of the analysis. Each call to this function returns either a
6657 ** NULL pointer or a pointer to a buffer containing a nul-terminated string.
6658 ** The value passed as the third argument must be one of the EXPERT_REPORT_*
6659 ** #define constants defined below.
6661 ** For some EXPERT_REPORT_* parameters, the buffer returned contains
6662 ** information relating to a specific SQL statement. In these cases that
6663 ** SQL statement is identified by the value passed as the second argument.
6664 ** SQL statements are numbered from 0 in the order in which they are parsed.
6665 ** If an out-of-range value (less than zero or equal to or greater than the
6666 ** value returned by sqlite3_expert_count()) is passed as the second argument
6667 ** along with such an EXPERT_REPORT_* parameter, NULL is always returned.
6669 ** EXPERT_REPORT_SQL:
6670 ** Return the text of SQL statement iStmt.
6672 ** EXPERT_REPORT_INDEXES:
6673 ** Return a buffer containing the CREATE INDEX statements for all recommended
6674 ** indexes for statement iStmt. If there are no new recommeded indexes, NULL
6677 ** EXPERT_REPORT_PLAN:
6678 ** Return a buffer containing the EXPLAIN QUERY PLAN output for SQL query
6679 ** iStmt after the proposed indexes have been added to the database schema.
6681 ** EXPERT_REPORT_CANDIDATES:
6682 ** Return a pointer to a buffer containing the CREATE INDEX statements
6683 ** for all indexes that were tested (for all SQL statements). The iStmt
6684 ** parameter is ignored for EXPERT_REPORT_CANDIDATES calls.
6686 const char *sqlite3_expert_report(sqlite3expert*, int iStmt, int eReport);
6689 ** Values for the third argument passed to sqlite3_expert_report().
6691 #define EXPERT_REPORT_SQL 1
6692 #define EXPERT_REPORT_INDEXES 2
6693 #define EXPERT_REPORT_PLAN 3
6694 #define EXPERT_REPORT_CANDIDATES 4
6697 ** Free an (sqlite3expert*) handle and all associated resources. There
6698 ** should be one call to this function for each successful call to
6699 ** sqlite3-expert_new().
6701 void sqlite3_expert_destroy(sqlite3expert*);
6703 #endif /* !defined(SQLITEEXPERT_H) */
6705 /************************* End ../ext/expert/sqlite3expert.h ********************/
6706 /************************* Begin ../ext/expert/sqlite3expert.c ******************/
6710 ** The author disclaims copyright to this source code. In place of
6711 ** a legal notice, here is a blessing:
6713 ** May you do good and not evil.
6714 ** May you find forgiveness for yourself and forgive others.
6715 ** May you share freely, never taking more than you give.
6717 *************************************************************************
6719 /* #include "sqlite3expert.h" */
6724 #ifndef SQLITE_OMIT_VIRTUALTABLE
6726 /* typedef sqlite3_int64 i64; */
6727 /* typedef sqlite3_uint64 u64; */
6729 typedef struct IdxColumn IdxColumn;
6730 typedef struct IdxConstraint IdxConstraint;
6731 typedef struct IdxScan IdxScan;
6732 typedef struct IdxStatement IdxStatement;
6733 typedef struct IdxTable IdxTable;
6734 typedef struct IdxWrite IdxWrite;
6736 #define STRLEN (int)strlen
6739 ** A temp table name that we assume no user database will actually use.
6740 ** If this assumption proves incorrect triggers on the table with the
6741 ** conflicting name will be ignored.
6743 #define UNIQUE_TABLE_NAME "t592690916721053953805701627921227776"
6746 ** A single constraint. Equivalent to either "col = ?" or "col < ?" (or
6747 ** any other type of single-ended range constraint on a column).
6750 ** Used to temporarily link IdxConstraint objects into lists while
6751 ** creating candidate indexes.
6753 struct IdxConstraint {
6754 char *zColl; /* Collation sequence */
6755 int bRange; /* True for range, false for eq */
6756 int iCol; /* Constrained table column */
6757 int bFlag; /* Used by idxFindCompatible() */
6758 int bDesc; /* True if ORDER BY <expr> DESC */
6759 IdxConstraint *pNext; /* Next constraint in pEq or pRange list */
6760 IdxConstraint *pLink; /* See above */
6764 ** A single scan of a single table.
6767 IdxTable *pTab; /* Associated table object */
6768 int iDb; /* Database containing table zTable */
6769 i64 covering; /* Mask of columns required for cov. index */
6770 IdxConstraint *pOrder; /* ORDER BY columns */
6771 IdxConstraint *pEq; /* List of == constraints */
6772 IdxConstraint *pRange; /* List of < constraints */
6773 IdxScan *pNextScan; /* Next IdxScan object for same analysis */
6777 ** Information regarding a single database table. Extracted from
6778 ** "PRAGMA table_info" by function idxGetTableInfo().
6787 char *zName; /* Table name */
6789 IdxTable *pNext; /* Next table in linked list of all tables */
6793 ** An object of the following type is created for each unique table/write-op
6794 ** seen. The objects are stored in a singly-linked list beginning at
6795 ** sqlite3expert.pWrite.
6799 int eOp; /* SQLITE_UPDATE, DELETE or INSERT */
6804 ** Each statement being analyzed is represented by an instance of this
6807 struct IdxStatement {
6808 int iId; /* Statement number */
6809 char *zSql; /* SQL statement */
6810 char *zIdx; /* Indexes */
6811 char *zEQP; /* Plan */
6812 IdxStatement *pNext;
6817 ** A hash table for storing strings. With space for a payload string
6818 ** with each entry. Methods are:
6825 #define IDX_HASH_SIZE 1023
6826 typedef struct IdxHashEntry IdxHashEntry;
6827 typedef struct IdxHash IdxHash;
6828 struct IdxHashEntry {
6829 char *zKey; /* nul-terminated key */
6830 char *zVal; /* nul-terminated value string */
6831 char *zVal2; /* nul-terminated value string 2 */
6832 IdxHashEntry *pHashNext; /* Next entry in same hash bucket */
6833 IdxHashEntry *pNext; /* Next entry in hash */
6836 IdxHashEntry *pFirst;
6837 IdxHashEntry *aHash[IDX_HASH_SIZE];
6841 ** sqlite3expert object.
6843 struct sqlite3expert {
6844 int iSample; /* Percentage of tables to sample for stat1 */
6845 sqlite3 *db; /* User database */
6846 sqlite3 *dbm; /* In-memory db for this analysis */
6847 sqlite3 *dbv; /* Vtab schema for this analysis */
6848 IdxTable *pTable; /* List of all IdxTable objects */
6849 IdxScan *pScan; /* List of scan objects */
6850 IdxWrite *pWrite; /* List of write objects */
6851 IdxStatement *pStatement; /* List of IdxStatement objects */
6852 int bRun; /* True once analysis has run */
6854 int rc; /* Error code from whereinfo hook */
6855 IdxHash hIdx; /* Hash containing all candidate indexes */
6856 char *zCandidates; /* For EXPERT_REPORT_CANDIDATES */
6861 ** Allocate and return nByte bytes of zeroed memory using sqlite3_malloc().
6862 ** If the allocation fails, set *pRc to SQLITE_NOMEM and return NULL.
6864 static void *idxMalloc(int *pRc, int nByte){
6866 assert( *pRc==SQLITE_OK );
6868 pRet = sqlite3_malloc(nByte);
6870 memset(pRet, 0, nByte);
6872 *pRc = SQLITE_NOMEM;
6878 ** Initialize an IdxHash hash table.
6880 static void idxHashInit(IdxHash *pHash){
6881 memset(pHash, 0, sizeof(IdxHash));
6885 ** Reset an IdxHash hash table.
6887 static void idxHashClear(IdxHash *pHash){
6889 for(i=0; i<IDX_HASH_SIZE; i++){
6890 IdxHashEntry *pEntry;
6891 IdxHashEntry *pNext;
6892 for(pEntry=pHash->aHash[i]; pEntry; pEntry=pNext){
6893 pNext = pEntry->pHashNext;
6894 sqlite3_free(pEntry->zVal2);
6895 sqlite3_free(pEntry);
6898 memset(pHash, 0, sizeof(IdxHash));
6902 ** Return the index of the hash bucket that the string specified by the
6903 ** arguments to this function belongs.
6905 static int idxHashString(const char *z, int n){
6906 unsigned int ret = 0;
6909 ret += (ret<<3) + (unsigned char)(z[i]);
6911 return (int)(ret % IDX_HASH_SIZE);
6915 ** If zKey is already present in the hash table, return non-zero and do
6916 ** nothing. Otherwise, add an entry with key zKey and payload string zVal to
6917 ** the hash table passed as the second argument.
6919 static int idxHashAdd(
6925 int nKey = STRLEN(zKey);
6926 int iHash = idxHashString(zKey, nKey);
6927 int nVal = (zVal ? STRLEN(zVal) : 0);
6928 IdxHashEntry *pEntry;
6930 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){
6931 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){
6935 pEntry = idxMalloc(pRc, sizeof(IdxHashEntry) + nKey+1 + nVal+1);
6937 pEntry->zKey = (char*)&pEntry[1];
6938 memcpy(pEntry->zKey, zKey, nKey);
6940 pEntry->zVal = &pEntry->zKey[nKey+1];
6941 memcpy(pEntry->zVal, zVal, nVal);
6943 pEntry->pHashNext = pHash->aHash[iHash];
6944 pHash->aHash[iHash] = pEntry;
6946 pEntry->pNext = pHash->pFirst;
6947 pHash->pFirst = pEntry;
6953 ** If zKey/nKey is present in the hash table, return a pointer to the
6954 ** hash-entry object.
6956 static IdxHashEntry *idxHashFind(IdxHash *pHash, const char *zKey, int nKey){
6958 IdxHashEntry *pEntry;
6959 if( nKey<0 ) nKey = STRLEN(zKey);
6960 iHash = idxHashString(zKey, nKey);
6962 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){
6963 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){
6971 ** If the hash table contains an entry with a key equal to the string
6972 ** passed as the final two arguments to this function, return a pointer
6973 ** to the payload string. Otherwise, if zKey/nKey is not present in the
6974 ** hash table, return NULL.
6976 static const char *idxHashSearch(IdxHash *pHash, const char *zKey, int nKey){
6977 IdxHashEntry *pEntry = idxHashFind(pHash, zKey, nKey);
6978 if( pEntry ) return pEntry->zVal;
6983 ** Allocate and return a new IdxConstraint object. Set the IdxConstraint.zColl
6984 ** variable to point to a copy of nul-terminated string zColl.
6986 static IdxConstraint *idxNewConstraint(int *pRc, const char *zColl){
6987 IdxConstraint *pNew;
6988 int nColl = STRLEN(zColl);
6990 assert( *pRc==SQLITE_OK );
6991 pNew = (IdxConstraint*)idxMalloc(pRc, sizeof(IdxConstraint) * nColl + 1);
6993 pNew->zColl = (char*)&pNew[1];
6994 memcpy(pNew->zColl, zColl, nColl+1);
7000 ** An error associated with database handle db has just occurred. Pass
7001 ** the error message to callback function xOut.
7003 static void idxDatabaseError(
7004 sqlite3 *db, /* Database handle */
7005 char **pzErrmsg /* Write error here */
7007 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
7011 ** Prepare an SQL statement.
7013 static int idxPrepareStmt(
7014 sqlite3 *db, /* Database handle to compile against */
7015 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */
7016 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */
7017 const char *zSql /* SQL statement to compile */
7019 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
7020 if( rc!=SQLITE_OK ){
7022 idxDatabaseError(db, pzErrmsg);
7028 ** Prepare an SQL statement using the results of a printf() formatting.
7030 static int idxPrintfPrepareStmt(
7031 sqlite3 *db, /* Database handle to compile against */
7032 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */
7033 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */
7034 const char *zFmt, /* printf() format of SQL statement */
7035 ... /* Trailing printf() arguments */
7041 zSql = sqlite3_vmprintf(zFmt, ap);
7045 rc = idxPrepareStmt(db, ppStmt, pzErrmsg, zSql);
7053 /*************************************************************************
7054 ** Beginning of virtual table implementation.
7056 typedef struct ExpertVtab ExpertVtab;
7060 sqlite3expert *pExpert;
7063 typedef struct ExpertCsr ExpertCsr;
7065 sqlite3_vtab_cursor base;
7066 sqlite3_stmt *pData;
7069 static char *expertDequote(const char *zIn){
7070 int n = STRLEN(zIn);
7071 char *zRet = sqlite3_malloc(n);
7073 assert( zIn[0]=='\'' );
7074 assert( zIn[n-1]=='\'' );
7079 for(iIn=1; iIn<(n-1); iIn++){
7080 if( zIn[iIn]=='\'' ){
7081 assert( zIn[iIn+1]=='\'' );
7084 zRet[iOut++] = zIn[iIn];
7093 ** This function is the implementation of both the xConnect and xCreate
7094 ** methods of the r-tree virtual table.
7096 ** argv[0] -> module name
7097 ** argv[1] -> database name
7098 ** argv[2] -> table name
7099 ** argv[...] -> column names...
7101 static int expertConnect(
7104 int argc, const char *const*argv,
7105 sqlite3_vtab **ppVtab,
7108 sqlite3expert *pExpert = (sqlite3expert*)pAux;
7113 *pzErr = sqlite3_mprintf("internal error!");
7116 char *zCreateTable = expertDequote(argv[3]);
7118 rc = sqlite3_declare_vtab(db, zCreateTable);
7119 if( rc==SQLITE_OK ){
7120 p = idxMalloc(&rc, sizeof(ExpertVtab));
7122 if( rc==SQLITE_OK ){
7123 p->pExpert = pExpert;
7124 p->pTab = pExpert->pTable;
7125 assert( sqlite3_stricmp(p->pTab->zName, argv[2])==0 );
7127 sqlite3_free(zCreateTable);
7133 *ppVtab = (sqlite3_vtab*)p;
7137 static int expertDisconnect(sqlite3_vtab *pVtab){
7138 ExpertVtab *p = (ExpertVtab*)pVtab;
7143 static int expertBestIndex(sqlite3_vtab *pVtab, sqlite3_index_info *pIdxInfo){
7144 ExpertVtab *p = (ExpertVtab*)pVtab;
7149 SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_GT |
7150 SQLITE_INDEX_CONSTRAINT_LT | SQLITE_INDEX_CONSTRAINT_GE |
7151 SQLITE_INDEX_CONSTRAINT_LE;
7153 pScan = idxMalloc(&rc, sizeof(IdxScan));
7157 /* Link the new scan object into the list */
7158 pScan->pTab = p->pTab;
7159 pScan->pNextScan = p->pExpert->pScan;
7160 p->pExpert->pScan = pScan;
7162 /* Add the constraints to the IdxScan object */
7163 for(i=0; i<pIdxInfo->nConstraint; i++){
7164 struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i];
7166 && pCons->iColumn>=0
7167 && p->pTab->aCol[pCons->iColumn].iPk==0
7168 && (pCons->op & opmask)
7170 IdxConstraint *pNew;
7171 const char *zColl = sqlite3_vtab_collation(pIdxInfo, i);
7172 pNew = idxNewConstraint(&rc, zColl);
7174 pNew->iCol = pCons->iColumn;
7175 if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){
7176 pNew->pNext = pScan->pEq;
7180 pNew->pNext = pScan->pRange;
7181 pScan->pRange = pNew;
7185 pIdxInfo->aConstraintUsage[i].argvIndex = n;
7189 /* Add the ORDER BY to the IdxScan object */
7190 for(i=pIdxInfo->nOrderBy-1; i>=0; i--){
7191 int iCol = pIdxInfo->aOrderBy[i].iColumn;
7193 IdxConstraint *pNew = idxNewConstraint(&rc, p->pTab->aCol[iCol].zColl);
7196 pNew->bDesc = pIdxInfo->aOrderBy[i].desc;
7197 pNew->pNext = pScan->pOrder;
7198 pNew->pLink = pScan->pOrder;
7199 pScan->pOrder = pNew;
7206 pIdxInfo->estimatedCost = 1000000.0 / (n+1);
7210 static int expertUpdate(
7211 sqlite3_vtab *pVtab,
7213 sqlite3_value **azData,
7214 sqlite_int64 *pRowid
7224 ** Virtual table module xOpen method.
7226 static int expertOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
7230 pCsr = idxMalloc(&rc, sizeof(ExpertCsr));
7231 *ppCursor = (sqlite3_vtab_cursor*)pCsr;
7236 ** Virtual table module xClose method.
7238 static int expertClose(sqlite3_vtab_cursor *cur){
7239 ExpertCsr *pCsr = (ExpertCsr*)cur;
7240 sqlite3_finalize(pCsr->pData);
7246 ** Virtual table module xEof method.
7248 ** Return non-zero if the cursor does not currently point to a valid
7249 ** record (i.e if the scan has finished), or zero otherwise.
7251 static int expertEof(sqlite3_vtab_cursor *cur){
7252 ExpertCsr *pCsr = (ExpertCsr*)cur;
7253 return pCsr->pData==0;
7257 ** Virtual table module xNext method.
7259 static int expertNext(sqlite3_vtab_cursor *cur){
7260 ExpertCsr *pCsr = (ExpertCsr*)cur;
7263 assert( pCsr->pData );
7264 rc = sqlite3_step(pCsr->pData);
7265 if( rc!=SQLITE_ROW ){
7266 rc = sqlite3_finalize(pCsr->pData);
7276 ** Virtual table module xRowid method.
7278 static int expertRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
7285 ** Virtual table module xColumn method.
7287 static int expertColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
7288 ExpertCsr *pCsr = (ExpertCsr*)cur;
7289 sqlite3_value *pVal;
7290 pVal = sqlite3_column_value(pCsr->pData, i);
7292 sqlite3_result_value(ctx, pVal);
7298 ** Virtual table module xFilter method.
7300 static int expertFilter(
7301 sqlite3_vtab_cursor *cur,
7302 int idxNum, const char *idxStr,
7303 int argc, sqlite3_value **argv
7305 ExpertCsr *pCsr = (ExpertCsr*)cur;
7306 ExpertVtab *pVtab = (ExpertVtab*)(cur->pVtab);
7307 sqlite3expert *pExpert = pVtab->pExpert;
7314 rc = sqlite3_finalize(pCsr->pData);
7316 if( rc==SQLITE_OK ){
7317 rc = idxPrintfPrepareStmt(pExpert->db, &pCsr->pData, &pVtab->base.zErrMsg,
7318 "SELECT * FROM main.%Q WHERE sample()", pVtab->pTab->zName
7322 if( rc==SQLITE_OK ){
7323 rc = expertNext(cur);
7328 static int idxRegisterVtab(sqlite3expert *p){
7329 static sqlite3_module expertModule = {
7331 expertConnect, /* xCreate - create a table */
7332 expertConnect, /* xConnect - connect to an existing table */
7333 expertBestIndex, /* xBestIndex - Determine search strategy */
7334 expertDisconnect, /* xDisconnect - Disconnect from a table */
7335 expertDisconnect, /* xDestroy - Drop a table */
7336 expertOpen, /* xOpen - open a cursor */
7337 expertClose, /* xClose - close a cursor */
7338 expertFilter, /* xFilter - configure scan constraints */
7339 expertNext, /* xNext - advance a cursor */
7340 expertEof, /* xEof */
7341 expertColumn, /* xColumn - read data */
7342 expertRowid, /* xRowid - read data */
7343 expertUpdate, /* xUpdate - write data */
7344 0, /* xBegin - begin transaction */
7345 0, /* xSync - sync transaction */
7346 0, /* xCommit - commit transaction */
7347 0, /* xRollback - rollback transaction */
7348 0, /* xFindFunction - function overloading */
7349 0, /* xRename - rename the table */
7352 0, /* xRollbackTo */
7353 0, /* xShadowName */
7356 return sqlite3_create_module(p->dbv, "expert", &expertModule, (void*)p);
7359 ** End of virtual table implementation.
7360 *************************************************************************/
7362 ** Finalize SQL statement pStmt. If (*pRc) is SQLITE_OK when this function
7363 ** is called, set it to the return value of sqlite3_finalize() before
7364 ** returning. Otherwise, discard the sqlite3_finalize() return value.
7366 static void idxFinalize(int *pRc, sqlite3_stmt *pStmt){
7367 int rc = sqlite3_finalize(pStmt);
7368 if( *pRc==SQLITE_OK ) *pRc = rc;
7372 ** Attempt to allocate an IdxTable structure corresponding to table zTab
7373 ** in the main database of connection db. If successful, set (*ppOut) to
7374 ** point to the new object and return SQLITE_OK. Otherwise, return an
7375 ** SQLite error code and set (*ppOut) to NULL. In this case *pzErrmsg may be
7376 ** set to point to an error string.
7378 ** It is the responsibility of the caller to eventually free either the
7379 ** IdxTable object or error message using sqlite3_free().
7381 static int idxGetTableInfo(
7382 sqlite3 *db, /* Database connection to read details from */
7383 const char *zTab, /* Table name */
7384 IdxTable **ppOut, /* OUT: New object (if successful) */
7385 char **pzErrmsg /* OUT: Error message (if not) */
7387 sqlite3_stmt *p1 = 0;
7389 int nTab = STRLEN(zTab);
7390 int nByte = sizeof(IdxTable) + nTab + 1;
7395 rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_info=%Q", zTab);
7396 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
7397 const char *zCol = (const char*)sqlite3_column_text(p1, 1);
7398 nByte += 1 + STRLEN(zCol);
7399 rc = sqlite3_table_column_metadata(
7400 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0
7402 nByte += 1 + STRLEN(zCol);
7405 rc2 = sqlite3_reset(p1);
7406 if( rc==SQLITE_OK ) rc = rc2;
7408 nByte += sizeof(IdxColumn) * nCol;
7409 if( rc==SQLITE_OK ){
7410 pNew = idxMalloc(&rc, nByte);
7412 if( rc==SQLITE_OK ){
7413 pNew->aCol = (IdxColumn*)&pNew[1];
7415 pCsr = (char*)&pNew->aCol[nCol];
7419 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
7420 const char *zCol = (const char*)sqlite3_column_text(p1, 1);
7421 int nCopy = STRLEN(zCol) + 1;
7422 pNew->aCol[nCol].zName = pCsr;
7423 pNew->aCol[nCol].iPk = sqlite3_column_int(p1, 5);
7424 memcpy(pCsr, zCol, nCopy);
7427 rc = sqlite3_table_column_metadata(
7428 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0
7430 if( rc==SQLITE_OK ){
7431 nCopy = STRLEN(zCol) + 1;
7432 pNew->aCol[nCol].zColl = pCsr;
7433 memcpy(pCsr, zCol, nCopy);
7439 idxFinalize(&rc, p1);
7441 if( rc!=SQLITE_OK ){
7446 memcpy(pNew->zName, zTab, nTab+1);
7454 ** This function is a no-op if *pRc is set to anything other than
7455 ** SQLITE_OK when it is called.
7457 ** If *pRc is initially set to SQLITE_OK, then the text specified by
7458 ** the printf() style arguments is appended to zIn and the result returned
7459 ** in a buffer allocated by sqlite3_malloc(). sqlite3_free() is called on
7460 ** zIn before returning.
7462 static char *idxAppendText(int *pRc, char *zIn, const char *zFmt, ...){
7466 int nIn = zIn ? STRLEN(zIn) : 0;
7469 if( *pRc==SQLITE_OK ){
7470 zAppend = sqlite3_vmprintf(zFmt, ap);
7472 nAppend = STRLEN(zAppend);
7473 zRet = (char*)sqlite3_malloc(nIn + nAppend + 1);
7475 if( zAppend && zRet ){
7476 if( nIn ) memcpy(zRet, zIn, nIn);
7477 memcpy(&zRet[nIn], zAppend, nAppend+1);
7481 *pRc = SQLITE_NOMEM;
7483 sqlite3_free(zAppend);
7491 ** Return true if zId must be quoted in order to use it as an SQL
7492 ** identifier, or false otherwise.
7494 static int idxIdentifierRequiresQuotes(const char *zId){
7496 for(i=0; zId[i]; i++){
7498 && !(zId[i]>='0' && zId[i]<='9')
7499 && !(zId[i]>='a' && zId[i]<='z')
7500 && !(zId[i]>='A' && zId[i]<='Z')
7509 ** This function appends an index column definition suitable for constraint
7510 ** pCons to the string passed as zIn and returns the result.
7512 static char *idxAppendColDefn(
7513 int *pRc, /* IN/OUT: Error code */
7514 char *zIn, /* Column defn accumulated so far */
7515 IdxTable *pTab, /* Table index will be created on */
7516 IdxConstraint *pCons
7519 IdxColumn *p = &pTab->aCol[pCons->iCol];
7520 if( zRet ) zRet = idxAppendText(pRc, zRet, ", ");
7522 if( idxIdentifierRequiresQuotes(p->zName) ){
7523 zRet = idxAppendText(pRc, zRet, "%Q", p->zName);
7525 zRet = idxAppendText(pRc, zRet, "%s", p->zName);
7528 if( sqlite3_stricmp(p->zColl, pCons->zColl) ){
7529 if( idxIdentifierRequiresQuotes(pCons->zColl) ){
7530 zRet = idxAppendText(pRc, zRet, " COLLATE %Q", pCons->zColl);
7532 zRet = idxAppendText(pRc, zRet, " COLLATE %s", pCons->zColl);
7537 zRet = idxAppendText(pRc, zRet, " DESC");
7543 ** Search database dbm for an index compatible with the one idxCreateFromCons()
7544 ** would create from arguments pScan, pEq and pTail. If no error occurs and
7545 ** such an index is found, return non-zero. Or, if no such index is found,
7548 ** If an error occurs, set *pRc to an SQLite error code and return zero.
7550 static int idxFindCompatible(
7551 int *pRc, /* OUT: Error code */
7552 sqlite3* dbm, /* Database to search */
7553 IdxScan *pScan, /* Scan for table to search for index on */
7554 IdxConstraint *pEq, /* List of == constraints */
7555 IdxConstraint *pTail /* List of range constraints */
7557 const char *zTbl = pScan->pTab->zName;
7558 sqlite3_stmt *pIdxList = 0;
7559 IdxConstraint *pIter;
7560 int nEq = 0; /* Number of elements in pEq */
7563 /* Count the elements in list pEq */
7564 for(pIter=pEq; pIter; pIter=pIter->pLink) nEq++;
7566 rc = idxPrintfPrepareStmt(dbm, &pIdxList, 0, "PRAGMA index_list=%Q", zTbl);
7567 while( rc==SQLITE_OK && sqlite3_step(pIdxList)==SQLITE_ROW ){
7569 IdxConstraint *pT = pTail;
7570 sqlite3_stmt *pInfo = 0;
7571 const char *zIdx = (const char*)sqlite3_column_text(pIdxList, 1);
7573 /* Zero the IdxConstraint.bFlag values in the pEq list */
7574 for(pIter=pEq; pIter; pIter=pIter->pLink) pIter->bFlag = 0;
7576 rc = idxPrintfPrepareStmt(dbm, &pInfo, 0, "PRAGMA index_xInfo=%Q", zIdx);
7577 while( rc==SQLITE_OK && sqlite3_step(pInfo)==SQLITE_ROW ){
7578 int iIdx = sqlite3_column_int(pInfo, 0);
7579 int iCol = sqlite3_column_int(pInfo, 1);
7580 const char *zColl = (const char*)sqlite3_column_text(pInfo, 4);
7583 for(pIter=pEq; pIter; pIter=pIter->pLink){
7584 if( pIter->bFlag ) continue;
7585 if( pIter->iCol!=iCol ) continue;
7586 if( sqlite3_stricmp(pIter->zColl, zColl) ) continue;
7596 if( pT->iCol!=iCol || sqlite3_stricmp(pT->zColl, zColl) ){
7604 idxFinalize(&rc, pInfo);
7606 if( rc==SQLITE_OK && bMatch ){
7607 sqlite3_finalize(pIdxList);
7611 idxFinalize(&rc, pIdxList);
7617 static int idxCreateFromCons(
7621 IdxConstraint *pTail
7623 sqlite3 *dbm = p->dbm;
7625 if( (pEq || pTail) && 0==idxFindCompatible(&rc, dbm, pScan, pEq, pTail) ){
7626 IdxTable *pTab = pScan->pTab;
7629 IdxConstraint *pCons;
7633 for(pCons=pEq; pCons; pCons=pCons->pLink){
7634 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons);
7636 for(pCons=pTail; pCons; pCons=pCons->pLink){
7637 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons);
7640 if( rc==SQLITE_OK ){
7641 /* Hash the list of columns to come up with a name for the index */
7642 const char *zTable = pScan->pTab->zName;
7643 char *zName; /* Index name */
7645 for(i=0; zCols[i]; i++){
7646 h += ((h<<3) + zCols[i]);
7648 zName = sqlite3_mprintf("%s_idx_%08x", zTable, h);
7652 if( idxIdentifierRequiresQuotes(zTable) ){
7653 zFmt = "CREATE INDEX '%q' ON %Q(%s)";
7655 zFmt = "CREATE INDEX %s ON %s(%s)";
7657 zIdx = sqlite3_mprintf(zFmt, zName, zTable, zCols);
7661 rc = sqlite3_exec(dbm, zIdx, 0, 0, p->pzErrmsg);
7662 idxHashAdd(&rc, &p->hIdx, zName, zIdx);
7664 sqlite3_free(zName);
7669 sqlite3_free(zCols);
7675 ** Return true if list pList (linked by IdxConstraint.pLink) contains
7676 ** a constraint compatible with *p. Otherwise return false.
7678 static int idxFindConstraint(IdxConstraint *pList, IdxConstraint *p){
7679 IdxConstraint *pCmp;
7680 for(pCmp=pList; pCmp; pCmp=pCmp->pLink){
7681 if( p->iCol==pCmp->iCol ) return 1;
7686 static int idxCreateFromWhere(
7688 IdxScan *pScan, /* Create indexes for this scan */
7689 IdxConstraint *pTail /* range/ORDER BY constraints for inclusion */
7691 IdxConstraint *p1 = 0;
7692 IdxConstraint *pCon;
7695 /* Gather up all the == constraints. */
7696 for(pCon=pScan->pEq; pCon; pCon=pCon->pNext){
7697 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){
7703 /* Create an index using the == constraints collected above. And the
7704 ** range constraint/ORDER BY terms passed in by the caller, if any. */
7705 rc = idxCreateFromCons(p, pScan, p1, pTail);
7707 /* If no range/ORDER BY passed by the caller, create a version of the
7708 ** index for each range constraint. */
7710 for(pCon=pScan->pRange; rc==SQLITE_OK && pCon; pCon=pCon->pNext){
7711 assert( pCon->pLink==0 );
7712 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){
7713 rc = idxCreateFromCons(p, pScan, p1, pCon);
7722 ** Create candidate indexes in database [dbm] based on the data in
7723 ** linked-list pScan.
7725 static int idxCreateCandidates(sqlite3expert *p){
7729 for(pIter=p->pScan; pIter && rc==SQLITE_OK; pIter=pIter->pNextScan){
7730 rc = idxCreateFromWhere(p, pIter, 0);
7731 if( rc==SQLITE_OK && pIter->pOrder ){
7732 rc = idxCreateFromWhere(p, pIter, pIter->pOrder);
7740 ** Free all elements of the linked list starting at pConstraint.
7742 static void idxConstraintFree(IdxConstraint *pConstraint){
7743 IdxConstraint *pNext;
7746 for(p=pConstraint; p; p=pNext){
7753 ** Free all elements of the linked list starting from pScan up until pLast
7754 ** (pLast is not freed).
7756 static void idxScanFree(IdxScan *pScan, IdxScan *pLast){
7759 for(p=pScan; p!=pLast; p=pNext){
7760 pNext = p->pNextScan;
7761 idxConstraintFree(p->pOrder);
7762 idxConstraintFree(p->pEq);
7763 idxConstraintFree(p->pRange);
7769 ** Free all elements of the linked list starting from pStatement up
7770 ** until pLast (pLast is not freed).
7772 static void idxStatementFree(IdxStatement *pStatement, IdxStatement *pLast){
7774 IdxStatement *pNext;
7775 for(p=pStatement; p!=pLast; p=pNext){
7777 sqlite3_free(p->zEQP);
7778 sqlite3_free(p->zIdx);
7784 ** Free the linked list of IdxTable objects starting at pTab.
7786 static void idxTableFree(IdxTable *pTab){
7789 for(pIter=pTab; pIter; pIter=pNext){
7790 pNext = pIter->pNext;
7791 sqlite3_free(pIter);
7796 ** Free the linked list of IdxWrite objects starting at pTab.
7798 static void idxWriteFree(IdxWrite *pTab){
7801 for(pIter=pTab; pIter; pIter=pNext){
7802 pNext = pIter->pNext;
7803 sqlite3_free(pIter);
7810 ** This function is called after candidate indexes have been created. It
7811 ** runs all the queries to see which indexes they prefer, and populates
7812 ** IdxStatement.zIdx and IdxStatement.zEQP with the results.
7816 char **pzErr /* OUT: Error message (sqlite3_malloc) */
7818 IdxStatement *pStmt;
7819 sqlite3 *dbm = p->dbm;
7825 for(pStmt=p->pStatement; rc==SQLITE_OK && pStmt; pStmt=pStmt->pNext){
7826 IdxHashEntry *pEntry;
7827 sqlite3_stmt *pExplain = 0;
7828 idxHashClear(&hIdx);
7829 rc = idxPrintfPrepareStmt(dbm, &pExplain, pzErr,
7830 "EXPLAIN QUERY PLAN %s", pStmt->zSql
7832 while( rc==SQLITE_OK && sqlite3_step(pExplain)==SQLITE_ROW ){
7833 /* int iId = sqlite3_column_int(pExplain, 0); */
7834 /* int iParent = sqlite3_column_int(pExplain, 1); */
7835 /* int iNotUsed = sqlite3_column_int(pExplain, 2); */
7836 const char *zDetail = (const char*)sqlite3_column_text(pExplain, 3);
7837 int nDetail = STRLEN(zDetail);
7840 for(i=0; i<nDetail; i++){
7841 const char *zIdx = 0;
7842 if( memcmp(&zDetail[i], " USING INDEX ", 13)==0 ){
7843 zIdx = &zDetail[i+13];
7844 }else if( memcmp(&zDetail[i], " USING COVERING INDEX ", 22)==0 ){
7845 zIdx = &zDetail[i+22];
7850 while( zIdx[nIdx]!='\0' && (zIdx[nIdx]!=' ' || zIdx[nIdx+1]!='(') ){
7853 zSql = idxHashSearch(&p->hIdx, zIdx, nIdx);
7855 idxHashAdd(&rc, &hIdx, zSql, 0);
7856 if( rc ) goto find_indexes_out;
7862 if( zDetail[0]!='-' ){
7863 pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail);
7867 for(pEntry=hIdx.pFirst; pEntry; pEntry=pEntry->pNext){
7868 pStmt->zIdx = idxAppendText(&rc, pStmt->zIdx, "%s;\n", pEntry->zKey);
7871 idxFinalize(&rc, pExplain);
7875 idxHashClear(&hIdx);
7879 static int idxAuthCallback(
7885 const char *zTrigger
7890 if( eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE || eOp==SQLITE_DELETE ){
7891 if( sqlite3_stricmp(zDb, "main")==0 ){
7892 sqlite3expert *p = (sqlite3expert*)pCtx;
7894 for(pTab=p->pTable; pTab; pTab=pTab->pNext){
7895 if( 0==sqlite3_stricmp(z3, pTab->zName) ) break;
7899 for(pWrite=p->pWrite; pWrite; pWrite=pWrite->pNext){
7900 if( pWrite->pTab==pTab && pWrite->eOp==eOp ) break;
7903 pWrite = idxMalloc(&rc, sizeof(IdxWrite));
7904 if( rc==SQLITE_OK ){
7905 pWrite->pTab = pTab;
7907 pWrite->pNext = p->pWrite;
7917 static int idxProcessOneTrigger(
7922 static const char *zInt = UNIQUE_TABLE_NAME;
7923 static const char *zDrop = "DROP TABLE " UNIQUE_TABLE_NAME;
7924 IdxTable *pTab = pWrite->pTab;
7925 const char *zTab = pTab->zName;
7927 "SELECT 'CREATE TEMP' || substr(sql, 7) FROM sqlite_master "
7928 "WHERE tbl_name = %Q AND type IN ('table', 'trigger') "
7930 sqlite3_stmt *pSelect = 0;
7934 /* Create the table and its triggers in the temp schema */
7935 rc = idxPrintfPrepareStmt(p->db, &pSelect, pzErr, zSql, zTab, zTab);
7936 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSelect) ){
7937 const char *zCreate = (const char*)sqlite3_column_text(pSelect, 0);
7938 rc = sqlite3_exec(p->dbv, zCreate, 0, 0, pzErr);
7940 idxFinalize(&rc, pSelect);
7942 /* Rename the table in the temp schema to zInt */
7943 if( rc==SQLITE_OK ){
7944 char *z = sqlite3_mprintf("ALTER TABLE temp.%Q RENAME TO %Q", zTab, zInt);
7948 rc = sqlite3_exec(p->dbv, z, 0, 0, pzErr);
7953 switch( pWrite->eOp ){
7954 case SQLITE_INSERT: {
7956 zWrite = idxAppendText(&rc, zWrite, "INSERT INTO %Q VALUES(", zInt);
7957 for(i=0; i<pTab->nCol; i++){
7958 zWrite = idxAppendText(&rc, zWrite, "%s?", i==0 ? "" : ", ");
7960 zWrite = idxAppendText(&rc, zWrite, ")");
7963 case SQLITE_UPDATE: {
7965 zWrite = idxAppendText(&rc, zWrite, "UPDATE %Q SET ", zInt);
7966 for(i=0; i<pTab->nCol; i++){
7967 zWrite = idxAppendText(&rc, zWrite, "%s%Q=?", i==0 ? "" : ", ",
7974 assert( pWrite->eOp==SQLITE_DELETE );
7975 if( rc==SQLITE_OK ){
7976 zWrite = sqlite3_mprintf("DELETE FROM %Q", zInt);
7977 if( zWrite==0 ) rc = SQLITE_NOMEM;
7982 if( rc==SQLITE_OK ){
7983 sqlite3_stmt *pX = 0;
7984 rc = sqlite3_prepare_v2(p->dbv, zWrite, -1, &pX, 0);
7985 idxFinalize(&rc, pX);
7986 if( rc!=SQLITE_OK ){
7987 idxDatabaseError(p->dbv, pzErr);
7990 sqlite3_free(zWrite);
7992 if( rc==SQLITE_OK ){
7993 rc = sqlite3_exec(p->dbv, zDrop, 0, 0, pzErr);
7999 static int idxProcessTriggers(sqlite3expert *p, char **pzErr){
8002 IdxWrite *pFirst = p->pWrite;
8004 while( rc==SQLITE_OK && pFirst!=pEnd ){
8006 for(pIter=pFirst; rc==SQLITE_OK && pIter!=pEnd; pIter=pIter->pNext){
8007 rc = idxProcessOneTrigger(p, pIter, pzErr);
8017 static int idxCreateVtabSchema(sqlite3expert *p, char **pzErrmsg){
8018 int rc = idxRegisterVtab(p);
8019 sqlite3_stmt *pSchema = 0;
8021 /* For each table in the main db schema:
8023 ** 1) Add an entry to the p->pTable list, and
8024 ** 2) Create the equivalent virtual table in dbv.
8026 rc = idxPrepareStmt(p->db, &pSchema, pzErrmsg,
8027 "SELECT type, name, sql, 1 FROM sqlite_master "
8028 "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%%' "
8030 "SELECT type, name, sql, 2 FROM sqlite_master "
8031 "WHERE type = 'trigger'"
8032 " AND tbl_name IN(SELECT name FROM sqlite_master WHERE type = 'view') "
8035 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSchema) ){
8036 const char *zType = (const char*)sqlite3_column_text(pSchema, 0);
8037 const char *zName = (const char*)sqlite3_column_text(pSchema, 1);
8038 const char *zSql = (const char*)sqlite3_column_text(pSchema, 2);
8040 if( zType[0]=='v' || zType[1]=='r' ){
8041 rc = sqlite3_exec(p->dbv, zSql, 0, 0, pzErrmsg);
8044 rc = idxGetTableInfo(p->db, zName, &pTab, pzErrmsg);
8045 if( rc==SQLITE_OK ){
8049 pTab->pNext = p->pTable;
8052 /* The statement the vtab will pass to sqlite3_declare_vtab() */
8053 zInner = idxAppendText(&rc, 0, "CREATE TABLE x(");
8054 for(i=0; i<pTab->nCol; i++){
8055 zInner = idxAppendText(&rc, zInner, "%s%Q COLLATE %s",
8056 (i==0 ? "" : ", "), pTab->aCol[i].zName, pTab->aCol[i].zColl
8059 zInner = idxAppendText(&rc, zInner, ")");
8061 /* The CVT statement to create the vtab */
8062 zOuter = idxAppendText(&rc, 0,
8063 "CREATE VIRTUAL TABLE %Q USING expert(%Q)", zName, zInner
8065 if( rc==SQLITE_OK ){
8066 rc = sqlite3_exec(p->dbv, zOuter, 0, 0, pzErrmsg);
8068 sqlite3_free(zInner);
8069 sqlite3_free(zOuter);
8073 idxFinalize(&rc, pSchema);
8077 struct IdxSampleCtx {
8079 double target; /* Target nRet/nRow value */
8080 double nRow; /* Number of rows seen */
8081 double nRet; /* Number of rows returned */
8084 static void idxSampleFunc(
8085 sqlite3_context *pCtx,
8087 sqlite3_value **argv
8089 struct IdxSampleCtx *p = (struct IdxSampleCtx*)sqlite3_user_data(pCtx);
8097 bRet = (p->nRet / p->nRow) <= p->target;
8100 sqlite3_randomness(2, (void*)&rnd);
8101 bRet = ((int)rnd % 100) <= p->iTarget;
8105 sqlite3_result_int(pCtx, bRet);
8107 p->nRet += (double)bRet;
8113 int eType; /* SQLITE_NULL, INTEGER, REAL, TEXT, BLOB */
8114 i64 iVal; /* SQLITE_INTEGER value */
8115 double rVal; /* SQLITE_FLOAT value */
8116 int nByte; /* Bytes of space allocated at z */
8117 int n; /* Size of buffer z */
8118 char *z; /* SQLITE_TEXT/BLOB value */
8123 ** Implementation of scalar function rem().
8125 static void idxRemFunc(
8126 sqlite3_context *pCtx,
8128 sqlite3_value **argv
8130 struct IdxRemCtx *p = (struct IdxRemCtx*)sqlite3_user_data(pCtx);
8131 struct IdxRemSlot *pSlot;
8135 iSlot = sqlite3_value_int(argv[0]);
8136 assert( iSlot<=p->nSlot );
8137 pSlot = &p->aSlot[iSlot];
8139 switch( pSlot->eType ){
8144 case SQLITE_INTEGER:
8145 sqlite3_result_int64(pCtx, pSlot->iVal);
8149 sqlite3_result_double(pCtx, pSlot->rVal);
8153 sqlite3_result_blob(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT);
8157 sqlite3_result_text(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT);
8161 pSlot->eType = sqlite3_value_type(argv[1]);
8162 switch( pSlot->eType ){
8167 case SQLITE_INTEGER:
8168 pSlot->iVal = sqlite3_value_int64(argv[1]);
8172 pSlot->rVal = sqlite3_value_double(argv[1]);
8177 int nByte = sqlite3_value_bytes(argv[1]);
8178 if( nByte>pSlot->nByte ){
8179 char *zNew = (char*)sqlite3_realloc(pSlot->z, nByte*2);
8181 sqlite3_result_error_nomem(pCtx);
8184 pSlot->nByte = nByte*2;
8188 if( pSlot->eType==SQLITE_BLOB ){
8189 memcpy(pSlot->z, sqlite3_value_blob(argv[1]), nByte);
8191 memcpy(pSlot->z, sqlite3_value_text(argv[1]), nByte);
8198 static int idxLargestIndex(sqlite3 *db, int *pnMax, char **pzErr){
8201 "SELECT max(i.seqno) FROM "
8202 " sqlite_master AS s, "
8203 " pragma_index_list(s.name) AS l, "
8204 " pragma_index_info(l.name) AS i "
8205 "WHERE s.type = 'table'";
8206 sqlite3_stmt *pMax = 0;
8209 rc = idxPrepareStmt(db, &pMax, pzErr, zMax);
8210 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
8211 *pnMax = sqlite3_column_int(pMax, 0) + 1;
8213 idxFinalize(&rc, pMax);
8218 static int idxPopulateOneStat1(
8220 sqlite3_stmt *pIndexXInfo,
8221 sqlite3_stmt *pWriteStat,
8231 sqlite3_stmt *pQuery = 0;
8235 assert( p->iSample>0 );
8237 /* Formulate the query text */
8238 sqlite3_bind_text(pIndexXInfo, 1, zIdx, -1, SQLITE_STATIC);
8239 while( SQLITE_OK==rc && SQLITE_ROW==sqlite3_step(pIndexXInfo) ){
8240 const char *zComma = zCols==0 ? "" : ", ";
8241 const char *zName = (const char*)sqlite3_column_text(pIndexXInfo, 0);
8242 const char *zColl = (const char*)sqlite3_column_text(pIndexXInfo, 1);
8243 zCols = idxAppendText(&rc, zCols,
8244 "%sx.%Q IS rem(%d, x.%Q) COLLATE %s", zComma, zName, nCol, zName, zColl
8246 zOrder = idxAppendText(&rc, zOrder, "%s%d", zComma, ++nCol);
8248 sqlite3_reset(pIndexXInfo);
8249 if( rc==SQLITE_OK ){
8250 if( p->iSample==100 ){
8251 zQuery = sqlite3_mprintf(
8252 "SELECT %s FROM %Q x ORDER BY %s", zCols, zTab, zOrder
8255 zQuery = sqlite3_mprintf(
8256 "SELECT %s FROM temp."UNIQUE_TABLE_NAME" x ORDER BY %s", zCols, zOrder
8260 sqlite3_free(zCols);
8261 sqlite3_free(zOrder);
8263 /* Formulate the query text */
8264 if( rc==SQLITE_OK ){
8265 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv);
8266 rc = idxPrepareStmt(dbrem, &pQuery, pzErr, zQuery);
8268 sqlite3_free(zQuery);
8270 if( rc==SQLITE_OK ){
8271 aStat = (int*)idxMalloc(&rc, sizeof(int)*(nCol+1));
8273 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){
8274 IdxHashEntry *pEntry;
8276 for(i=0; i<=nCol; i++) aStat[i] = 1;
8277 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){
8279 for(i=0; i<nCol; i++){
8280 if( sqlite3_column_int(pQuery, i)==0 ) break;
8282 for(/*no-op*/; i<nCol; i++){
8287 if( rc==SQLITE_OK ){
8289 zStat = sqlite3_mprintf("%d", s0);
8290 if( zStat==0 ) rc = SQLITE_NOMEM;
8291 for(i=1; rc==SQLITE_OK && i<=nCol; i++){
8292 zStat = idxAppendText(&rc, zStat, " %d", (s0+aStat[i]/2) / aStat[i]);
8296 if( rc==SQLITE_OK ){
8297 sqlite3_bind_text(pWriteStat, 1, zTab, -1, SQLITE_STATIC);
8298 sqlite3_bind_text(pWriteStat, 2, zIdx, -1, SQLITE_STATIC);
8299 sqlite3_bind_text(pWriteStat, 3, zStat, -1, SQLITE_STATIC);
8300 sqlite3_step(pWriteStat);
8301 rc = sqlite3_reset(pWriteStat);
8304 pEntry = idxHashFind(&p->hIdx, zIdx, STRLEN(zIdx));
8306 assert( pEntry->zVal2==0 );
8307 pEntry->zVal2 = zStat;
8309 sqlite3_free(zStat);
8312 sqlite3_free(aStat);
8313 idxFinalize(&rc, pQuery);
8318 static int idxBuildSampleTable(sqlite3expert *p, const char *zTab){
8322 rc = sqlite3_exec(p->dbv,"DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0);
8323 if( rc!=SQLITE_OK ) return rc;
8325 zSql = sqlite3_mprintf(
8326 "CREATE TABLE temp." UNIQUE_TABLE_NAME " AS SELECT * FROM %Q", zTab
8328 if( zSql==0 ) return SQLITE_NOMEM;
8329 rc = sqlite3_exec(p->dbv, zSql, 0, 0, 0);
8336 ** This function is called as part of sqlite3_expert_analyze(). Candidate
8337 ** indexes have already been created in database sqlite3expert.dbm, this
8338 ** function populates sqlite_stat1 table in the same database.
8340 ** The stat1 data is generated by querying the
8342 static int idxPopulateStat1(sqlite3expert *p, char **pzErr){
8345 struct IdxRemCtx *pCtx = 0;
8346 struct IdxSampleCtx samplectx;
8348 i64 iPrev = -100000;
8349 sqlite3_stmt *pAllIndex = 0;
8350 sqlite3_stmt *pIndexXInfo = 0;
8351 sqlite3_stmt *pWrite = 0;
8353 const char *zAllIndex =
8354 "SELECT s.rowid, s.name, l.name FROM "
8355 " sqlite_master AS s, "
8356 " pragma_index_list(s.name) AS l "
8357 "WHERE s.type = 'table'";
8358 const char *zIndexXInfo =
8359 "SELECT name, coll FROM pragma_index_xinfo(?) WHERE key";
8360 const char *zWrite = "INSERT INTO sqlite_stat1 VALUES(?, ?, ?)";
8362 /* If iSample==0, no sqlite_stat1 data is required. */
8363 if( p->iSample==0 ) return SQLITE_OK;
8365 rc = idxLargestIndex(p->dbm, &nMax, pzErr);
8366 if( nMax<=0 || rc!=SQLITE_OK ) return rc;
8368 rc = sqlite3_exec(p->dbm, "ANALYZE; PRAGMA writable_schema=1", 0, 0, 0);
8370 if( rc==SQLITE_OK ){
8371 int nByte = sizeof(struct IdxRemCtx) + (sizeof(struct IdxRemSlot) * nMax);
8372 pCtx = (struct IdxRemCtx*)idxMalloc(&rc, nByte);
8375 if( rc==SQLITE_OK ){
8376 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv);
8377 rc = sqlite3_create_function(
8378 dbrem, "rem", 2, SQLITE_UTF8, (void*)pCtx, idxRemFunc, 0, 0
8381 if( rc==SQLITE_OK ){
8382 rc = sqlite3_create_function(
8383 p->db, "sample", 0, SQLITE_UTF8, (void*)&samplectx, idxSampleFunc, 0, 0
8387 if( rc==SQLITE_OK ){
8388 pCtx->nSlot = nMax+1;
8389 rc = idxPrepareStmt(p->dbm, &pAllIndex, pzErr, zAllIndex);
8391 if( rc==SQLITE_OK ){
8392 rc = idxPrepareStmt(p->dbm, &pIndexXInfo, pzErr, zIndexXInfo);
8394 if( rc==SQLITE_OK ){
8395 rc = idxPrepareStmt(p->dbm, &pWrite, pzErr, zWrite);
8398 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pAllIndex) ){
8399 i64 iRowid = sqlite3_column_int64(pAllIndex, 0);
8400 const char *zTab = (const char*)sqlite3_column_text(pAllIndex, 1);
8401 const char *zIdx = (const char*)sqlite3_column_text(pAllIndex, 2);
8402 if( p->iSample<100 && iPrev!=iRowid ){
8403 samplectx.target = (double)p->iSample / 100.0;
8404 samplectx.iTarget = p->iSample;
8405 samplectx.nRow = 0.0;
8406 samplectx.nRet = 0.0;
8407 rc = idxBuildSampleTable(p, zTab);
8408 if( rc!=SQLITE_OK ) break;
8410 rc = idxPopulateOneStat1(p, pIndexXInfo, pWrite, zTab, zIdx, pzErr);
8413 if( rc==SQLITE_OK && p->iSample<100 ){
8414 rc = sqlite3_exec(p->dbv,
8415 "DROP TABLE IF EXISTS temp." UNIQUE_TABLE_NAME, 0,0,0
8419 idxFinalize(&rc, pAllIndex);
8420 idxFinalize(&rc, pIndexXInfo);
8421 idxFinalize(&rc, pWrite);
8423 for(i=0; i<pCtx->nSlot; i++){
8424 sqlite3_free(pCtx->aSlot[i].z);
8428 if( rc==SQLITE_OK ){
8429 rc = sqlite3_exec(p->dbm, "ANALYZE sqlite_master", 0, 0, 0);
8432 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0);
8437 ** Allocate a new sqlite3expert object.
8439 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErrmsg){
8441 sqlite3expert *pNew;
8443 pNew = (sqlite3expert*)idxMalloc(&rc, sizeof(sqlite3expert));
8445 /* Open two in-memory databases to work with. The "vtab database" (dbv)
8446 ** will contain a virtual table corresponding to each real table in
8447 ** the user database schema, and a copy of each view. It is used to
8448 ** collect information regarding the WHERE, ORDER BY and other clauses
8449 ** of the user's query.
8451 if( rc==SQLITE_OK ){
8453 pNew->iSample = 100;
8454 rc = sqlite3_open(":memory:", &pNew->dbv);
8456 if( rc==SQLITE_OK ){
8457 rc = sqlite3_open(":memory:", &pNew->dbm);
8458 if( rc==SQLITE_OK ){
8459 sqlite3_db_config(pNew->dbm, SQLITE_DBCONFIG_TRIGGER_EQP, 1, (int*)0);
8464 /* Copy the entire schema of database [db] into [dbm]. */
8465 if( rc==SQLITE_OK ){
8467 rc = idxPrintfPrepareStmt(pNew->db, &pSql, pzErrmsg,
8468 "SELECT sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%%'"
8469 " AND sql NOT LIKE 'CREATE VIRTUAL %%'"
8471 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
8472 const char *zSql = (const char*)sqlite3_column_text(pSql, 0);
8473 rc = sqlite3_exec(pNew->dbm, zSql, 0, 0, pzErrmsg);
8475 idxFinalize(&rc, pSql);
8478 /* Create the vtab schema */
8479 if( rc==SQLITE_OK ){
8480 rc = idxCreateVtabSchema(pNew, pzErrmsg);
8483 /* Register the auth callback with dbv */
8484 if( rc==SQLITE_OK ){
8485 sqlite3_set_authorizer(pNew->dbv, idxAuthCallback, (void*)pNew);
8488 /* If an error has occurred, free the new object and reutrn NULL. Otherwise,
8489 ** return the new sqlite3expert handle. */
8490 if( rc!=SQLITE_OK ){
8491 sqlite3_expert_destroy(pNew);
8498 ** Configure an sqlite3expert object.
8500 int sqlite3_expert_config(sqlite3expert *p, int op, ...){
8505 case EXPERT_CONFIG_SAMPLE: {
8506 int iVal = va_arg(ap, int);
8507 if( iVal<0 ) iVal = 0;
8508 if( iVal>100 ) iVal = 100;
8513 rc = SQLITE_NOTFOUND;
8522 ** Add an SQL statement to the analysis.
8524 int sqlite3_expert_sql(
8525 sqlite3expert *p, /* From sqlite3_expert_new() */
8526 const char *zSql, /* SQL statement to add */
8527 char **pzErr /* OUT: Error message (if any) */
8529 IdxScan *pScanOrig = p->pScan;
8530 IdxStatement *pStmtOrig = p->pStatement;
8532 const char *zStmt = zSql;
8534 if( p->bRun ) return SQLITE_MISUSE;
8536 while( rc==SQLITE_OK && zStmt && zStmt[0] ){
8537 sqlite3_stmt *pStmt = 0;
8538 rc = sqlite3_prepare_v2(p->dbv, zStmt, -1, &pStmt, &zStmt);
8539 if( rc==SQLITE_OK ){
8542 const char *z = sqlite3_sql(pStmt);
8544 pNew = (IdxStatement*)idxMalloc(&rc, sizeof(IdxStatement) + n+1);
8545 if( rc==SQLITE_OK ){
8546 pNew->zSql = (char*)&pNew[1];
8547 memcpy(pNew->zSql, z, n+1);
8548 pNew->pNext = p->pStatement;
8549 if( p->pStatement ) pNew->iId = p->pStatement->iId+1;
8550 p->pStatement = pNew;
8552 sqlite3_finalize(pStmt);
8555 idxDatabaseError(p->dbv, pzErr);
8559 if( rc!=SQLITE_OK ){
8560 idxScanFree(p->pScan, pScanOrig);
8561 idxStatementFree(p->pStatement, pStmtOrig);
8562 p->pScan = pScanOrig;
8563 p->pStatement = pStmtOrig;
8569 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr){
8571 IdxHashEntry *pEntry;
8573 /* Do trigger processing to collect any extra IdxScan structures */
8574 rc = idxProcessTriggers(p, pzErr);
8576 /* Create candidate indexes within the in-memory database file */
8577 if( rc==SQLITE_OK ){
8578 rc = idxCreateCandidates(p);
8581 /* Generate the stat1 data */
8582 if( rc==SQLITE_OK ){
8583 rc = idxPopulateStat1(p, pzErr);
8586 /* Formulate the EXPERT_REPORT_CANDIDATES text */
8587 for(pEntry=p->hIdx.pFirst; pEntry; pEntry=pEntry->pNext){
8588 p->zCandidates = idxAppendText(&rc, p->zCandidates,
8589 "%s;%s%s\n", pEntry->zVal,
8590 pEntry->zVal2 ? " -- stat1: " : "", pEntry->zVal2
8594 /* Figure out which of the candidate indexes are preferred by the query
8595 ** planner and report the results to the user. */
8596 if( rc==SQLITE_OK ){
8597 rc = idxFindIndexes(p, pzErr);
8600 if( rc==SQLITE_OK ){
8607 ** Return the total number of statements that have been added to this
8608 ** sqlite3expert using sqlite3_expert_sql().
8610 int sqlite3_expert_count(sqlite3expert *p){
8612 if( p->pStatement ) nRet = p->pStatement->iId+1;
8617 ** Return a component of the report.
8619 const char *sqlite3_expert_report(sqlite3expert *p, int iStmt, int eReport){
8620 const char *zRet = 0;
8621 IdxStatement *pStmt;
8623 if( p->bRun==0 ) return 0;
8624 for(pStmt=p->pStatement; pStmt && pStmt->iId!=iStmt; pStmt=pStmt->pNext);
8626 case EXPERT_REPORT_SQL:
8627 if( pStmt ) zRet = pStmt->zSql;
8629 case EXPERT_REPORT_INDEXES:
8630 if( pStmt ) zRet = pStmt->zIdx;
8632 case EXPERT_REPORT_PLAN:
8633 if( pStmt ) zRet = pStmt->zEQP;
8635 case EXPERT_REPORT_CANDIDATES:
8636 zRet = p->zCandidates;
8643 ** Free an sqlite3expert object.
8645 void sqlite3_expert_destroy(sqlite3expert *p){
8647 sqlite3_close(p->dbm);
8648 sqlite3_close(p->dbv);
8649 idxScanFree(p->pScan, 0);
8650 idxStatementFree(p->pStatement, 0);
8651 idxTableFree(p->pTable);
8652 idxWriteFree(p->pWrite);
8653 idxHashClear(&p->hIdx);
8654 sqlite3_free(p->zCandidates);
8659 #endif /* ifndef SQLITE_OMIT_VIRTUAL_TABLE */
8661 /************************* End ../ext/expert/sqlite3expert.c ********************/
8663 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
8664 /************************* Begin ../ext/misc/dbdata.c ******************/
8668 ** The author disclaims copyright to this source code. In place of
8669 ** a legal notice, here is a blessing:
8671 ** May you do good and not evil.
8672 ** May you find forgiveness for yourself and forgive others.
8673 ** May you share freely, never taking more than you give.
8675 ******************************************************************************
8677 ** This file contains an implementation of two eponymous virtual tables,
8678 ** "sqlite_dbdata" and "sqlite_dbptr". Both modules require that the
8679 ** "sqlite_dbpage" eponymous virtual table be available.
8682 ** sqlite_dbdata is used to extract data directly from a database b-tree
8683 ** page and its associated overflow pages, bypassing the b-tree layer.
8684 ** The table schema is equivalent to:
8686 ** CREATE TABLE sqlite_dbdata(
8691 ** schema TEXT HIDDEN
8694 ** IMPORTANT: THE VIRTUAL TABLE SCHEMA ABOVE IS SUBJECT TO CHANGE. IN THE
8695 ** FUTURE NEW NON-HIDDEN COLUMNS MAY BE ADDED BETWEEN "value" AND
8698 ** Each page of the database is inspected. If it cannot be interpreted as
8699 ** a b-tree page, or if it is a b-tree page containing 0 entries, the
8700 ** sqlite_dbdata table contains no rows for that page. Otherwise, the
8701 ** table contains one row for each field in the record associated with
8702 ** each cell on the page. For intkey b-trees, the key value is stored in
8705 ** For example, for the database:
8707 ** CREATE TABLE t1(a, b); -- root page is page 2
8708 ** INSERT INTO t1(rowid, a, b) VALUES(5, 'v', 'five');
8709 ** INSERT INTO t1(rowid, a, b) VALUES(10, 'x', 'ten');
8711 ** the sqlite_dbdata table contains, as well as from entries related to
8712 ** page 1, content equivalent to:
8714 ** INSERT INTO sqlite_dbdata(pgno, cell, field, value) VALUES
8717 ** (2, 0, 1, 'five'),
8720 ** (2, 1, 1, 'ten' );
8722 ** If database corruption is encountered, this module does not report an
8723 ** error. Instead, it attempts to extract as much data as possible and
8724 ** ignores the corruption.
8727 ** The sqlite_dbptr table has the following schema:
8729 ** CREATE TABLE sqlite_dbptr(
8732 ** schema TEXT HIDDEN
8735 ** It contains one entry for each b-tree pointer between a parent and
8736 ** child page in the database.
8738 #if !defined(SQLITEINT_H)
8739 /* #include "sqlite3ext.h" */
8741 /* typedef unsigned char u8; */
8744 SQLITE_EXTENSION_INIT1
8748 #define DBDATA_PADDING_BYTES 100
8750 typedef struct DbdataTable DbdataTable;
8751 typedef struct DbdataCursor DbdataCursor;
8754 struct DbdataCursor {
8755 sqlite3_vtab_cursor base; /* Base class. Must be first */
8756 sqlite3_stmt *pStmt; /* For fetching database pages */
8758 int iPgno; /* Current page number */
8759 u8 *aPage; /* Buffer containing page */
8760 int nPage; /* Size of aPage[] in bytes */
8761 int nCell; /* Number of cells on aPage[] */
8762 int iCell; /* Current cell number */
8763 int bOnePage; /* True to stop after one page */
8765 sqlite3_int64 iRowid;
8767 /* Only for the sqlite_dbdata table */
8768 u8 *pRec; /* Buffer containing current record */
8769 int nRec; /* Size of pRec[] in bytes */
8770 int nHdr; /* Size of header in bytes */
8771 int iField; /* Current field number */
8775 sqlite3_int64 iIntkey; /* Integer key value */
8779 struct DbdataTable {
8780 sqlite3_vtab base; /* Base class. Must be first */
8781 sqlite3 *db; /* The database connection */
8782 sqlite3_stmt *pStmt; /* For fetching database pages */
8783 int bPtr; /* True for sqlite3_dbptr table */
8786 /* Column and schema definitions for sqlite_dbdata */
8787 #define DBDATA_COLUMN_PGNO 0
8788 #define DBDATA_COLUMN_CELL 1
8789 #define DBDATA_COLUMN_FIELD 2
8790 #define DBDATA_COLUMN_VALUE 3
8791 #define DBDATA_COLUMN_SCHEMA 4
8792 #define DBDATA_SCHEMA \
8798 " schema TEXT HIDDEN" \
8801 /* Column and schema definitions for sqlite_dbptr */
8802 #define DBPTR_COLUMN_PGNO 0
8803 #define DBPTR_COLUMN_CHILD 1
8804 #define DBPTR_COLUMN_SCHEMA 2
8805 #define DBPTR_SCHEMA \
8809 " schema TEXT HIDDEN" \
8813 ** Connect to an sqlite_dbdata (pAux==0) or sqlite_dbptr (pAux!=0) virtual
8816 static int dbdataConnect(
8819 int argc, const char *const*argv,
8820 sqlite3_vtab **ppVtab,
8823 DbdataTable *pTab = 0;
8824 int rc = sqlite3_declare_vtab(db, pAux ? DBPTR_SCHEMA : DBDATA_SCHEMA);
8826 if( rc==SQLITE_OK ){
8827 pTab = (DbdataTable*)sqlite3_malloc64(sizeof(DbdataTable));
8831 memset(pTab, 0, sizeof(DbdataTable));
8833 pTab->bPtr = (pAux!=0);
8837 *ppVtab = (sqlite3_vtab*)pTab;
8842 ** Disconnect from or destroy a sqlite_dbdata or sqlite_dbptr virtual table.
8844 static int dbdataDisconnect(sqlite3_vtab *pVtab){
8845 DbdataTable *pTab = (DbdataTable*)pVtab;
8847 sqlite3_finalize(pTab->pStmt);
8848 sqlite3_free(pVtab);
8854 ** This function interprets two types of constraints:
8859 ** If neither are present, idxNum is set to 0. If schema=? is present,
8860 ** the 0x01 bit in idxNum is set. If pgno=? is present, the 0x02 bit
8861 ** in idxNum is set.
8863 ** If both parameters are present, schema is in position 0 and pgno in
8866 static int dbdataBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdx){
8867 DbdataTable *pTab = (DbdataTable*)tab;
8871 int colSchema = (pTab->bPtr ? DBPTR_COLUMN_SCHEMA : DBDATA_COLUMN_SCHEMA);
8873 for(i=0; i<pIdx->nConstraint; i++){
8874 struct sqlite3_index_constraint *p = &pIdx->aConstraint[i];
8875 if( p->op==SQLITE_INDEX_CONSTRAINT_EQ ){
8876 if( p->iColumn==colSchema ){
8877 if( p->usable==0 ) return SQLITE_CONSTRAINT;
8880 if( p->iColumn==DBDATA_COLUMN_PGNO && p->usable ){
8887 pIdx->aConstraintUsage[iSchema].argvIndex = 1;
8888 pIdx->aConstraintUsage[iSchema].omit = 1;
8891 pIdx->aConstraintUsage[iPgno].argvIndex = 1 + (iSchema>=0);
8892 pIdx->aConstraintUsage[iPgno].omit = 1;
8893 pIdx->estimatedCost = 100;
8894 pIdx->estimatedRows = 50;
8896 if( pTab->bPtr==0 && pIdx->nOrderBy && pIdx->aOrderBy[0].desc==0 ){
8897 int iCol = pIdx->aOrderBy[0].iColumn;
8898 if( pIdx->nOrderBy==1 ){
8899 pIdx->orderByConsumed = (iCol==0 || iCol==1);
8900 }else if( pIdx->nOrderBy==2 && pIdx->aOrderBy[1].desc==0 && iCol==0 ){
8901 pIdx->orderByConsumed = (pIdx->aOrderBy[1].iColumn==1);
8906 pIdx->estimatedCost = 100000000;
8907 pIdx->estimatedRows = 1000000000;
8909 pIdx->idxNum = (iSchema>=0 ? 0x01 : 0x00) | (iPgno>=0 ? 0x02 : 0x00);
8914 ** Open a new sqlite_dbdata or sqlite_dbptr cursor.
8916 static int dbdataOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
8919 pCsr = (DbdataCursor*)sqlite3_malloc64(sizeof(DbdataCursor));
8921 return SQLITE_NOMEM;
8923 memset(pCsr, 0, sizeof(DbdataCursor));
8924 pCsr->base.pVtab = pVTab;
8927 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
8932 ** Restore a cursor object to the state it was in when first allocated
8935 static void dbdataResetCursor(DbdataCursor *pCsr){
8936 DbdataTable *pTab = (DbdataTable*)(pCsr->base.pVtab);
8937 if( pTab->pStmt==0 ){
8938 pTab->pStmt = pCsr->pStmt;
8940 sqlite3_finalize(pCsr->pStmt);
8947 sqlite3_free(pCsr->aPage);
8948 sqlite3_free(pCsr->pRec);
8954 ** Close an sqlite_dbdata or sqlite_dbptr cursor.
8956 static int dbdataClose(sqlite3_vtab_cursor *pCursor){
8957 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
8958 dbdataResetCursor(pCsr);
8964 ** Utility methods to decode 16 and 32-bit big-endian unsigned integers.
8966 static unsigned int get_uint16(unsigned char *a){
8967 return (a[0]<<8)|a[1];
8969 static unsigned int get_uint32(unsigned char *a){
8970 return ((unsigned int)a[0]<<24)
8971 | ((unsigned int)a[1]<<16)
8972 | ((unsigned int)a[2]<<8)
8973 | ((unsigned int)a[3]);
8977 ** Load page pgno from the database via the sqlite_dbpage virtual table.
8978 ** If successful, set (*ppPage) to point to a buffer containing the page
8979 ** data, (*pnPage) to the size of that buffer in bytes and return
8980 ** SQLITE_OK. In this case it is the responsibility of the caller to
8981 ** eventually free the buffer using sqlite3_free().
8983 ** Or, if an error occurs, set both (*ppPage) and (*pnPage) to 0 and
8984 ** return an SQLite error code.
8986 static int dbdataLoadPage(
8987 DbdataCursor *pCsr, /* Cursor object */
8988 unsigned int pgno, /* Page number of page to load */
8989 u8 **ppPage, /* OUT: pointer to page buffer */
8990 int *pnPage /* OUT: Size of (*ppPage) in bytes */
8994 sqlite3_stmt *pStmt = pCsr->pStmt;
8998 sqlite3_bind_int64(pStmt, 2, pgno);
8999 if( SQLITE_ROW==sqlite3_step(pStmt) ){
9000 int nCopy = sqlite3_column_bytes(pStmt, 0);
9003 pPage = (u8*)sqlite3_malloc64(nCopy + DBDATA_PADDING_BYTES);
9007 const u8 *pCopy = sqlite3_column_blob(pStmt, 0);
9008 memcpy(pPage, pCopy, nCopy);
9009 memset(&pPage[nCopy], 0, DBDATA_PADDING_BYTES);
9015 rc2 = sqlite3_reset(pStmt);
9016 if( rc==SQLITE_OK ) rc = rc2;
9022 ** Read a varint. Put the value in *pVal and return the number of bytes.
9024 static int dbdataGetVarint(const u8 *z, sqlite3_int64 *pVal){
9025 sqlite3_int64 v = 0;
9028 v = (v<<7) + (z[i]&0x7f);
9029 if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; }
9031 v = (v<<8) + (z[i]&0xff);
9037 ** Return the number of bytes of space used by an SQLite value of type
9040 static int dbdataValueBytes(int eType){
9042 case 0: case 8: case 9:
9060 return ((eType-12) / 2);
9067 ** Load a value of type eType from buffer pData and use it to set the
9068 ** result of context object pCtx.
9070 static void dbdataValue(
9071 sqlite3_context *pCtx,
9076 if( eType>=0 && dbdataValueBytes(eType)<=nData ){
9081 sqlite3_result_null(pCtx);
9085 sqlite3_result_int(pCtx, 0);
9088 sqlite3_result_int(pCtx, 1);
9091 case 1: case 2: case 3: case 4: case 5: case 6: case 7: {
9092 sqlite3_uint64 v = (signed char)pData[0];
9096 case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
9097 case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
9098 case 4: v = (v<<8) + pData[0]; pData++;
9099 case 3: v = (v<<8) + pData[0]; pData++;
9100 case 2: v = (v<<8) + pData[0]; pData++;
9105 memcpy(&r, &v, sizeof(r));
9106 sqlite3_result_double(pCtx, r);
9108 sqlite3_result_int64(pCtx, (sqlite3_int64)v);
9114 int n = ((eType-12) / 2);
9116 sqlite3_result_text(pCtx, (const char*)pData, n, SQLITE_TRANSIENT);
9118 sqlite3_result_blob(pCtx, pData, n, SQLITE_TRANSIENT);
9126 ** Move an sqlite_dbdata or sqlite_dbptr cursor to the next entry.
9128 static int dbdataNext(sqlite3_vtab_cursor *pCursor){
9129 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9130 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab;
9135 int iOff = (pCsr->iPgno==1 ? 100 : 0);
9138 if( pCsr->aPage==0 ){
9140 if( pCsr->bOnePage==0 && pCsr->iPgno>pCsr->szDb ) return SQLITE_OK;
9141 rc = dbdataLoadPage(pCsr, pCsr->iPgno, &pCsr->aPage, &pCsr->nPage);
9142 if( rc!=SQLITE_OK ) return rc;
9143 if( pCsr->aPage ) break;
9146 pCsr->iCell = pTab->bPtr ? -2 : 0;
9147 pCsr->nCell = get_uint16(&pCsr->aPage[iOff+3]);
9151 if( pCsr->aPage[iOff]!=0x02 && pCsr->aPage[iOff]!=0x05 ){
9152 pCsr->iCell = pCsr->nCell;
9155 if( pCsr->iCell>=pCsr->nCell ){
9156 sqlite3_free(pCsr->aPage);
9158 if( pCsr->bOnePage ) return SQLITE_OK;
9164 /* If there is no record loaded, load it now. */
9165 if( pCsr->pRec==0 ){
9168 sqlite3_int64 nPayload = 0;
9169 sqlite3_int64 nHdr = 0;
9174 switch( pCsr->aPage[iOff] ){
9184 /* This is not a b-tree page with records on it. Continue. */
9185 pCsr->iCell = pCsr->nCell;
9189 if( pCsr->iCell>=pCsr->nCell ){
9193 iOff += 8 + nPointer + pCsr->iCell*2;
9194 if( iOff>pCsr->nPage ){
9197 iOff = get_uint16(&pCsr->aPage[iOff]);
9200 /* For an interior node cell, skip past the child-page number */
9203 /* Load the "byte of payload including overflow" field */
9204 if( bNextPage || iOff>pCsr->nPage ){
9207 iOff += dbdataGetVarint(&pCsr->aPage[iOff], &nPayload);
9210 /* If this is a leaf intkey cell, load the rowid */
9211 if( bHasRowid && !bNextPage && iOff<pCsr->nPage ){
9212 iOff += dbdataGetVarint(&pCsr->aPage[iOff], &pCsr->iIntkey);
9215 /* Figure out how much data to read from the local page */
9220 X = ((U-12)*64/255)-23;
9226 M = ((U-12)*32/255)-23;
9227 K = M+((nPayload-M)%(U-4));
9235 if( bNextPage || nLocal+iOff>pCsr->nPage ){
9239 /* Allocate space for payload. And a bit more to catch small buffer
9240 ** overruns caused by attempting to read a varint or similar from
9241 ** near the end of a corrupt record. */
9242 pCsr->pRec = (u8*)sqlite3_malloc64(nPayload+DBDATA_PADDING_BYTES);
9243 if( pCsr->pRec==0 ) return SQLITE_NOMEM;
9244 memset(pCsr->pRec, 0, nPayload+DBDATA_PADDING_BYTES);
9245 pCsr->nRec = nPayload;
9247 /* Load the nLocal bytes of payload */
9248 memcpy(pCsr->pRec, &pCsr->aPage[iOff], nLocal);
9251 /* Load content from overflow pages */
9252 if( nPayload>nLocal ){
9253 sqlite3_int64 nRem = nPayload - nLocal;
9254 unsigned int pgnoOvfl = get_uint32(&pCsr->aPage[iOff]);
9259 rc = dbdataLoadPage(pCsr, pgnoOvfl, &aOvfl, &nOvfl);
9260 assert( rc!=SQLITE_OK || aOvfl==0 || nOvfl==pCsr->nPage );
9261 if( rc!=SQLITE_OK ) return rc;
9262 if( aOvfl==0 ) break;
9265 if( nCopy>nRem ) nCopy = nRem;
9266 memcpy(&pCsr->pRec[nPayload-nRem], &aOvfl[4], nCopy);
9269 pgnoOvfl = get_uint32(aOvfl);
9270 sqlite3_free(aOvfl);
9274 iHdr = dbdataGetVarint(pCsr->pRec, &nHdr);
9276 pCsr->pHdrPtr = &pCsr->pRec[iHdr];
9277 pCsr->pPtr = &pCsr->pRec[pCsr->nHdr];
9278 pCsr->iField = (bHasRowid ? -1 : 0);
9283 if( pCsr->iField>0 ){
9284 sqlite3_int64 iType;
9285 if( pCsr->pHdrPtr>&pCsr->pRec[pCsr->nRec] ){
9288 pCsr->pHdrPtr += dbdataGetVarint(pCsr->pHdrPtr, &iType);
9289 pCsr->pPtr += dbdataValueBytes(iType);
9295 sqlite3_free(pCsr->aPage);
9296 sqlite3_free(pCsr->pRec);
9299 if( pCsr->bOnePage ) return SQLITE_OK;
9302 if( pCsr->iField<0 || pCsr->pHdrPtr<&pCsr->pRec[pCsr->nHdr] ){
9306 /* Advance to the next cell. The next iteration of the loop will load
9307 ** the record and so on. */
9308 sqlite3_free(pCsr->pRec);
9315 assert( !"can't get here" );
9320 ** Return true if the cursor is at EOF.
9322 static int dbdataEof(sqlite3_vtab_cursor *pCursor){
9323 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9324 return pCsr->aPage==0;
9328 ** Determine the size in pages of database zSchema (where zSchema is
9329 ** "main", "temp" or the name of an attached database) and set
9330 ** pCsr->szDb accordingly. If successful, return SQLITE_OK. Otherwise,
9331 ** an SQLite error code.
9333 static int dbdataDbsize(DbdataCursor *pCsr, const char *zSchema){
9334 DbdataTable *pTab = (DbdataTable*)pCsr->base.pVtab;
9337 sqlite3_stmt *pStmt = 0;
9339 zSql = sqlite3_mprintf("PRAGMA %Q.page_count", zSchema);
9340 if( zSql==0 ) return SQLITE_NOMEM;
9341 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0);
9343 if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
9344 pCsr->szDb = sqlite3_column_int(pStmt, 0);
9346 rc2 = sqlite3_finalize(pStmt);
9347 if( rc==SQLITE_OK ) rc = rc2;
9352 ** xFilter method for sqlite_dbdata and sqlite_dbptr.
9354 static int dbdataFilter(
9355 sqlite3_vtab_cursor *pCursor,
9356 int idxNum, const char *idxStr,
9357 int argc, sqlite3_value **argv
9359 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9360 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab;
9362 const char *zSchema = "main";
9364 dbdataResetCursor(pCsr);
9365 assert( pCsr->iPgno==1 );
9366 if( idxNum & 0x01 ){
9367 zSchema = (const char*)sqlite3_value_text(argv[0]);
9369 if( idxNum & 0x02 ){
9370 pCsr->iPgno = sqlite3_value_int(argv[(idxNum & 0x01)]);
9373 pCsr->nPage = dbdataDbsize(pCsr, zSchema);
9374 rc = dbdataDbsize(pCsr, zSchema);
9377 if( rc==SQLITE_OK ){
9379 pCsr->pStmt = pTab->pStmt;
9382 rc = sqlite3_prepare_v2(pTab->db,
9383 "SELECT data FROM sqlite_dbpage(?) WHERE pgno=?", -1,
9388 if( rc==SQLITE_OK ){
9389 rc = sqlite3_bind_text(pCsr->pStmt, 1, zSchema, -1, SQLITE_TRANSIENT);
9391 pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db));
9393 if( rc==SQLITE_OK ){
9394 rc = dbdataNext(pCursor);
9400 ** Return a column for the sqlite_dbdata or sqlite_dbptr table.
9402 static int dbdataColumn(
9403 sqlite3_vtab_cursor *pCursor,
9404 sqlite3_context *ctx,
9407 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9408 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab;
9411 case DBPTR_COLUMN_PGNO:
9412 sqlite3_result_int64(ctx, pCsr->iPgno);
9414 case DBPTR_COLUMN_CHILD: {
9415 int iOff = pCsr->iPgno==1 ? 100 : 0;
9416 if( pCsr->iCell<0 ){
9419 iOff += 12 + pCsr->iCell*2;
9420 if( iOff>pCsr->nPage ) return SQLITE_OK;
9421 iOff = get_uint16(&pCsr->aPage[iOff]);
9423 if( iOff<=pCsr->nPage ){
9424 sqlite3_result_int64(ctx, get_uint32(&pCsr->aPage[iOff]));
9431 case DBDATA_COLUMN_PGNO:
9432 sqlite3_result_int64(ctx, pCsr->iPgno);
9434 case DBDATA_COLUMN_CELL:
9435 sqlite3_result_int(ctx, pCsr->iCell);
9437 case DBDATA_COLUMN_FIELD:
9438 sqlite3_result_int(ctx, pCsr->iField);
9440 case DBDATA_COLUMN_VALUE: {
9441 if( pCsr->iField<0 ){
9442 sqlite3_result_int64(ctx, pCsr->iIntkey);
9444 sqlite3_int64 iType;
9445 dbdataGetVarint(pCsr->pHdrPtr, &iType);
9447 ctx, iType, pCsr->pPtr, &pCsr->pRec[pCsr->nRec] - pCsr->pPtr
9458 ** Return the rowid for an sqlite_dbdata or sqlite_dptr table.
9460 static int dbdataRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
9461 DbdataCursor *pCsr = (DbdataCursor*)pCursor;
9462 *pRowid = pCsr->iRowid;
9468 ** Invoke this routine to register the "sqlite_dbdata" virtual table module
9470 static int sqlite3DbdataRegister(sqlite3 *db){
9471 static sqlite3_module dbdata_module = {
9474 dbdataConnect, /* xConnect */
9475 dbdataBestIndex, /* xBestIndex */
9476 dbdataDisconnect, /* xDisconnect */
9478 dbdataOpen, /* xOpen - open a cursor */
9479 dbdataClose, /* xClose - close a cursor */
9480 dbdataFilter, /* xFilter - configure scan constraints */
9481 dbdataNext, /* xNext - advance a cursor */
9482 dbdataEof, /* xEof - check for end of scan */
9483 dbdataColumn, /* xColumn - read data */
9484 dbdataRowid, /* xRowid - read data */
9490 0, /* xFindMethod */
9494 0, /* xRollbackTo */
9498 int rc = sqlite3_create_module(db, "sqlite_dbdata", &dbdata_module, 0);
9499 if( rc==SQLITE_OK ){
9500 rc = sqlite3_create_module(db, "sqlite_dbptr", &dbdata_module, (void*)1);
9508 int sqlite3_dbdata_init(
9511 const sqlite3_api_routines *pApi
9513 SQLITE_EXTENSION_INIT2(pApi);
9514 return sqlite3DbdataRegister(db);
9517 /************************* End ../ext/misc/dbdata.c ********************/
9520 #if defined(SQLITE_ENABLE_SESSION)
9522 ** State information for a single open session
9524 typedef struct OpenSession OpenSession;
9525 struct OpenSession {
9526 char *zName; /* Symbolic name for this session */
9527 int nFilter; /* Number of xFilter rejection GLOB patterns */
9528 char **azFilter; /* Array of xFilter rejection GLOB patterns */
9529 sqlite3_session *p; /* The open session */
9534 ** Shell output mode information from before ".explain on",
9535 ** saved so that it can be restored by ".explain off"
9537 typedef struct SavedModeInfo SavedModeInfo;
9538 struct SavedModeInfo {
9539 int valid; /* Is there legit data in here? */
9540 int mode; /* Mode prior to ".explain on" */
9541 int showHeader; /* The ".header" setting prior to ".explain on" */
9542 int colWidth[100]; /* Column widths prior to ".explain on" */
9545 typedef struct ExpertInfo ExpertInfo;
9547 sqlite3expert *pExpert;
9551 /* A single line in the EQP output */
9552 typedef struct EQPGraphRow EQPGraphRow;
9553 struct EQPGraphRow {
9554 int iEqpId; /* ID for this row */
9555 int iParentId; /* ID of the parent row */
9556 EQPGraphRow *pNext; /* Next row in sequence */
9557 char zText[1]; /* Text to display for this row */
9560 /* All EQP output is collected into an instance of the following */
9561 typedef struct EQPGraph EQPGraph;
9563 EQPGraphRow *pRow; /* Linked list of all rows of the EQP output */
9564 EQPGraphRow *pLast; /* Last element of the pRow list */
9565 char zPrefix[100]; /* Graph prefix */
9569 ** State information about the database connection is contained in an
9570 ** instance of the following structure.
9572 typedef struct ShellState ShellState;
9574 sqlite3 *db; /* The database */
9575 u8 autoExplain; /* Automatically turn on .explain mode */
9576 u8 autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
9577 u8 autoEQPtest; /* autoEQP is in test mode */
9578 u8 autoEQPtrace; /* autoEQP is in trace mode */
9579 u8 statsOn; /* True to display memory stats before each finalize */
9580 u8 scanstatsOn; /* True to display scan stats before each finalize */
9581 u8 openMode; /* SHELL_OPEN_NORMAL, _APPENDVFS, or _ZIPFILE */
9582 u8 doXdgOpen; /* Invoke start/open/xdg-open in output_reset() */
9583 u8 nEqpLevel; /* Depth of the EQP output graph */
9584 u8 eTraceType; /* SHELL_TRACE_* value for type of trace */
9585 unsigned mEqpLines; /* Mask of veritical lines in the EQP output graph */
9586 int outCount; /* Revert to stdout when reaching zero */
9587 int cnt; /* Number of records displayed so far */
9588 int lineno; /* Line number of last line read from in */
9589 int openFlags; /* Additional flags to open. (SQLITE_OPEN_NOFOLLOW) */
9590 FILE *in; /* Read commands from this stream */
9591 FILE *out; /* Write results here */
9592 FILE *traceOut; /* Output for sqlite3_trace() */
9593 int nErr; /* Number of errors seen */
9594 int mode; /* An output mode setting */
9595 int modePrior; /* Saved mode */
9596 int cMode; /* temporary output mode for the current query */
9597 int normalMode; /* Output mode before ".explain on" */
9598 int writableSchema; /* True if PRAGMA writable_schema=ON */
9599 int showHeader; /* True to show column names in List or Column mode */
9600 int nCheck; /* Number of ".check" commands run */
9601 unsigned nProgress; /* Number of progress callbacks encountered */
9602 unsigned mxProgress; /* Maximum progress callbacks before failing */
9603 unsigned flgProgress; /* Flags for the progress callback */
9604 unsigned shellFlgs; /* Various flags */
9605 sqlite3_int64 szMax; /* --maxsize argument to .open */
9606 char *zDestTable; /* Name of destination table when MODE_Insert */
9607 char *zTempFile; /* Temporary file that might need deleting */
9608 char zTestcase[30]; /* Name of current test case */
9609 char colSeparator[20]; /* Column separator character for several modes */
9610 char rowSeparator[20]; /* Row separator character for MODE_Ascii */
9611 char colSepPrior[20]; /* Saved column separator */
9612 char rowSepPrior[20]; /* Saved row separator */
9613 int colWidth[100]; /* Requested width of each column when in column mode*/
9614 int actualWidth[100]; /* Actual width of each column */
9615 char nullValue[20]; /* The text to print when a NULL comes back from
9617 char outfile[FILENAME_MAX]; /* Filename for *out */
9618 const char *zDbFilename; /* name of the database file */
9619 char *zFreeOnClose; /* Filename to free when closing */
9620 const char *zVfs; /* Name of VFS to use */
9621 sqlite3_stmt *pStmt; /* Current statement if any. */
9622 FILE *pLog; /* Write log output here */
9623 int *aiIndent; /* Array of indents used in MODE_Explain */
9624 int nIndent; /* Size of array aiIndent[] */
9625 int iIndent; /* Index of current op in aiIndent[] */
9626 EQPGraph sGraph; /* Information for the graphical EXPLAIN QUERY PLAN */
9627 #if defined(SQLITE_ENABLE_SESSION)
9628 int nSession; /* Number of active sessions */
9629 OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */
9631 ExpertInfo expert; /* Valid if previous command was ".expert OPT..." */
9635 /* Allowed values for ShellState.autoEQP
9637 #define AUTOEQP_off 0 /* Automatic EXPLAIN QUERY PLAN is off */
9638 #define AUTOEQP_on 1 /* Automatic EQP is on */
9639 #define AUTOEQP_trigger 2 /* On and also show plans for triggers */
9640 #define AUTOEQP_full 3 /* Show full EXPLAIN */
9642 /* Allowed values for ShellState.openMode
9644 #define SHELL_OPEN_UNSPEC 0 /* No open-mode specified */
9645 #define SHELL_OPEN_NORMAL 1 /* Normal database file */
9646 #define SHELL_OPEN_APPENDVFS 2 /* Use appendvfs */
9647 #define SHELL_OPEN_ZIPFILE 3 /* Use the zipfile virtual table */
9648 #define SHELL_OPEN_READONLY 4 /* Open a normal database read-only */
9649 #define SHELL_OPEN_DESERIALIZE 5 /* Open using sqlite3_deserialize() */
9650 #define SHELL_OPEN_HEXDB 6 /* Use "dbtotxt" output as data source */
9652 /* Allowed values for ShellState.eTraceType
9654 #define SHELL_TRACE_PLAIN 0 /* Show input SQL text */
9655 #define SHELL_TRACE_EXPANDED 1 /* Show expanded SQL text */
9656 #define SHELL_TRACE_NORMALIZED 2 /* Show normalized SQL text */
9658 /* Bits in the ShellState.flgProgress variable */
9659 #define SHELL_PROGRESS_QUIET 0x01 /* Omit announcing every progress callback */
9660 #define SHELL_PROGRESS_RESET 0x02 /* Reset the count when the progres
9661 ** callback limit is reached, and for each
9662 ** top-level SQL statement */
9663 #define SHELL_PROGRESS_ONCE 0x04 /* Cancel the --limit after firing once */
9666 ** These are the allowed shellFlgs values
9668 #define SHFLG_Pagecache 0x00000001 /* The --pagecache option is used */
9669 #define SHFLG_Lookaside 0x00000002 /* Lookaside memory is used */
9670 #define SHFLG_Backslash 0x00000004 /* The --backslash option is used */
9671 #define SHFLG_PreserveRowid 0x00000008 /* .dump preserves rowid values */
9672 #define SHFLG_Newlines 0x00000010 /* .dump --newline flag */
9673 #define SHFLG_CountChanges 0x00000020 /* .changes setting */
9674 #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
9677 ** Macros for testing and setting shellFlgs
9679 #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
9680 #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
9681 #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
9684 ** These are the allowed modes.
9686 #define MODE_Line 0 /* One column per line. Blank line between records */
9687 #define MODE_Column 1 /* One record per line in neat columns */
9688 #define MODE_List 2 /* One record per line with a separator */
9689 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
9690 #define MODE_Html 4 /* Generate an XHTML table */
9691 #define MODE_Insert 5 /* Generate SQL "insert" statements */
9692 #define MODE_Quote 6 /* Quote values as for SQL */
9693 #define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */
9694 #define MODE_Csv 8 /* Quote strings, numbers are plain */
9695 #define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */
9696 #define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */
9697 #define MODE_Pretty 11 /* Pretty-print schemas */
9698 #define MODE_EQP 12 /* Converts EXPLAIN QUERY PLAN output into a graph */
9700 static const char *modeDescr[] = {
9717 ** These are the column/row/line separators used by the various
9718 ** import/export modes.
9720 #define SEP_Column "|"
9721 #define SEP_Row "\n"
9722 #define SEP_Tab "\t"
9723 #define SEP_Space " "
9724 #define SEP_Comma ","
9725 #define SEP_CrLf "\r\n"
9726 #define SEP_Unit "\x1F"
9727 #define SEP_Record "\x1E"
9730 ** A callback for the sqlite3_log() interface.
9732 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
9733 ShellState *p = (ShellState*)pArg;
9734 if( p->pLog==0 ) return;
9735 utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
9740 ** SQL function: shell_putsnl(X)
9742 ** Write the text X to the screen (or whatever output is being directed)
9743 ** adding a newline at the end, and then return X.
9745 static void shellPutsFunc(
9746 sqlite3_context *pCtx,
9748 sqlite3_value **apVal
9750 ShellState *p = (ShellState*)sqlite3_user_data(pCtx);
9752 utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0]));
9753 sqlite3_result_value(pCtx, apVal[0]);
9757 ** SQL function: edit(VALUE)
9758 ** edit(VALUE,EDITOR)
9762 ** (1) Write VALUE into a temporary file.
9763 ** (2) Run program EDITOR on that temporary file.
9764 ** (3) Read the temporary file back and return its content as the result.
9765 ** (4) Delete the temporary file
9767 ** If the EDITOR argument is omitted, use the value in the VISUAL
9768 ** environment variable. If still there is no EDITOR, through an error.
9770 ** Also throw an error if the EDITOR program returns a non-zero exit code.
9772 #ifndef SQLITE_NOHAVE_SYSTEM
9773 static void editFunc(
9774 sqlite3_context *context,
9776 sqlite3_value **argv
9778 const char *zEditor;
9779 char *zTempFile = 0;
9788 unsigned char *p = 0;
9791 zEditor = (const char*)sqlite3_value_text(argv[1]);
9793 zEditor = getenv("VISUAL");
9796 sqlite3_result_error(context, "no editor for edit()", -1);
9799 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
9800 sqlite3_result_error(context, "NULL input to edit()", -1);
9803 db = sqlite3_context_db_handle(context);
9805 sqlite3_file_control(db, 0, SQLITE_FCNTL_TEMPFILENAME, &zTempFile);
9807 sqlite3_uint64 r = 0;
9808 sqlite3_randomness(sizeof(r), &r);
9809 zTempFile = sqlite3_mprintf("temp%llx", r);
9811 sqlite3_result_error_nomem(context);
9815 bBin = sqlite3_value_type(argv[0])==SQLITE_BLOB;
9816 /* When writing the file to be edited, do \n to \r\n conversions on systems
9817 ** that want \r\n line endings */
9818 f = fopen(zTempFile, bBin ? "wb" : "w");
9820 sqlite3_result_error(context, "edit() cannot open temp file", -1);
9823 sz = sqlite3_value_bytes(argv[0]);
9825 x = fwrite(sqlite3_value_blob(argv[0]), 1, (size_t)sz, f);
9827 const char *z = (const char*)sqlite3_value_text(argv[0]);
9828 /* Remember whether or not the value originally contained \r\n */
9829 if( z && strstr(z,"\r\n")!=0 ) hasCRNL = 1;
9830 x = fwrite(sqlite3_value_text(argv[0]), 1, (size_t)sz, f);
9835 sqlite3_result_error(context, "edit() could not write the whole file", -1);
9838 zCmd = sqlite3_mprintf("%s \"%s\"", zEditor, zTempFile);
9840 sqlite3_result_error_nomem(context);
9846 sqlite3_result_error(context, "EDITOR returned non-zero", -1);
9849 f = fopen(zTempFile, "rb");
9851 sqlite3_result_error(context,
9852 "edit() cannot reopen temp file after edit", -1);
9855 fseek(f, 0, SEEK_END);
9858 p = sqlite3_malloc64( sz+1 );
9860 sqlite3_result_error_nomem(context);
9863 x = fread(p, 1, (size_t)sz, f);
9867 sqlite3_result_error(context, "could not read back the whole file", -1);
9871 sqlite3_result_blob64(context, p, sz, sqlite3_free);
9875 /* If the original contains \r\n then do no conversions back to \n */
9878 /* If the file did not originally contain \r\n then convert any new
9879 ** \r\n back into \n */
9880 for(i=j=0; i<sz; i++){
9881 if( p[i]=='\r' && p[i+1]=='\n' ) i++;
9887 sqlite3_result_text64(context, (const char*)p, sz,
9888 sqlite3_free, SQLITE_UTF8);
9895 sqlite3_free(zTempFile);
9898 #endif /* SQLITE_NOHAVE_SYSTEM */
9901 ** Save or restore the current output mode
9903 static void outputModePush(ShellState *p){
9904 p->modePrior = p->mode;
9905 memcpy(p->colSepPrior, p->colSeparator, sizeof(p->colSeparator));
9906 memcpy(p->rowSepPrior, p->rowSeparator, sizeof(p->rowSeparator));
9908 static void outputModePop(ShellState *p){
9909 p->mode = p->modePrior;
9910 memcpy(p->colSeparator, p->colSepPrior, sizeof(p->colSeparator));
9911 memcpy(p->rowSeparator, p->rowSepPrior, sizeof(p->rowSeparator));
9915 ** Output the given string as a hex-encoded blob (eg. X'1234' )
9917 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
9919 char *zBlob = (char *)pBlob;
9920 raw_printf(out,"X'");
9921 for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); }
9922 raw_printf(out,"'");
9926 ** Find a string that is not found anywhere in z[]. Return a pointer
9929 ** Try to use zA and zB first. If both of those are already found in z[]
9930 ** then make up some string and store it in the buffer zBuf.
9932 static const char *unused_string(
9933 const char *z, /* Result must not appear anywhere in z */
9934 const char *zA, const char *zB, /* Try these first */
9935 char *zBuf /* Space to store a generated string */
9938 if( strstr(z, zA)==0 ) return zA;
9939 if( strstr(z, zB)==0 ) return zB;
9941 sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++);
9942 }while( strstr(z,zBuf)!=0 );
9947 ** Output the given string as a quoted string using SQL quoting conventions.
9949 ** See also: output_quoted_escaped_string()
9951 static void output_quoted_string(FILE *out, const char *z){
9954 setBinaryMode(out, 1);
9955 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
9957 utf8_printf(out,"'%s'",z);
9959 raw_printf(out, "'");
9961 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
9964 utf8_printf(out, "%.*s", i, z);
9968 raw_printf(out, "'");
9976 raw_printf(out, "'");
9978 setTextMode(out, 1);
9982 ** Output the given string as a quoted string using SQL quoting conventions.
9983 ** Additionallly , escape the "\n" and "\r" characters so that they do not
9984 ** get corrupted by end-of-line translation facilities in some operating
9987 ** This is like output_quoted_string() but with the addition of the \r\n
9988 ** escape mechanism.
9990 static void output_quoted_escaped_string(FILE *out, const char *z){
9993 setBinaryMode(out, 1);
9994 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
9996 utf8_printf(out,"'%s'",z);
9998 const char *zNL = 0;
9999 const char *zCR = 0;
10002 char zBuf1[20], zBuf2[20];
10003 for(i=0; z[i]; i++){
10004 if( z[i]=='\n' ) nNL++;
10005 if( z[i]=='\r' ) nCR++;
10008 raw_printf(out, "replace(");
10009 zNL = unused_string(z, "\\n", "\\012", zBuf1);
10012 raw_printf(out, "replace(");
10013 zCR = unused_string(z, "\\r", "\\015", zBuf2);
10015 raw_printf(out, "'");
10017 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
10020 utf8_printf(out, "%.*s", i, z);
10024 raw_printf(out, "'");
10032 raw_printf(out, "%s", zNL);
10035 raw_printf(out, "%s", zCR);
10037 raw_printf(out, "'");
10039 raw_printf(out, ",'%s',char(13))", zCR);
10042 raw_printf(out, ",'%s',char(10))", zNL);
10045 setTextMode(out, 1);
10049 ** Output the given string as a quoted according to C or TCL quoting rules.
10051 static void output_c_string(FILE *out, const char *z){
10054 while( (c = *(z++))!=0 ){
10058 }else if( c=='"' ){
10061 }else if( c=='\t' ){
10064 }else if( c=='\n' ){
10067 }else if( c=='\r' ){
10070 }else if( !isprint(c&0xff) ){
10071 raw_printf(out, "\\%03o", c&0xff);
10080 ** Output the given string with characters that are special to
10083 static void output_html_string(FILE *out, const char *z){
10095 utf8_printf(out,"%.*s",i,z);
10098 raw_printf(out,"<");
10099 }else if( z[i]=='&' ){
10100 raw_printf(out,"&");
10101 }else if( z[i]=='>' ){
10102 raw_printf(out,">");
10103 }else if( z[i]=='\"' ){
10104 raw_printf(out,""");
10105 }else if( z[i]=='\'' ){
10106 raw_printf(out,"'");
10115 ** If a field contains any character identified by a 1 in the following
10116 ** array, then the string must be quoted for CSV.
10118 static const char needCsvQuote[] = {
10119 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10120 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10121 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
10122 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10123 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10124 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10125 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10126 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
10127 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10128 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10129 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10130 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10131 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10132 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10133 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10134 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
10138 ** Output a single term of CSV. Actually, p->colSeparator is used for
10139 ** the separator, which may or may not be a comma. p->nullValue is
10140 ** the null value. Strings are quoted if necessary. The separator
10141 ** is only issued if bSep is true.
10143 static void output_csv(ShellState *p, const char *z, int bSep){
10144 FILE *out = p->out;
10146 utf8_printf(out,"%s",p->nullValue);
10149 int nSep = strlen30(p->colSeparator);
10150 for(i=0; z[i]; i++){
10151 if( needCsvQuote[((unsigned char*)z)[i]]
10152 || (z[i]==p->colSeparator[0] &&
10153 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
10159 char *zQuoted = sqlite3_mprintf("\"%w\"", z);
10160 utf8_printf(out, "%s", zQuoted);
10161 sqlite3_free(zQuoted);
10163 utf8_printf(out, "%s", z);
10167 utf8_printf(p->out, "%s", p->colSeparator);
10172 ** This routine runs when the user presses Ctrl-C
10174 static void interrupt_handler(int NotUsed){
10175 UNUSED_PARAMETER(NotUsed);
10177 if( seenInterrupt>2 ) exit(1);
10178 if( globalDb ) sqlite3_interrupt(globalDb);
10181 #if (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE)
10183 ** This routine runs for console events (e.g. Ctrl-C) on Win32
10185 static BOOL WINAPI ConsoleCtrlHandler(
10186 DWORD dwCtrlType /* One of the CTRL_*_EVENT constants */
10188 if( dwCtrlType==CTRL_C_EVENT ){
10189 interrupt_handler(0);
10196 #ifndef SQLITE_OMIT_AUTHORIZATION
10198 ** When the ".auth ON" is set, the following authorizer callback is
10199 ** invoked. It always returns SQLITE_OK.
10201 static int shellAuth(
10209 ShellState *p = (ShellState*)pClientData;
10210 static const char *azAction[] = { 0,
10211 "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX",
10212 "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW",
10213 "CREATE_TRIGGER", "CREATE_VIEW", "DELETE",
10214 "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX",
10215 "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW",
10216 "DROP_TRIGGER", "DROP_VIEW", "INSERT",
10217 "PRAGMA", "READ", "SELECT",
10218 "TRANSACTION", "UPDATE", "ATTACH",
10219 "DETACH", "ALTER_TABLE", "REINDEX",
10220 "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE",
10221 "FUNCTION", "SAVEPOINT", "RECURSIVE"
10229 utf8_printf(p->out, "authorizer: %s", azAction[op]);
10230 for(i=0; i<4; i++){
10231 raw_printf(p->out, " ");
10233 output_c_string(p->out, az[i]);
10235 raw_printf(p->out, "NULL");
10238 raw_printf(p->out, "\n");
10244 ** Print a schema statement. Part of MODE_Semi and MODE_Pretty output.
10246 ** This routine converts some CREATE TABLE statements for shadow tables
10247 ** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements.
10249 static void printSchemaLine(FILE *out, const char *z, const char *zTail){
10251 if( zTail==0 ) return;
10252 if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
10253 utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
10255 utf8_printf(out, "%s%s", z, zTail);
10258 static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){
10261 printSchemaLine(out, z, zTail);
10266 ** Return true if string z[] has nothing but whitespace and comments to the
10267 ** end of the first line.
10269 static int wsToEol(const char *z){
10271 for(i=0; z[i]; i++){
10272 if( z[i]=='\n' ) return 1;
10273 if( IsSpace(z[i]) ) continue;
10274 if( z[i]=='-' && z[i+1]=='-' ) return 1;
10281 ** Add a new entry to the EXPLAIN QUERY PLAN data
10283 static void eqp_append(ShellState *p, int iEqpId, int p2, const char *zText){
10285 int nText = strlen30(zText);
10286 if( p->autoEQPtest ){
10287 utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText);
10289 pNew = sqlite3_malloc64( sizeof(*pNew) + nText );
10290 if( pNew==0 ) shell_out_of_memory();
10291 pNew->iEqpId = iEqpId;
10292 pNew->iParentId = p2;
10293 memcpy(pNew->zText, zText, nText+1);
10295 if( p->sGraph.pLast ){
10296 p->sGraph.pLast->pNext = pNew;
10298 p->sGraph.pRow = pNew;
10300 p->sGraph.pLast = pNew;
10304 ** Free and reset the EXPLAIN QUERY PLAN data that has been collected
10307 static void eqp_reset(ShellState *p){
10308 EQPGraphRow *pRow, *pNext;
10309 for(pRow = p->sGraph.pRow; pRow; pRow = pNext){
10310 pNext = pRow->pNext;
10311 sqlite3_free(pRow);
10313 memset(&p->sGraph, 0, sizeof(p->sGraph));
10316 /* Return the next EXPLAIN QUERY PLAN line with iEqpId that occurs after
10317 ** pOld, or return the first such line if pOld is NULL
10319 static EQPGraphRow *eqp_next_row(ShellState *p, int iEqpId, EQPGraphRow *pOld){
10320 EQPGraphRow *pRow = pOld ? pOld->pNext : p->sGraph.pRow;
10321 while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext;
10325 /* Render a single level of the graph that has iEqpId as its parent. Called
10326 ** recursively to render sublevels.
10328 static void eqp_render_level(ShellState *p, int iEqpId){
10329 EQPGraphRow *pRow, *pNext;
10330 int n = strlen30(p->sGraph.zPrefix);
10332 for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){
10333 pNext = eqp_next_row(p, iEqpId, pRow);
10335 utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix,
10336 pNext ? "|--" : "`--", z);
10337 if( n<(int)sizeof(p->sGraph.zPrefix)-7 ){
10338 memcpy(&p->sGraph.zPrefix[n], pNext ? "| " : " ", 4);
10339 eqp_render_level(p, pRow->iEqpId);
10340 p->sGraph.zPrefix[n] = 0;
10346 ** Display and reset the EXPLAIN QUERY PLAN data
10348 static void eqp_render(ShellState *p){
10349 EQPGraphRow *pRow = p->sGraph.pRow;
10351 if( pRow->zText[0]=='-' ){
10352 if( pRow->pNext==0 ){
10356 utf8_printf(p->out, "%s\n", pRow->zText+3);
10357 p->sGraph.pRow = pRow->pNext;
10358 sqlite3_free(pRow);
10360 utf8_printf(p->out, "QUERY PLAN\n");
10362 p->sGraph.zPrefix[0] = 0;
10363 eqp_render_level(p, 0);
10368 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
10370 ** Progress handler callback.
10372 static int progress_handler(void *pClientData) {
10373 ShellState *p = (ShellState*)pClientData;
10375 if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){
10376 raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress);
10377 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
10378 if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0;
10381 if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){
10382 raw_printf(p->out, "Progress %u\n", p->nProgress);
10386 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
10389 ** This is the callback routine that the shell
10390 ** invokes for each row of a query result.
10392 static int shell_callback(
10394 int nArg, /* Number of result columns */
10395 char **azArg, /* Text of each result column */
10396 char **azCol, /* Column names */
10397 int *aiType /* Column types */
10400 ShellState *p = (ShellState*)pArg;
10402 if( azArg==0 ) return 0;
10403 switch( p->cMode ){
10406 if( azArg==0 ) break;
10407 for(i=0; i<nArg; i++){
10408 int len = strlen30(azCol[i] ? azCol[i] : "");
10409 if( len>w ) w = len;
10411 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
10412 for(i=0; i<nArg; i++){
10413 utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
10414 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
10419 case MODE_Column: {
10420 static const int aExplainWidths[] = {4, 13, 4, 4, 4, 13, 2, 13};
10421 const int *colWidth;
10425 if( p->cMode==MODE_Column ){
10426 colWidth = p->colWidth;
10427 nWidth = ArraySize(p->colWidth);
10428 showHdr = p->showHeader;
10429 rowSep = p->rowSeparator;
10431 colWidth = aExplainWidths;
10432 nWidth = ArraySize(aExplainWidths);
10437 for(i=0; i<nArg; i++){
10445 w = strlenChar(azCol[i] ? azCol[i] : "");
10447 n = strlenChar(azArg && azArg[i] ? azArg[i] : p->nullValue);
10450 if( i<ArraySize(p->actualWidth) ){
10451 p->actualWidth[i] = w;
10454 utf8_width_print(p->out, w, azCol[i]);
10455 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
10459 for(i=0; i<nArg; i++){
10461 if( i<ArraySize(p->actualWidth) ){
10462 w = p->actualWidth[i];
10467 utf8_printf(p->out,"%-*.*s%s",w,w,
10468 "----------------------------------------------------------"
10469 "----------------------------------------------------------",
10470 i==nArg-1 ? rowSep : " ");
10474 if( azArg==0 ) break;
10475 for(i=0; i<nArg; i++){
10477 if( i<ArraySize(p->actualWidth) ){
10478 w = p->actualWidth[i];
10482 if( p->cMode==MODE_Explain && azArg[i] && strlenChar(azArg[i])>w ){
10483 w = strlenChar(azArg[i]);
10485 if( i==1 && p->aiIndent && p->pStmt ){
10486 if( p->iIndent<p->nIndent ){
10487 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
10491 utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue);
10492 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
10496 case MODE_Semi: { /* .schema and .fullschema output */
10497 printSchemaLine(p->out, azArg[0], ";\n");
10500 case MODE_Pretty: { /* .schema and .fullschema with --indent */
10508 if( azArg[0]==0 ) break;
10509 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
10510 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
10512 utf8_printf(p->out, "%s;\n", azArg[0]);
10515 z = sqlite3_mprintf("%s", azArg[0]);
10517 for(i=0; IsSpace(z[i]); i++){}
10518 for(; (c = z[i])!=0; i++){
10520 if( z[j-1]=='\r' ) z[j-1] = '\n';
10521 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue;
10522 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){
10527 while( j>0 && IsSpace(z[j-1]) ){ j--; }
10529 if( strlen30(z)>=79 ){
10530 for(i=j=0; (c = z[i])!=0; i++){ /* Copy from z[i] back to z[j] */
10533 }else if( c=='"' || c=='\'' || c=='`' ){
10535 }else if( c=='[' ){
10537 }else if( c=='-' && z[i+1]=='-' ){
10539 }else if( c=='(' ){
10541 }else if( c==')' ){
10543 if( nLine>0 && nParen==0 && j>0 ){
10544 printSchemaLineN(p->out, z, j, "\n");
10549 if( nParen==1 && cEnd==0
10550 && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1)))
10553 printSchemaLineN(p->out, z, j, "\n ");
10556 while( IsSpace(z[i+1]) ){ i++; }
10561 printSchemaLine(p->out, z, ";\n");
10566 if( p->cnt++==0 && p->showHeader ){
10567 for(i=0; i<nArg; i++){
10568 utf8_printf(p->out,"%s%s",azCol[i],
10569 i==nArg-1 ? p->rowSeparator : p->colSeparator);
10572 if( azArg==0 ) break;
10573 for(i=0; i<nArg; i++){
10574 char *z = azArg[i];
10575 if( z==0 ) z = p->nullValue;
10576 utf8_printf(p->out, "%s", z);
10578 utf8_printf(p->out, "%s", p->colSeparator);
10580 utf8_printf(p->out, "%s", p->rowSeparator);
10586 if( p->cnt++==0 && p->showHeader ){
10587 raw_printf(p->out,"<TR>");
10588 for(i=0; i<nArg; i++){
10589 raw_printf(p->out,"<TH>");
10590 output_html_string(p->out, azCol[i]);
10591 raw_printf(p->out,"</TH>\n");
10593 raw_printf(p->out,"</TR>\n");
10595 if( azArg==0 ) break;
10596 raw_printf(p->out,"<TR>");
10597 for(i=0; i<nArg; i++){
10598 raw_printf(p->out,"<TD>");
10599 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
10600 raw_printf(p->out,"</TD>\n");
10602 raw_printf(p->out,"</TR>\n");
10606 if( p->cnt++==0 && p->showHeader ){
10607 for(i=0; i<nArg; i++){
10608 output_c_string(p->out,azCol[i] ? azCol[i] : "");
10609 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
10611 utf8_printf(p->out, "%s", p->rowSeparator);
10613 if( azArg==0 ) break;
10614 for(i=0; i<nArg; i++){
10615 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
10616 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
10618 utf8_printf(p->out, "%s", p->rowSeparator);
10622 setBinaryMode(p->out, 1);
10623 if( p->cnt++==0 && p->showHeader ){
10624 for(i=0; i<nArg; i++){
10625 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
10627 utf8_printf(p->out, "%s", p->rowSeparator);
10630 for(i=0; i<nArg; i++){
10631 output_csv(p, azArg[i], i<nArg-1);
10633 utf8_printf(p->out, "%s", p->rowSeparator);
10635 setTextMode(p->out, 1);
10638 case MODE_Insert: {
10639 if( azArg==0 ) break;
10640 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
10641 if( p->showHeader ){
10642 raw_printf(p->out,"(");
10643 for(i=0; i<nArg; i++){
10644 if( i>0 ) raw_printf(p->out, ",");
10645 if( quoteChar(azCol[i]) ){
10646 char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
10647 utf8_printf(p->out, "%s", z);
10650 raw_printf(p->out, "%s", azCol[i]);
10653 raw_printf(p->out,")");
10656 for(i=0; i<nArg; i++){
10657 raw_printf(p->out, i>0 ? "," : " VALUES(");
10658 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
10659 utf8_printf(p->out,"NULL");
10660 }else if( aiType && aiType[i]==SQLITE_TEXT ){
10661 if( ShellHasFlag(p, SHFLG_Newlines) ){
10662 output_quoted_string(p->out, azArg[i]);
10664 output_quoted_escaped_string(p->out, azArg[i]);
10666 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
10667 utf8_printf(p->out,"%s", azArg[i]);
10668 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
10670 double r = sqlite3_column_double(p->pStmt, i);
10672 memcpy(&ur,&r,sizeof(r));
10673 if( ur==0x7ff0000000000000LL ){
10674 raw_printf(p->out, "1e999");
10675 }else if( ur==0xfff0000000000000LL ){
10676 raw_printf(p->out, "-1e999");
10678 sqlite3_snprintf(50,z,"%!.20g", r);
10679 raw_printf(p->out, "%s", z);
10681 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
10682 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
10683 int nBlob = sqlite3_column_bytes(p->pStmt, i);
10684 output_hex_blob(p->out, pBlob, nBlob);
10685 }else if( isNumber(azArg[i], 0) ){
10686 utf8_printf(p->out,"%s", azArg[i]);
10687 }else if( ShellHasFlag(p, SHFLG_Newlines) ){
10688 output_quoted_string(p->out, azArg[i]);
10690 output_quoted_escaped_string(p->out, azArg[i]);
10693 raw_printf(p->out,");\n");
10697 if( azArg==0 ) break;
10698 if( p->cnt==0 && p->showHeader ){
10699 for(i=0; i<nArg; i++){
10700 if( i>0 ) raw_printf(p->out, ",");
10701 output_quoted_string(p->out, azCol[i]);
10703 raw_printf(p->out,"\n");
10706 for(i=0; i<nArg; i++){
10707 if( i>0 ) raw_printf(p->out, ",");
10708 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
10709 utf8_printf(p->out,"NULL");
10710 }else if( aiType && aiType[i]==SQLITE_TEXT ){
10711 output_quoted_string(p->out, azArg[i]);
10712 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
10713 utf8_printf(p->out,"%s", azArg[i]);
10714 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
10716 double r = sqlite3_column_double(p->pStmt, i);
10717 sqlite3_snprintf(50,z,"%!.20g", r);
10718 raw_printf(p->out, "%s", z);
10719 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
10720 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
10721 int nBlob = sqlite3_column_bytes(p->pStmt, i);
10722 output_hex_blob(p->out, pBlob, nBlob);
10723 }else if( isNumber(azArg[i], 0) ){
10724 utf8_printf(p->out,"%s", azArg[i]);
10726 output_quoted_string(p->out, azArg[i]);
10729 raw_printf(p->out,"\n");
10733 if( p->cnt++==0 && p->showHeader ){
10734 for(i=0; i<nArg; i++){
10735 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
10736 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
10738 utf8_printf(p->out, "%s", p->rowSeparator);
10740 if( azArg==0 ) break;
10741 for(i=0; i<nArg; i++){
10742 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
10743 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
10745 utf8_printf(p->out, "%s", p->rowSeparator);
10749 eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]);
10757 ** This is the callback routine that the SQLite library
10758 ** invokes for each row of a query result.
10760 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
10761 /* since we don't have type info, call the shell_callback with a NULL value */
10762 return shell_callback(pArg, nArg, azArg, azCol, NULL);
10766 ** This is the callback routine from sqlite3_exec() that appends all
10767 ** output onto the end of a ShellText object.
10769 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
10770 ShellText *p = (ShellText*)pArg;
10772 UNUSED_PARAMETER(az);
10773 if( azArg==0 ) return 0;
10774 if( p->n ) appendText(p, "|", 0);
10775 for(i=0; i<nArg; i++){
10776 if( i ) appendText(p, ",", 0);
10777 if( azArg[i] ) appendText(p, azArg[i], 0);
10783 ** Generate an appropriate SELFTEST table in the main database.
10785 static void createSelftestTable(ShellState *p){
10787 sqlite3_exec(p->db,
10788 "SAVEPOINT selftest_init;\n"
10789 "CREATE TABLE IF NOT EXISTS selftest(\n"
10790 " tno INTEGER PRIMARY KEY,\n" /* Test number */
10791 " op TEXT,\n" /* Operator: memo run */
10792 " cmd TEXT,\n" /* Command text */
10793 " ans TEXT\n" /* Desired answer */
10795 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
10796 "INSERT INTO [_shell$self](rowid,op,cmd)\n"
10797 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
10798 " 'memo','Tests generated by --init');\n"
10799 "INSERT INTO [_shell$self]\n"
10801 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
10802 "FROM sqlite_master ORDER BY 2'',224))',\n"
10803 " hex(sha3_query('SELECT type,name,tbl_name,sql "
10804 "FROM sqlite_master ORDER BY 2',224));\n"
10805 "INSERT INTO [_shell$self]\n"
10807 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
10808 " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
10809 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
10811 " SELECT name FROM sqlite_master\n"
10812 " WHERE type='table'\n"
10813 " AND name<>'selftest'\n"
10814 " AND coalesce(rootpage,0)>0\n"
10816 " ORDER BY name;\n"
10817 "INSERT INTO [_shell$self]\n"
10818 " VALUES('run','PRAGMA integrity_check','ok');\n"
10819 "INSERT INTO selftest(tno,op,cmd,ans)"
10820 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
10821 "DROP TABLE [_shell$self];"
10824 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
10825 sqlite3_free(zErrMsg);
10827 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
10832 ** Set the destination table field of the ShellState structure to
10833 ** the name of the table given. Escape any quote characters in the
10836 static void set_table_name(ShellState *p, const char *zName){
10841 if( p->zDestTable ){
10842 free(p->zDestTable);
10845 if( zName==0 ) return;
10846 cQuote = quoteChar(zName);
10847 n = strlen30(zName);
10848 if( cQuote ) n += n+2;
10849 z = p->zDestTable = malloc( n+1 );
10850 if( z==0 ) shell_out_of_memory();
10852 if( cQuote ) z[n++] = cQuote;
10853 for(i=0; zName[i]; i++){
10855 if( zName[i]==cQuote ) z[n++] = cQuote;
10857 if( cQuote ) z[n++] = cQuote;
10863 ** Execute a query statement that will generate SQL output. Print
10864 ** the result columns, comma-separated, on a line and then add a
10865 ** semicolon terminator to the end of that line.
10867 ** If the number of columns is 1 and that column contains text "--"
10868 ** then write the semicolon on a separate line. That way, if a
10869 ** "--" comment occurs at the end of the statement, the comment
10870 ** won't consume the semicolon terminator.
10872 static int run_table_dump_query(
10873 ShellState *p, /* Query context */
10874 const char *zSelect, /* SELECT statement to extract content */
10875 const char *zFirstRow /* Print before first row, if not NULL */
10877 sqlite3_stmt *pSelect;
10882 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
10883 if( rc!=SQLITE_OK || !pSelect ){
10884 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
10885 sqlite3_errmsg(p->db));
10886 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
10889 rc = sqlite3_step(pSelect);
10890 nResult = sqlite3_column_count(pSelect);
10891 while( rc==SQLITE_ROW ){
10893 utf8_printf(p->out, "%s", zFirstRow);
10896 z = (const char*)sqlite3_column_text(pSelect, 0);
10897 utf8_printf(p->out, "%s", z);
10898 for(i=1; i<nResult; i++){
10899 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
10902 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
10904 raw_printf(p->out, "\n;\n");
10906 raw_printf(p->out, ";\n");
10908 rc = sqlite3_step(pSelect);
10910 rc = sqlite3_finalize(pSelect);
10911 if( rc!=SQLITE_OK ){
10912 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
10913 sqlite3_errmsg(p->db));
10914 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
10920 ** Allocate space and save off current error string.
10922 static char *save_err_msg(
10923 sqlite3 *db /* Database to query */
10925 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
10926 char *zErrMsg = sqlite3_malloc64(nErrMsg);
10928 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
10935 ** Attempt to display I/O stats on Linux using /proc/PID/io
10937 static void displayLinuxIoStats(FILE *out){
10940 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
10941 in = fopen(z, "rb");
10942 if( in==0 ) return;
10943 while( fgets(z, sizeof(z), in)!=0 ){
10944 static const struct {
10945 const char *zPattern;
10948 { "rchar: ", "Bytes received by read():" },
10949 { "wchar: ", "Bytes sent to write():" },
10950 { "syscr: ", "Read() system calls:" },
10951 { "syscw: ", "Write() system calls:" },
10952 { "read_bytes: ", "Bytes read from storage:" },
10953 { "write_bytes: ", "Bytes written to storage:" },
10954 { "cancelled_write_bytes: ", "Cancelled write bytes:" },
10957 for(i=0; i<ArraySize(aTrans); i++){
10958 int n = strlen30(aTrans[i].zPattern);
10959 if( strncmp(aTrans[i].zPattern, z, n)==0 ){
10960 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
10970 ** Display a single line of status using 64-bit values.
10972 static void displayStatLine(
10973 ShellState *p, /* The shell context */
10974 char *zLabel, /* Label for this one line */
10975 char *zFormat, /* Format for the result */
10976 int iStatusCtrl, /* Which status to display */
10977 int bReset /* True to reset the stats */
10979 sqlite3_int64 iCur = -1;
10980 sqlite3_int64 iHiwtr = -1;
10983 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
10984 for(i=0, nPercent=0; zFormat[i]; i++){
10985 if( zFormat[i]=='%' ) nPercent++;
10988 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
10990 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
10992 raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
10996 ** Display memory stats.
10998 static int display_stats(
10999 sqlite3 *db, /* Database to query */
11000 ShellState *pArg, /* Pointer to ShellState */
11001 int bReset /* True to reset the stats */
11006 if( pArg==0 || pArg->out==0 ) return 0;
11009 if( pArg->pStmt && (pArg->statsOn & 2) ){
11011 sqlite3_stmt *pStmt = pArg->pStmt;
11013 nCol = sqlite3_column_count(pStmt);
11014 raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol);
11015 for(i=0; i<nCol; i++){
11016 sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x);
11017 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i));
11018 #ifndef SQLITE_OMIT_DECLTYPE
11019 sqlite3_snprintf(30, z+x, "declared type:");
11020 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
11022 #ifdef SQLITE_ENABLE_COLUMN_METADATA
11023 sqlite3_snprintf(30, z+x, "database name:");
11024 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i));
11025 sqlite3_snprintf(30, z+x, "table name:");
11026 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
11027 sqlite3_snprintf(30, z+x, "origin name:");
11028 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i));
11033 displayStatLine(pArg, "Memory Used:",
11034 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
11035 displayStatLine(pArg, "Number of Outstanding Allocations:",
11036 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
11037 if( pArg->shellFlgs & SHFLG_Pagecache ){
11038 displayStatLine(pArg, "Number of Pcache Pages Used:",
11039 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
11041 displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
11042 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
11043 displayStatLine(pArg, "Largest Allocation:",
11044 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
11045 displayStatLine(pArg, "Largest Pcache Allocation:",
11046 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
11047 #ifdef YYTRACKMAXSTACKDEPTH
11048 displayStatLine(pArg, "Deepest Parser Stack:",
11049 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
11053 if( pArg->shellFlgs & SHFLG_Lookaside ){
11054 iHiwtr = iCur = -1;
11055 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
11056 &iCur, &iHiwtr, bReset);
11057 raw_printf(pArg->out,
11058 "Lookaside Slots Used: %d (max %d)\n",
11060 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
11061 &iCur, &iHiwtr, bReset);
11062 raw_printf(pArg->out, "Successful lookaside attempts: %d\n",
11064 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
11065 &iCur, &iHiwtr, bReset);
11066 raw_printf(pArg->out, "Lookaside failures due to size: %d\n",
11068 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
11069 &iCur, &iHiwtr, bReset);
11070 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n",
11073 iHiwtr = iCur = -1;
11074 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
11075 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n",
11077 iHiwtr = iCur = -1;
11078 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
11079 raw_printf(pArg->out, "Page cache hits: %d\n", iCur);
11080 iHiwtr = iCur = -1;
11081 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
11082 raw_printf(pArg->out, "Page cache misses: %d\n", iCur);
11083 iHiwtr = iCur = -1;
11084 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
11085 raw_printf(pArg->out, "Page cache writes: %d\n", iCur);
11086 iHiwtr = iCur = -1;
11087 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1);
11088 raw_printf(pArg->out, "Page cache spills: %d\n", iCur);
11089 iHiwtr = iCur = -1;
11090 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
11091 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n",
11093 iHiwtr = iCur = -1;
11094 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
11095 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",
11100 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
11102 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur);
11103 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
11104 raw_printf(pArg->out, "Sort Operations: %d\n", iCur);
11105 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
11106 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur);
11107 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
11108 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
11109 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset);
11110 raw_printf(pArg->out, "Reprepare operations: %d\n", iCur);
11111 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset);
11112 raw_printf(pArg->out, "Number of times run: %d\n", iCur);
11113 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset);
11114 raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur);
11118 displayLinuxIoStats(pArg->out);
11121 /* Do not remove this machine readable comment: extra-stats-output-here */
11127 ** Display scan stats.
11129 static void display_scanstats(
11130 sqlite3 *db, /* Database to query */
11131 ShellState *pArg /* Pointer to ShellState */
11133 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
11134 UNUSED_PARAMETER(db);
11135 UNUSED_PARAMETER(pArg);
11138 raw_printf(pArg->out, "-------- scanstats --------\n");
11140 for(k=0; k<=mx; k++){
11141 double rEstLoop = 1.0;
11142 for(i=n=0; 1; i++){
11143 sqlite3_stmt *p = pArg->pStmt;
11144 sqlite3_int64 nLoop, nVisit;
11147 const char *zExplain;
11148 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
11151 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
11152 if( iSid>mx ) mx = iSid;
11153 if( iSid!=k ) continue;
11155 rEstLoop = (double)nLoop;
11156 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k);
11159 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
11160 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
11161 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
11162 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain);
11164 raw_printf(pArg->out,
11165 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
11166 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
11170 raw_printf(pArg->out, "---------------------------\n");
11175 ** Parameter azArray points to a zero-terminated array of strings. zStr
11176 ** points to a single nul-terminated string. Return non-zero if zStr
11177 ** is equal, according to strcmp(), to any of the strings in the array.
11178 ** Otherwise, return zero.
11180 static int str_in_array(const char *zStr, const char **azArray){
11182 for(i=0; azArray[i]; i++){
11183 if( 0==strcmp(zStr, azArray[i]) ) return 1;
11189 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
11190 ** and populate the ShellState.aiIndent[] array with the number of
11191 ** spaces each opcode should be indented before it is output.
11193 ** The indenting rules are:
11195 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
11196 ** all opcodes that occur between the p2 jump destination and the opcode
11197 ** itself by 2 spaces.
11199 ** * For each "Goto", if the jump destination is earlier in the program
11200 ** and ends on one of:
11201 ** Yield SeekGt SeekLt RowSetRead Rewind
11202 ** or if the P1 parameter is one instead of zero,
11203 ** then indent all opcodes between the earlier instruction
11204 ** and "Goto" by 2 spaces.
11206 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
11207 const char *zSql; /* The text of the SQL statement */
11208 const char *z; /* Used to check if this is an EXPLAIN */
11209 int *abYield = 0; /* True if op is an OP_Yield */
11210 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
11211 int iOp; /* Index of operation in p->aiIndent[] */
11213 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 };
11214 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
11216 const char *azGoto[] = { "Goto", 0 };
11218 /* Try to figure out if this is really an EXPLAIN statement. If this
11219 ** cannot be verified, return early. */
11220 if( sqlite3_column_count(pSql)!=8 ){
11221 p->cMode = p->mode;
11224 zSql = sqlite3_sql(pSql);
11225 if( zSql==0 ) return;
11226 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
11227 if( sqlite3_strnicmp(z, "explain", 7) ){
11228 p->cMode = p->mode;
11232 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
11234 int iAddr = sqlite3_column_int(pSql, 0);
11235 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
11237 /* Set p2 to the P2 field of the current opcode. Then, assuming that
11238 ** p2 is an instruction address, set variable p2op to the index of that
11239 ** instruction in the aiIndent[] array. p2 and p2op may be different if
11240 ** the current instruction is part of a sub-program generated by an
11241 ** SQL trigger or foreign key. */
11242 int p2 = sqlite3_column_int(pSql, 3);
11243 int p2op = (p2 + (iOp-iAddr));
11245 /* Grow the p->aiIndent array as required */
11248 /* Do further verfication that this is explain output. Abort if
11250 static const char *explainCols[] = {
11251 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" };
11253 for(jj=0; jj<ArraySize(explainCols); jj++){
11254 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){
11255 p->cMode = p->mode;
11256 sqlite3_reset(pSql);
11262 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
11263 if( p->aiIndent==0 ) shell_out_of_memory();
11264 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
11265 if( abYield==0 ) shell_out_of_memory();
11267 abYield[iOp] = str_in_array(zOp, azYield);
11268 p->aiIndent[iOp] = 0;
11269 p->nIndent = iOp+1;
11271 if( str_in_array(zOp, azNext) ){
11272 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
11274 if( str_in_array(zOp, azGoto) && p2op<p->nIndent
11275 && (abYield[p2op] || sqlite3_column_int(pSql, 2))
11277 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
11282 sqlite3_free(abYield);
11283 sqlite3_reset(pSql);
11287 ** Free the array allocated by explain_data_prepare().
11289 static void explain_data_delete(ShellState *p){
11290 sqlite3_free(p->aiIndent);
11297 ** Disable and restore .wheretrace and .selecttrace settings.
11299 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11300 extern int sqlite3SelectTrace;
11301 static int savedSelectTrace;
11303 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11304 extern int sqlite3WhereTrace;
11305 static int savedWhereTrace;
11307 static void disable_debug_trace_modes(void){
11308 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11309 savedSelectTrace = sqlite3SelectTrace;
11310 sqlite3SelectTrace = 0;
11312 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11313 savedWhereTrace = sqlite3WhereTrace;
11314 sqlite3WhereTrace = 0;
11317 static void restore_debug_trace_modes(void){
11318 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
11319 sqlite3SelectTrace = savedSelectTrace;
11321 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
11322 sqlite3WhereTrace = savedWhereTrace;
11326 /* Create the TEMP table used to store parameter bindings */
11327 static void bind_table_init(ShellState *p){
11329 int defensiveMode = 0;
11330 sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, -1, &defensiveMode);
11331 sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 0, 0);
11332 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema);
11333 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0);
11334 sqlite3_exec(p->db,
11335 "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n"
11336 " key TEXT PRIMARY KEY,\n"
11338 ") WITHOUT ROWID;",
11340 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0);
11341 sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, defensiveMode, 0);
11345 ** Bind parameters on a prepared statement.
11347 ** Parameter bindings are taken from a TEMP table of the form:
11349 ** CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value)
11352 ** No bindings occur if this table does not exist. The special character '$'
11353 ** is included in the table name to help prevent collisions with actual tables.
11354 ** The table must be in the TEMP schema.
11356 static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){
11360 sqlite3_stmt *pQ = 0;
11362 nVar = sqlite3_bind_parameter_count(pStmt);
11363 if( nVar==0 ) return; /* Nothing to do */
11364 if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters",
11365 "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){
11366 return; /* Parameter table does not exist */
11368 rc = sqlite3_prepare_v2(pArg->db,
11369 "SELECT value FROM temp.sqlite_parameters"
11370 " WHERE key=?1", -1, &pQ, 0);
11371 if( rc || pQ==0 ) return;
11372 for(i=1; i<=nVar; i++){
11374 const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
11376 sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i);
11379 sqlite3_bind_text(pQ, 1, zVar, -1, SQLITE_STATIC);
11380 if( sqlite3_step(pQ)==SQLITE_ROW ){
11381 sqlite3_bind_value(pStmt, i, sqlite3_column_value(pQ, 0));
11383 sqlite3_bind_null(pStmt, i);
11387 sqlite3_finalize(pQ);
11391 ** Run a prepared statement
11393 static void exec_prepared_stmt(
11394 ShellState *pArg, /* Pointer to ShellState */
11395 sqlite3_stmt *pStmt /* Statment to run */
11399 /* perform the first step. this will tell us if we
11400 ** have a result set or not and how wide it is.
11402 rc = sqlite3_step(pStmt);
11403 /* if we have a result set... */
11404 if( SQLITE_ROW == rc ){
11405 /* allocate space for col name ptr, value ptr, and type */
11406 int nCol = sqlite3_column_count(pStmt);
11407 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
11411 char **azCols = (char **)pData; /* Names of result columns */
11412 char **azVals = &azCols[nCol]; /* Results */
11413 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
11415 assert(sizeof(int) <= sizeof(char *));
11416 /* save off ptrs to column names */
11417 for(i=0; i<nCol; i++){
11418 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
11421 /* extract the data and data types */
11422 for(i=0; i<nCol; i++){
11423 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
11424 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){
11427 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
11429 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
11431 break; /* from for */
11435 /* if data and types extracted successfully... */
11436 if( SQLITE_ROW == rc ){
11437 /* call the supplied callback with the result row data */
11438 if( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){
11441 rc = sqlite3_step(pStmt);
11444 } while( SQLITE_ROW == rc );
11445 sqlite3_free(pData);
11450 #ifndef SQLITE_OMIT_VIRTUALTABLE
11452 ** This function is called to process SQL if the previous shell command
11453 ** was ".expert". It passes the SQL in the second argument directly to
11454 ** the sqlite3expert object.
11456 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error
11457 ** code. In this case, (*pzErr) may be set to point to a buffer containing
11458 ** an English language error message. It is the responsibility of the
11459 ** caller to eventually free this buffer using sqlite3_free().
11461 static int expertHandleSQL(
11462 ShellState *pState,
11466 assert( pState->expert.pExpert );
11467 assert( pzErr==0 || *pzErr==0 );
11468 return sqlite3_expert_sql(pState->expert.pExpert, zSql, pzErr);
11472 ** This function is called either to silently clean up the object
11473 ** created by the ".expert" command (if bCancel==1), or to generate a
11474 ** report from it and then clean it up (if bCancel==0).
11476 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error
11477 ** code. In this case, (*pzErr) may be set to point to a buffer containing
11478 ** an English language error message. It is the responsibility of the
11479 ** caller to eventually free this buffer using sqlite3_free().
11481 static int expertFinish(
11482 ShellState *pState,
11486 int rc = SQLITE_OK;
11487 sqlite3expert *p = pState->expert.pExpert;
11489 assert( bCancel || pzErr==0 || *pzErr==0 );
11491 FILE *out = pState->out;
11492 int bVerbose = pState->expert.bVerbose;
11494 rc = sqlite3_expert_analyze(p, pzErr);
11495 if( rc==SQLITE_OK ){
11496 int nQuery = sqlite3_expert_count(p);
11500 const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
11501 raw_printf(out, "-- Candidates -----------------------------\n");
11502 raw_printf(out, "%s\n", zCand);
11504 for(i=0; i<nQuery; i++){
11505 const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
11506 const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
11507 const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
11508 if( zIdx==0 ) zIdx = "(no new indexes)\n";
11510 raw_printf(out, "-- Query %d --------------------------------\n",i+1);
11511 raw_printf(out, "%s\n\n", zSql);
11513 raw_printf(out, "%s\n", zIdx);
11514 raw_printf(out, "%s\n", zEQP);
11518 sqlite3_expert_destroy(p);
11519 pState->expert.pExpert = 0;
11524 ** Implementation of ".expert" dot command.
11526 static int expertDotCommand(
11527 ShellState *pState, /* Current shell tool state */
11528 char **azArg, /* Array of arguments passed to dot command */
11529 int nArg /* Number of entries in azArg[] */
11531 int rc = SQLITE_OK;
11536 assert( pState->expert.pExpert==0 );
11537 memset(&pState->expert, 0, sizeof(ExpertInfo));
11539 for(i=1; rc==SQLITE_OK && i<nArg; i++){
11540 char *z = azArg[i];
11542 if( z[0]=='-' && z[1]=='-' ) z++;
11544 if( n>=2 && 0==strncmp(z, "-verbose", n) ){
11545 pState->expert.bVerbose = 1;
11547 else if( n>=2 && 0==strncmp(z, "-sample", n) ){
11549 raw_printf(stderr, "option requires an argument: %s\n", z);
11552 iSample = (int)integerValue(azArg[++i]);
11553 if( iSample<0 || iSample>100 ){
11554 raw_printf(stderr, "value out of range: %s\n", azArg[i]);
11560 raw_printf(stderr, "unknown option: %s\n", z);
11565 if( rc==SQLITE_OK ){
11566 pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr);
11567 if( pState->expert.pExpert==0 ){
11568 raw_printf(stderr, "sqlite3_expert_new: %s\n", zErr);
11571 sqlite3_expert_config(
11572 pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample
11579 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
11582 ** Execute a statement or set of statements. Print
11583 ** any result rows/columns depending on the current mode
11584 ** set via the supplied callback.
11586 ** This is very similar to SQLite's built-in sqlite3_exec()
11587 ** function except it takes a slightly different callback
11588 ** and callback data argument.
11590 static int shell_exec(
11591 ShellState *pArg, /* Pointer to ShellState */
11592 const char *zSql, /* SQL to be evaluated */
11593 char **pzErrMsg /* Error msg written here */
11595 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
11596 int rc = SQLITE_OK; /* Return Code */
11598 const char *zLeftover; /* Tail of unprocessed SQL */
11599 sqlite3 *db = pArg->db;
11605 #ifndef SQLITE_OMIT_VIRTUALTABLE
11606 if( pArg->expert.pExpert ){
11607 rc = expertHandleSQL(pArg, zSql, pzErrMsg);
11608 return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg);
11612 while( zSql[0] && (SQLITE_OK == rc) ){
11613 static const char *zStmtSql;
11614 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
11615 if( SQLITE_OK != rc ){
11617 *pzErrMsg = save_err_msg(db);
11621 /* this happens for a comment or white-space */
11623 while( IsSpace(zSql[0]) ) zSql++;
11626 zStmtSql = sqlite3_sql(pStmt);
11627 if( zStmtSql==0 ) zStmtSql = "";
11628 while( IsSpace(zStmtSql[0]) ) zStmtSql++;
11630 /* save off the prepared statment handle and reset row count */
11632 pArg->pStmt = pStmt;
11636 /* echo the sql statement if echo on */
11637 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
11638 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
11641 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
11642 if( pArg && pArg->autoEQP && sqlite3_stmt_isexplain(pStmt)==0 ){
11643 sqlite3_stmt *pExplain;
11645 int triggerEQP = 0;
11646 disable_debug_trace_modes();
11647 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP);
11648 if( pArg->autoEQP>=AUTOEQP_trigger ){
11649 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0);
11651 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql);
11652 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
11653 if( rc==SQLITE_OK ){
11654 while( sqlite3_step(pExplain)==SQLITE_ROW ){
11655 const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3);
11656 int iEqpId = sqlite3_column_int(pExplain, 0);
11657 int iParentId = sqlite3_column_int(pExplain, 1);
11658 if( zEQPLine[0]=='-' ) eqp_render(pArg);
11659 eqp_append(pArg, iEqpId, iParentId, zEQPLine);
11663 sqlite3_finalize(pExplain);
11664 sqlite3_free(zEQP);
11665 if( pArg->autoEQP>=AUTOEQP_full ){
11666 /* Also do an EXPLAIN for ".eqp full" mode */
11667 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql);
11668 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
11669 if( rc==SQLITE_OK ){
11670 pArg->cMode = MODE_Explain;
11671 explain_data_prepare(pArg, pExplain);
11672 exec_prepared_stmt(pArg, pExplain);
11673 explain_data_delete(pArg);
11675 sqlite3_finalize(pExplain);
11676 sqlite3_free(zEQP);
11678 if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){
11679 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0);
11680 /* Reprepare pStmt before reactiving trace modes */
11681 sqlite3_finalize(pStmt);
11682 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
11683 if( pArg ) pArg->pStmt = pStmt;
11685 restore_debug_trace_modes();
11689 pArg->cMode = pArg->mode;
11690 if( pArg->autoExplain ){
11691 if( sqlite3_stmt_isexplain(pStmt)==1 ){
11692 pArg->cMode = MODE_Explain;
11694 if( sqlite3_stmt_isexplain(pStmt)==2 ){
11695 pArg->cMode = MODE_EQP;
11699 /* If the shell is currently in ".explain" mode, gather the extra
11700 ** data required to add indents to the output.*/
11701 if( pArg->cMode==MODE_Explain ){
11702 explain_data_prepare(pArg, pStmt);
11706 bind_prepared_stmt(pArg, pStmt);
11707 exec_prepared_stmt(pArg, pStmt);
11708 explain_data_delete(pArg);
11711 /* print usage stats if stats on */
11712 if( pArg && pArg->statsOn ){
11713 display_stats(db, pArg, 0);
11716 /* print loop-counters if required */
11717 if( pArg && pArg->scanstatsOn ){
11718 display_scanstats(db, pArg);
11721 /* Finalize the statement just executed. If this fails, save a
11722 ** copy of the error message. Otherwise, set zSql to point to the
11723 ** next statement to execute. */
11724 rc2 = sqlite3_finalize(pStmt);
11725 if( rc!=SQLITE_NOMEM ) rc = rc2;
11726 if( rc==SQLITE_OK ){
11728 while( IsSpace(zSql[0]) ) zSql++;
11729 }else if( pzErrMsg ){
11730 *pzErrMsg = save_err_msg(db);
11733 /* clear saved stmt handle */
11735 pArg->pStmt = NULL;
11744 ** Release memory previously allocated by tableColumnList().
11746 static void freeColumnList(char **azCol){
11748 for(i=1; azCol[i]; i++){
11749 sqlite3_free(azCol[i]);
11751 /* azCol[0] is a static string */
11752 sqlite3_free(azCol);
11756 ** Return a list of pointers to strings which are the names of all
11757 ** columns in table zTab. The memory to hold the names is dynamically
11758 ** allocated and must be released by the caller using a subsequent call
11759 ** to freeColumnList().
11761 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
11762 ** value that needs to be preserved, then azCol[0] is filled in with the
11763 ** name of the rowid column.
11765 ** The first regular column in the table is azCol[1]. The list is terminated
11766 ** by an entry with azCol[i]==0.
11768 static char **tableColumnList(ShellState *p, const char *zTab){
11770 sqlite3_stmt *pStmt;
11774 int nPK = 0; /* Number of PRIMARY KEY columns seen */
11775 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
11776 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
11779 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
11780 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
11781 sqlite3_free(zSql);
11783 while( sqlite3_step(pStmt)==SQLITE_ROW ){
11784 if( nCol>=nAlloc-2 ){
11785 nAlloc = nAlloc*2 + nCol + 10;
11786 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
11787 if( azCol==0 ) shell_out_of_memory();
11789 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
11790 if( sqlite3_column_int(pStmt, 5) ){
11793 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
11802 sqlite3_finalize(pStmt);
11803 if( azCol==0 ) return 0;
11807 /* The decision of whether or not a rowid really needs to be preserved
11808 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
11809 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
11810 ** rowids on tables where the rowid is inaccessible because there are other
11811 ** columns in the table named "rowid", "_rowid_", and "oid".
11813 if( preserveRowid && isIPK ){
11814 /* If a single PRIMARY KEY column with type INTEGER was seen, then it
11815 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
11816 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
11817 ** ROWID aliases. To distinguish these cases, check to see if
11818 ** there is a "pk" entry in "PRAGMA index_list". There will be
11819 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
11821 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
11822 " WHERE origin='pk'", zTab);
11823 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
11824 sqlite3_free(zSql);
11826 freeColumnList(azCol);
11829 rc = sqlite3_step(pStmt);
11830 sqlite3_finalize(pStmt);
11831 preserveRowid = rc==SQLITE_ROW;
11833 if( preserveRowid ){
11834 /* Only preserve the rowid if we can find a name to use for the
11836 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
11838 for(j=0; j<3; j++){
11839 for(i=1; i<=nCol; i++){
11840 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
11843 /* At this point, we know that azRowid[j] is not the name of any
11844 ** ordinary column in the table. Verify that azRowid[j] is a valid
11845 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
11846 ** tables will fail this last check */
11847 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
11848 if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
11857 ** Toggle the reverse_unordered_selects setting.
11859 static void toggleSelectOrder(sqlite3 *db){
11860 sqlite3_stmt *pStmt = 0;
11863 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
11864 if( sqlite3_step(pStmt)==SQLITE_ROW ){
11865 iSetting = sqlite3_column_int(pStmt, 0);
11867 sqlite3_finalize(pStmt);
11868 sqlite3_snprintf(sizeof(zStmt), zStmt,
11869 "PRAGMA reverse_unordered_selects(%d)", !iSetting);
11870 sqlite3_exec(db, zStmt, 0, 0, 0);
11874 ** This is a different callback routine used for dumping the database.
11875 ** Each row received by this callback consists of a table name,
11876 ** the table type ("index" or "table") and SQL to create the table.
11877 ** This routine should print text sufficient to recreate the table.
11879 static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
11881 const char *zTable;
11884 ShellState *p = (ShellState *)pArg;
11886 UNUSED_PARAMETER(azNotUsed);
11887 if( nArg!=3 || azArg==0 ) return 0;
11892 if( strcmp(zTable, "sqlite_sequence")==0 ){
11893 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
11894 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
11895 raw_printf(p->out, "ANALYZE sqlite_master;\n");
11896 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
11898 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
11900 if( !p->writableSchema ){
11901 raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
11902 p->writableSchema = 1;
11904 zIns = sqlite3_mprintf(
11905 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
11906 "VALUES('table','%q','%q',0,'%q');",
11907 zTable, zTable, zSql);
11908 utf8_printf(p->out, "%s\n", zIns);
11909 sqlite3_free(zIns);
11912 printSchemaLine(p->out, zSql, ";\n");
11915 if( strcmp(zType, "table")==0 ){
11920 char *savedDestTable;
11923 azCol = tableColumnList(p, zTable);
11929 /* Always quote the table name, even if it appears to be pure ascii,
11930 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
11932 appendText(&sTable, zTable, quoteChar(zTable));
11933 /* If preserving the rowid, add a column list after the table name.
11934 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
11935 ** instead of the usual "INSERT INTO tab VALUES(...)".
11938 appendText(&sTable, "(", 0);
11939 appendText(&sTable, azCol[0], 0);
11940 for(i=1; azCol[i]; i++){
11941 appendText(&sTable, ",", 0);
11942 appendText(&sTable, azCol[i], quoteChar(azCol[i]));
11944 appendText(&sTable, ")", 0);
11947 /* Build an appropriate SELECT statement */
11948 initText(&sSelect);
11949 appendText(&sSelect, "SELECT ", 0);
11951 appendText(&sSelect, azCol[0], 0);
11952 appendText(&sSelect, ",", 0);
11954 for(i=1; azCol[i]; i++){
11955 appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
11957 appendText(&sSelect, ",", 0);
11960 freeColumnList(azCol);
11961 appendText(&sSelect, " FROM ", 0);
11962 appendText(&sSelect, zTable, quoteChar(zTable));
11964 savedDestTable = p->zDestTable;
11965 savedMode = p->mode;
11966 p->zDestTable = sTable.z;
11967 p->mode = p->cMode = MODE_Insert;
11968 rc = shell_exec(p, sSelect.z, 0);
11969 if( (rc&0xff)==SQLITE_CORRUPT ){
11970 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
11971 toggleSelectOrder(p->db);
11972 shell_exec(p, sSelect.z, 0);
11973 toggleSelectOrder(p->db);
11975 p->zDestTable = savedDestTable;
11976 p->mode = savedMode;
11978 freeText(&sSelect);
11979 if( rc ) p->nErr++;
11985 ** Run zQuery. Use dump_callback() as the callback routine so that
11986 ** the contents of the query are output as SQL statements.
11988 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
11989 ** "ORDER BY rowid DESC" to the end.
11991 static int run_schema_dump_query(
11997 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
11998 if( rc==SQLITE_CORRUPT ){
12000 int len = strlen30(zQuery);
12001 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
12003 utf8_printf(p->out, "/****** %s ******/\n", zErr);
12004 sqlite3_free(zErr);
12007 zQ2 = malloc( len+100 );
12008 if( zQ2==0 ) return rc;
12009 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
12010 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
12012 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr);
12014 rc = SQLITE_CORRUPT;
12016 sqlite3_free(zErr);
12023 ** Text of help messages.
12025 ** The help text for each individual command begins with a line that starts
12026 ** with ".". Subsequent lines are supplimental information.
12028 ** There must be two or more spaces between the end of the command and the
12029 ** start of the description of what that command does.
12031 static const char *(azHelp[]) = {
12032 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
12033 ".archive ... Manage SQL archives",
12034 " Each command must have exactly one of the following options:",
12035 " -c, --create Create a new archive",
12036 " -u, --update Add or update files with changed mtime",
12037 " -i, --insert Like -u but always add even if unchanged",
12038 " -t, --list List contents of archive",
12039 " -x, --extract Extract files from archive",
12040 " Optional arguments:",
12041 " -v, --verbose Print each filename as it is processed",
12042 " -f FILE, --file FILE Use archive FILE (default is current db)",
12043 " -a FILE, --append FILE Open FILE using the apndvfs VFS",
12044 " -C DIR, --directory DIR Read/extract files from directory DIR",
12045 " -n, --dryrun Show the SQL that would have occurred",
12047 " .ar -cf ARCHIVE foo bar # Create ARCHIVE from files foo and bar",
12048 " .ar -tf ARCHIVE # List members of ARCHIVE",
12049 " .ar -xvf ARCHIVE # Verbosely extract files from ARCHIVE",
12051 " http://sqlite.org/cli.html#sqlar_archive_support",
12053 #ifndef SQLITE_OMIT_AUTHORIZATION
12054 ".auth ON|OFF Show authorizer callbacks",
12056 ".backup ?DB? FILE Backup DB (default \"main\") to FILE",
12057 " --append Use the appendvfs",
12058 " --async Write to FILE without journal and fsync()",
12059 ".bail on|off Stop after hitting an error. Default OFF",
12060 ".binary on|off Turn binary output on or off. Default OFF",
12061 ".cd DIRECTORY Change the working directory to DIRECTORY",
12062 ".changes on|off Show number of rows changed by SQL",
12063 ".check GLOB Fail if output since .testcase does not match",
12064 ".clone NEWDB Clone data into NEWDB from the existing database",
12065 ".databases List names and files of attached databases",
12066 ".dbconfig ?op? ?val? List or change sqlite3_db_config() options",
12067 ".dbinfo ?DB? Show status information about the database",
12068 ".dump ?TABLE? ... Render all database content as SQL",
12070 " --preserve-rowids Include ROWID values in the output",
12071 " --newlines Allow unescaped newline characters in output",
12072 " TABLE is a LIKE pattern for the tables to dump",
12073 ".echo on|off Turn command echo on or off",
12074 ".eqp on|off|full|... Enable or disable automatic EXPLAIN QUERY PLAN",
12076 #ifdef SQLITE_DEBUG
12077 " test Show raw EXPLAIN QUERY PLAN output",
12078 " trace Like \"full\" but enable \"PRAGMA vdbe_trace\"",
12080 " trigger Like \"full\" but also show trigger bytecode",
12081 ".excel Display the output of next command in spreadsheet",
12082 ".exit ?CODE? Exit this program with return-code CODE",
12083 ".expert EXPERIMENTAL. Suggest indexes for queries",
12084 ".explain ?on|off|auto? Change the EXPLAIN formatting mode. Default: auto",
12085 ".filectrl CMD ... Run various sqlite3_file_control() operations",
12086 " Run \".filectrl\" with no arguments for details",
12087 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables",
12088 ".headers on|off Turn display of headers on or off",
12089 ".help ?-all? ?PATTERN? Show help text for PATTERN",
12090 ".import FILE TABLE Import data from FILE into TABLE",
12091 #ifndef SQLITE_OMIT_TEST_CONTROL
12092 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX",
12094 ".indexes ?TABLE? Show names of indexes",
12095 " If TABLE is specified, only show indexes for",
12096 " tables matching TABLE using the LIKE operator.",
12097 #ifdef SQLITE_ENABLE_IOTRACE
12098 ".iotrace FILE Enable I/O diagnostic logging to FILE",
12100 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT",
12101 ".lint OPTIONS Report potential schema issues.",
12103 " fkey-indexes Find missing foreign key indexes",
12104 #ifndef SQLITE_OMIT_LOAD_EXTENSION
12105 ".load FILE ?ENTRY? Load an extension library",
12107 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout",
12108 ".mode MODE ?TABLE? Set output mode",
12109 " MODE is one of:",
12110 " ascii Columns/rows delimited by 0x1F and 0x1E",
12111 " csv Comma-separated values",
12112 " column Left-aligned columns. (See .width)",
12113 " html HTML <table> code",
12114 " insert SQL insert statements for TABLE",
12115 " line One value per line",
12116 " list Values delimited by \"|\"",
12117 " quote Escape answers as for SQL",
12118 " tabs Tab-separated values",
12119 " tcl TCL list elements",
12120 ".nullvalue STRING Use STRING in place of NULL values",
12121 ".once (-e|-x|FILE) Output for the next SQL command only to FILE",
12122 " If FILE begins with '|' then open as a pipe",
12124 " -e Invoke system text editor",
12125 " -x Open in a spreadsheet",
12126 ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE",
12128 " --append Use appendvfs to append database to the end of FILE",
12129 #ifdef SQLITE_ENABLE_DESERIALIZE
12130 " --deserialize Load into memory useing sqlite3_deserialize()",
12131 " --hexdb Load the output of \"dbtotxt\" as an in-memory db",
12132 " --maxsize N Maximum size for --hexdb or --deserialized database",
12134 " --new Initialize FILE to an empty database",
12135 " --nofollow Do not follow symbolic links",
12136 " --readonly Open FILE readonly",
12137 " --zip FILE is a ZIP archive",
12138 ".output ?FILE? Send output to FILE or stdout if FILE is omitted",
12139 " If FILE begins with '|' then open it as a pipe.",
12140 ".parameter CMD ... Manage SQL parameter bindings",
12141 " clear Erase all bindings",
12142 " init Initialize the TEMP table that holds bindings",
12143 " list List the current parameter bindings",
12144 " set PARAMETER VALUE Given SQL parameter PARAMETER a value of VALUE",
12145 " PARAMETER should start with one of: $ : @ ?",
12146 " unset PARAMETER Remove PARAMETER from the binding table",
12147 ".print STRING... Print literal STRING",
12148 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
12149 ".progress N Invoke progress handler after every N opcodes",
12150 " --limit N Interrupt after N progress callbacks",
12151 " --once Do no more than one progress interrupt",
12152 " --quiet|-q No output except at interrupts",
12153 " --reset Reset the count for each input and interrupt",
12155 ".prompt MAIN CONTINUE Replace the standard prompts",
12156 ".quit Exit this program",
12157 ".read FILE Read input from FILE",
12158 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
12159 ".recover Recover as much data as possible from corrupt db.",
12160 " --freelist-corrupt Assume the freelist is corrupt",
12161 " --recovery-db NAME Store recovery metadata in database file NAME",
12162 " --lost-and-found TABLE Alternative name for the lost-and-found table",
12163 " --no-rowids Do not attempt to recover rowid values",
12164 " that are not also INTEGER PRIMARY KEYs",
12166 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE",
12167 ".save FILE Write in-memory database into FILE",
12168 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off",
12169 ".schema ?PATTERN? Show the CREATE statements matching PATTERN",
12171 " --indent Try to pretty-print the schema",
12172 ".selftest ?OPTIONS? Run tests defined in the SELFTEST table",
12174 " --init Create a new SELFTEST table",
12175 " -v Verbose output",
12176 ".separator COL ?ROW? Change the column and row separators",
12177 #if defined(SQLITE_ENABLE_SESSION)
12178 ".session ?NAME? CMD ... Create or control sessions",
12180 " attach TABLE Attach TABLE",
12181 " changeset FILE Write a changeset into FILE",
12182 " close Close one session",
12183 " enable ?BOOLEAN? Set or query the enable bit",
12184 " filter GLOB... Reject tables matching GLOBs",
12185 " indirect ?BOOLEAN? Mark or query the indirect status",
12186 " isempty Query whether the session is empty",
12187 " list List currently open session names",
12188 " open DB NAME Open a new session on DB",
12189 " patchset FILE Write a patchset into FILE",
12190 " If ?NAME? is omitted, the first defined session is used.",
12192 ".sha3sum ... Compute a SHA3 hash of database content",
12194 " --schema Also hash the sqlite_master table",
12195 " --sha3-224 Use the sha3-224 algorithm",
12196 " --sha3-256 Use the sha3-256 algorithm (default)",
12197 " --sha3-384 Use the sha3-384 algorithm",
12198 " --sha3-512 Use the sha3-512 algorithm",
12199 " Any other argument is a LIKE pattern for tables to hash",
12200 #ifndef SQLITE_NOHAVE_SYSTEM
12201 ".shell CMD ARGS... Run CMD ARGS... in a system shell",
12203 ".show Show the current values for various settings",
12204 ".stats ?on|off? Show stats or turn stats on or off",
12205 #ifndef SQLITE_NOHAVE_SYSTEM
12206 ".system CMD ARGS... Run CMD ARGS... in a system shell",
12208 ".tables ?TABLE? List names of tables matching LIKE pattern TABLE",
12209 ".testcase NAME Begin redirecting output to 'testcase-out.txt'",
12210 ".testctrl CMD ... Run various sqlite3_test_control() operations",
12211 " Run \".testctrl\" with no arguments for details",
12212 ".timeout MS Try opening locked tables for MS milliseconds",
12213 ".timer on|off Turn SQL timer on or off",
12214 #ifndef SQLITE_OMIT_TRACE
12215 ".trace ?OPTIONS? Output each SQL statement as it is run",
12216 " FILE Send output to FILE",
12217 " stdout Send output to stdout",
12218 " stderr Send output to stderr",
12219 " off Disable tracing",
12220 " --expanded Expand query parameters",
12221 #ifdef SQLITE_ENABLE_NORMALIZE
12222 " --normalized Normal the SQL statements",
12224 " --plain Show SQL as it is input",
12225 " --stmt Trace statement execution (SQLITE_TRACE_STMT)",
12226 " --profile Profile statements (SQLITE_TRACE_PROFILE)",
12227 " --row Trace each row (SQLITE_TRACE_ROW)",
12228 " --close Trace connection close (SQLITE_TRACE_CLOSE)",
12229 #endif /* SQLITE_OMIT_TRACE */
12230 #ifdef SQLITE_DEBUG
12231 ".unmodule NAME ... Unregister virtual table modules",
12232 " --allexcept Unregister everything except those named",
12234 ".vfsinfo ?AUX? Information about the top-level VFS",
12235 ".vfslist List all available VFSes",
12236 ".vfsname ?AUX? Print the name of the VFS stack",
12237 ".width NUM1 NUM2 ... Set column widths for \"column\" mode",
12238 " Negative values right-justify",
12242 ** Output help text.
12244 ** zPattern describes the set of commands for which help text is provided.
12245 ** If zPattern is NULL, then show all commands, but only give a one-line
12246 ** description of each.
12248 ** Return the number of matches.
12250 static int showHelp(FILE *out, const char *zPattern){
12256 || zPattern[0]=='0'
12257 || strcmp(zPattern,"-a")==0
12258 || strcmp(zPattern,"-all")==0
12260 /* Show all commands, but only one line per command */
12261 if( zPattern==0 ) zPattern = "";
12262 for(i=0; i<ArraySize(azHelp); i++){
12263 if( azHelp[i][0]=='.' || zPattern[0] ){
12264 utf8_printf(out, "%s\n", azHelp[i]);
12269 /* Look for commands that for which zPattern is an exact prefix */
12270 zPat = sqlite3_mprintf(".%s*", zPattern);
12271 for(i=0; i<ArraySize(azHelp); i++){
12272 if( sqlite3_strglob(zPat, azHelp[i])==0 ){
12273 utf8_printf(out, "%s\n", azHelp[i]);
12278 sqlite3_free(zPat);
12281 /* when zPattern is a prefix of exactly one command, then include the
12282 ** details of that command, which should begin at offset j */
12283 while( j<ArraySize(azHelp)-1 && azHelp[j][0]!='.' ){
12284 utf8_printf(out, "%s\n", azHelp[j]);
12290 /* Look for commands that contain zPattern anywhere. Show the complete
12291 ** text of all commands that match. */
12292 zPat = sqlite3_mprintf("%%%s%%", zPattern);
12293 for(i=0; i<ArraySize(azHelp); i++){
12294 if( azHelp[i][0]=='.' ) j = i;
12295 if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){
12296 utf8_printf(out, "%s\n", azHelp[j]);
12297 while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]!='.' ){
12299 utf8_printf(out, "%s\n", azHelp[j]);
12305 sqlite3_free(zPat);
12310 /* Forward reference */
12311 static int process_input(ShellState *p);
12314 ** Read the content of file zName into memory obtained from sqlite3_malloc64()
12315 ** and return a pointer to the buffer. The caller is responsible for freeing
12318 ** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes
12321 ** For convenience, a nul-terminator byte is always appended to the data read
12322 ** from the file before the buffer is returned. This byte is not included in
12323 ** the final value of (*pnByte), if applicable.
12325 ** NULL is returned if any error is encountered. The final value of *pnByte
12326 ** is undefined in this case.
12328 static char *readFile(const char *zName, int *pnByte){
12329 FILE *in = fopen(zName, "rb");
12333 if( in==0 ) return 0;
12334 fseek(in, 0, SEEK_END);
12337 pBuf = sqlite3_malloc64( nIn+1 );
12338 if( pBuf==0 ){ fclose(in); return 0; }
12339 nRead = fread(pBuf, nIn, 1, in);
12342 sqlite3_free(pBuf);
12346 if( pnByte ) *pnByte = nIn;
12350 #if defined(SQLITE_ENABLE_SESSION)
12352 ** Close a single OpenSession object and release all of its associated
12355 static void session_close(OpenSession *pSession){
12357 sqlite3session_delete(pSession->p);
12358 sqlite3_free(pSession->zName);
12359 for(i=0; i<pSession->nFilter; i++){
12360 sqlite3_free(pSession->azFilter[i]);
12362 sqlite3_free(pSession->azFilter);
12363 memset(pSession, 0, sizeof(OpenSession));
12368 ** Close all OpenSession objects and release all associated resources.
12370 #if defined(SQLITE_ENABLE_SESSION)
12371 static void session_close_all(ShellState *p){
12373 for(i=0; i<p->nSession; i++){
12374 session_close(&p->aSession[i]);
12379 # define session_close_all(X)
12383 ** Implementation of the xFilter function for an open session. Omit
12384 ** any tables named by ".session filter" but let all other table through.
12386 #if defined(SQLITE_ENABLE_SESSION)
12387 static int session_filter(void *pCtx, const char *zTab){
12388 OpenSession *pSession = (OpenSession*)pCtx;
12390 for(i=0; i<pSession->nFilter; i++){
12391 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0;
12398 ** Try to deduce the type of file for zName based on its content. Return
12399 ** one of the SHELL_OPEN_* constants.
12401 ** If the file does not exist or is empty but its name looks like a ZIP
12402 ** archive and the dfltZip flag is true, then assume it is a ZIP archive.
12403 ** Otherwise, assume an ordinary database regardless of the filename if
12404 ** the type cannot be determined from content.
12406 int deduceDatabaseType(const char *zName, int dfltZip){
12407 FILE *f = fopen(zName, "rb");
12409 int rc = SHELL_OPEN_UNSPEC;
12412 if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
12413 return SHELL_OPEN_ZIPFILE;
12415 return SHELL_OPEN_NORMAL;
12418 n = fread(zBuf, 16, 1, f);
12419 if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){
12421 return SHELL_OPEN_NORMAL;
12423 fseek(f, -25, SEEK_END);
12424 n = fread(zBuf, 25, 1, f);
12425 if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){
12426 rc = SHELL_OPEN_APPENDVFS;
12428 fseek(f, -22, SEEK_END);
12429 n = fread(zBuf, 22, 1, f);
12430 if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05
12431 && zBuf[3]==0x06 ){
12432 rc = SHELL_OPEN_ZIPFILE;
12433 }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
12434 rc = SHELL_OPEN_ZIPFILE;
12441 #ifdef SQLITE_ENABLE_DESERIALIZE
12443 ** Reconstruct an in-memory database using the output from the "dbtotxt"
12444 ** program. Read content from the file in p->zDbFilename. If p->zDbFilename
12445 ** is 0, then read from standard input.
12447 static unsigned char *readHexDb(ShellState *p, int *pnData){
12448 unsigned char *a = 0;
12456 unsigned int x[16];
12458 if( p->zDbFilename ){
12459 in = fopen(p->zDbFilename, "r");
12461 utf8_printf(stderr, "cannot open \"%s\" for reading\n", p->zDbFilename);
12468 if( in==0 ) in = stdin;
12472 if( fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error;
12473 rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz);
12474 if( rc!=2 ) goto readHexDb_error;
12475 if( n<0 ) goto readHexDb_error;
12476 if( pgsz<512 || pgsz>65536 || (pgsz&(pgsz-1))!=0 ) goto readHexDb_error;
12477 n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */
12478 a = sqlite3_malloc( n ? n : 1 );
12480 utf8_printf(stderr, "Out of memory!\n");
12481 goto readHexDb_error;
12484 if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){
12485 utf8_printf(stderr, "invalid pagesize\n");
12486 goto readHexDb_error;
12488 for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){
12489 rc = sscanf(zLine, "| page %d offset %d", &j, &k);
12494 if( strncmp(zLine, "| end ", 6)==0 ){
12497 rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
12498 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7],
12499 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]);
12504 for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff;
12520 while( fgets(zLine, sizeof(zLine), p->in)!=0 ){
12522 if(strncmp(zLine, "| end ", 6)==0 ) break;
12527 utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine);
12530 #endif /* SQLITE_ENABLE_DESERIALIZE */
12533 ** Scalar function "shell_int32". The first argument to this function
12534 ** must be a blob. The second a non-negative integer. This function
12535 ** reads and returns a 32-bit big-endian integer from byte
12536 ** offset (4*<arg2>) of the blob.
12538 static void shellInt32(
12539 sqlite3_context *context,
12541 sqlite3_value **argv
12543 const unsigned char *pBlob;
12547 UNUSED_PARAMETER(argc);
12548 nBlob = sqlite3_value_bytes(argv[0]);
12549 pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]);
12550 iInt = sqlite3_value_int(argv[1]);
12552 if( iInt>=0 && (iInt+1)*4<=nBlob ){
12553 const unsigned char *a = &pBlob[iInt*4];
12554 sqlite3_int64 iVal = ((sqlite3_int64)a[0]<<24)
12555 + ((sqlite3_int64)a[1]<<16)
12556 + ((sqlite3_int64)a[2]<< 8)
12557 + ((sqlite3_int64)a[3]<< 0);
12558 sqlite3_result_int64(context, iVal);
12563 ** Scalar function "shell_idquote(X)" returns string X quoted as an identifier,
12564 ** using "..." with internal double-quote characters doubled.
12566 static void shellIdQuote(
12567 sqlite3_context *context,
12569 sqlite3_value **argv
12571 const char *zName = (const char*)sqlite3_value_text(argv[0]);
12572 UNUSED_PARAMETER(argc);
12574 char *z = sqlite3_mprintf("\"%w\"", zName);
12575 sqlite3_result_text(context, z, -1, sqlite3_free);
12580 ** Scalar function "shell_escape_crnl" used by the .recover command.
12581 ** The argument passed to this function is the output of built-in
12582 ** function quote(). If the first character of the input is "'",
12583 ** indicating that the value passed to quote() was a text value,
12584 ** then this function searches the input for "\n" and "\r" characters
12585 ** and adds a wrapper similar to the following:
12587 ** replace(replace(<input>, '\n', char(10), '\r', char(13));
12589 ** Or, if the first character of the input is not "'", then a copy
12590 ** of the input is returned.
12592 static void shellEscapeCrnl(
12593 sqlite3_context *context,
12595 sqlite3_value **argv
12597 const char *zText = (const char*)sqlite3_value_text(argv[0]);
12598 UNUSED_PARAMETER(argc);
12599 if( zText[0]=='\'' ){
12600 int nText = sqlite3_value_bytes(argv[0]);
12604 const char *zNL = 0;
12605 const char *zCR = 0;
12609 for(i=0; zText[i]; i++){
12610 if( zNL==0 && zText[i]=='\n' ){
12611 zNL = unused_string(zText, "\\n", "\\012", zBuf1);
12612 nNL = (int)strlen(zNL);
12614 if( zCR==0 && zText[i]=='\r' ){
12615 zCR = unused_string(zText, "\\r", "\\015", zBuf2);
12616 nCR = (int)strlen(zCR);
12622 i64 nMax = (nNL > nCR) ? nNL : nCR;
12623 i64 nAlloc = nMax * nText + (nMax+64)*2;
12624 char *zOut = (char*)sqlite3_malloc64(nAlloc);
12626 sqlite3_result_error_nomem(context);
12631 memcpy(&zOut[iOut], "replace(replace(", 16);
12634 memcpy(&zOut[iOut], "replace(", 8);
12637 for(i=0; zText[i]; i++){
12638 if( zText[i]=='\n' ){
12639 memcpy(&zOut[iOut], zNL, nNL);
12641 }else if( zText[i]=='\r' ){
12642 memcpy(&zOut[iOut], zCR, nCR);
12645 zOut[iOut] = zText[i];
12651 memcpy(&zOut[iOut], ",'", 2); iOut += 2;
12652 memcpy(&zOut[iOut], zNL, nNL); iOut += nNL;
12653 memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12;
12656 memcpy(&zOut[iOut], ",'", 2); iOut += 2;
12657 memcpy(&zOut[iOut], zCR, nCR); iOut += nCR;
12658 memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12;
12661 sqlite3_result_text(context, zOut, iOut, SQLITE_TRANSIENT);
12662 sqlite3_free(zOut);
12667 sqlite3_result_value(context, argv[0]);
12670 /* Flags for open_db().
12672 ** The default behavior of open_db() is to exit(1) if the database fails to
12673 ** open. The OPEN_DB_KEEPALIVE flag changes that so that it prints an error
12674 ** but still returns without calling exit.
12676 ** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a
12677 ** ZIP archive if the file does not exist or is empty and its name matches
12678 ** the *.zip pattern.
12680 #define OPEN_DB_KEEPALIVE 0x001 /* Return after error if true */
12681 #define OPEN_DB_ZIPFILE 0x002 /* Open as ZIP if name matches *.zip */
12684 ** Make sure the database is open. If it is not, then open it. If
12685 ** the database fails to open, print an error message and exit.
12687 static void open_db(ShellState *p, int openFlags){
12689 if( p->openMode==SHELL_OPEN_UNSPEC ){
12690 if( p->zDbFilename==0 || p->zDbFilename[0]==0 ){
12691 p->openMode = SHELL_OPEN_NORMAL;
12693 p->openMode = (u8)deduceDatabaseType(p->zDbFilename,
12694 (openFlags & OPEN_DB_ZIPFILE)!=0);
12697 switch( p->openMode ){
12698 case SHELL_OPEN_APPENDVFS: {
12699 sqlite3_open_v2(p->zDbFilename, &p->db,
12700 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, "apndvfs");
12703 case SHELL_OPEN_HEXDB:
12704 case SHELL_OPEN_DESERIALIZE: {
12705 sqlite3_open(0, &p->db);
12708 case SHELL_OPEN_ZIPFILE: {
12709 sqlite3_open(":memory:", &p->db);
12712 case SHELL_OPEN_READONLY: {
12713 sqlite3_open_v2(p->zDbFilename, &p->db,
12714 SQLITE_OPEN_READONLY|p->openFlags, 0);
12717 case SHELL_OPEN_UNSPEC:
12718 case SHELL_OPEN_NORMAL: {
12719 sqlite3_open_v2(p->zDbFilename, &p->db,
12720 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, 0);
12725 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
12726 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
12727 p->zDbFilename, sqlite3_errmsg(p->db));
12728 if( openFlags & OPEN_DB_KEEPALIVE ){
12729 sqlite3_open(":memory:", &p->db);
12734 #ifndef SQLITE_OMIT_LOAD_EXTENSION
12735 sqlite3_enable_load_extension(p->db, 1);
12737 sqlite3_fileio_init(p->db, 0, 0);
12738 sqlite3_shathree_init(p->db, 0, 0);
12739 sqlite3_completion_init(p->db, 0, 0);
12740 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
12741 sqlite3_dbdata_init(p->db, 0, 0);
12743 #ifdef SQLITE_HAVE_ZLIB
12744 sqlite3_zipfile_init(p->db, 0, 0);
12745 sqlite3_sqlar_init(p->db, 0, 0);
12747 sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0,
12748 shellAddSchemaName, 0, 0);
12749 sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, 0,
12750 shellModuleSchema, 0, 0);
12751 sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p,
12752 shellPutsFunc, 0, 0);
12753 sqlite3_create_function(p->db, "shell_escape_crnl", 1, SQLITE_UTF8, 0,
12754 shellEscapeCrnl, 0, 0);
12755 sqlite3_create_function(p->db, "shell_int32", 2, SQLITE_UTF8, 0,
12757 sqlite3_create_function(p->db, "shell_idquote", 1, SQLITE_UTF8, 0,
12758 shellIdQuote, 0, 0);
12759 #ifndef SQLITE_NOHAVE_SYSTEM
12760 sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0,
12762 sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0,
12765 if( p->openMode==SHELL_OPEN_ZIPFILE ){
12766 char *zSql = sqlite3_mprintf(
12767 "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", p->zDbFilename);
12768 sqlite3_exec(p->db, zSql, 0, 0, 0);
12769 sqlite3_free(zSql);
12771 #ifdef SQLITE_ENABLE_DESERIALIZE
12773 if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){
12776 unsigned char *aData;
12777 if( p->openMode==SHELL_OPEN_DESERIALIZE ){
12778 aData = (unsigned char*)readFile(p->zDbFilename, &nData);
12780 aData = readHexDb(p, &nData);
12785 rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
12786 SQLITE_DESERIALIZE_RESIZEABLE |
12787 SQLITE_DESERIALIZE_FREEONCLOSE);
12789 utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc);
12792 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
12800 ** Attempt to close the databaes connection. Report errors.
12802 void close_db(sqlite3 *db){
12803 int rc = sqlite3_close(db);
12805 utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n",
12806 rc, sqlite3_errmsg(db));
12810 #if HAVE_READLINE || HAVE_EDITLINE
12812 ** Readline completion callbacks
12814 static char *readline_completion_generator(const char *text, int state){
12815 static sqlite3_stmt *pStmt = 0;
12819 sqlite3_finalize(pStmt);
12820 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
12821 " FROM completion(%Q) ORDER BY 1", text);
12822 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
12823 sqlite3_free(zSql);
12825 if( sqlite3_step(pStmt)==SQLITE_ROW ){
12826 zRet = strdup((const char*)sqlite3_column_text(pStmt, 0));
12828 sqlite3_finalize(pStmt);
12834 static char **readline_completion(const char *zText, int iStart, int iEnd){
12835 rl_attempted_completion_over = 1;
12836 return rl_completion_matches(zText, readline_completion_generator);
12839 #elif HAVE_LINENOISE
12841 ** Linenoise completion callback
12843 static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){
12844 int nLine = strlen30(zLine);
12846 sqlite3_stmt *pStmt = 0;
12850 if( nLine>sizeof(zBuf)-30 ) return;
12851 if( zLine[0]=='.' || zLine[0]=='#') return;
12852 for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){}
12853 if( i==nLine-1 ) return;
12855 memcpy(zBuf, zLine, iStart);
12856 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
12857 " FROM completion(%Q,%Q) ORDER BY 1",
12858 &zLine[iStart], zLine);
12859 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
12860 sqlite3_free(zSql);
12861 sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */
12862 while( sqlite3_step(pStmt)==SQLITE_ROW ){
12863 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0);
12864 int nCompletion = sqlite3_column_bytes(pStmt, 0);
12865 if( iStart+nCompletion < sizeof(zBuf)-1 ){
12866 memcpy(zBuf+iStart, zCompletion, nCompletion+1);
12867 linenoiseAddCompletion(lc, zBuf);
12870 sqlite3_finalize(pStmt);
12875 ** Do C-language style dequoting.
12881 ** \v -> vertical tab
12883 ** \r -> carriage return
12888 ** \NNN -> ascii character NNN in octal
12890 static void resolve_backslashes(char *z){
12893 while( *z && *z!='\\' ) z++;
12894 for(i=j=0; (c = z[i])!=0; i++, j++){
12895 if( c=='\\' && z[i+1]!=0 ){
12899 }else if( c=='b' ){
12901 }else if( c=='t' ){
12903 }else if( c=='n' ){
12905 }else if( c=='v' ){
12907 }else if( c=='f' ){
12909 }else if( c=='r' ){
12911 }else if( c=='"' ){
12913 }else if( c=='\'' ){
12915 }else if( c=='\\' ){
12917 }else if( c>='0' && c<='7' ){
12919 if( z[i+1]>='0' && z[i+1]<='7' ){
12921 c = (c<<3) + z[i] - '0';
12922 if( z[i+1]>='0' && z[i+1]<='7' ){
12924 c = (c<<3) + z[i] - '0';
12931 if( j<i ) z[j] = 0;
12935 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
12936 ** for TRUE and FALSE. Return the integer value if appropriate.
12938 static int booleanValue(const char *zArg){
12940 if( zArg[0]=='0' && zArg[1]=='x' ){
12941 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
12943 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
12945 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
12946 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
12949 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
12952 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
12958 ** Set or clear a shell flag according to a boolean value.
12960 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
12961 if( booleanValue(zArg) ){
12962 ShellSetFlag(p, mFlag);
12964 ShellClearFlag(p, mFlag);
12969 ** Close an output file, assuming it is not stderr or stdout
12971 static void output_file_close(FILE *f){
12972 if( f && f!=stdout && f!=stderr ) fclose(f);
12976 ** Try to open an output file. The names "stdout" and "stderr" are
12977 ** recognized and do the right thing. NULL is returned if the output
12978 ** filename is "off".
12980 static FILE *output_file_open(const char *zFile, int bTextMode){
12982 if( strcmp(zFile,"stdout")==0 ){
12984 }else if( strcmp(zFile, "stderr")==0 ){
12986 }else if( strcmp(zFile, "off")==0 ){
12989 f = fopen(zFile, bTextMode ? "w" : "wb");
12991 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
12997 #ifndef SQLITE_OMIT_TRACE
12999 ** A routine for handling output from sqlite3_trace().
13001 static int sql_trace_callback(
13002 unsigned mType, /* The trace type */
13003 void *pArg, /* The ShellState pointer */
13004 void *pP, /* Usually a pointer to sqlite_stmt */
13005 void *pX /* Auxiliary output */
13007 ShellState *p = (ShellState*)pArg;
13008 sqlite3_stmt *pStmt;
13011 if( p->traceOut==0 ) return 0;
13012 if( mType==SQLITE_TRACE_CLOSE ){
13013 utf8_printf(p->traceOut, "-- closing database connection\n");
13016 if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){
13017 zSql = (const char*)pX;
13019 pStmt = (sqlite3_stmt*)pP;
13020 switch( p->eTraceType ){
13021 case SHELL_TRACE_EXPANDED: {
13022 zSql = sqlite3_expanded_sql(pStmt);
13025 #ifdef SQLITE_ENABLE_NORMALIZE
13026 case SHELL_TRACE_NORMALIZED: {
13027 zSql = sqlite3_normalized_sql(pStmt);
13032 zSql = sqlite3_sql(pStmt);
13037 if( zSql==0 ) return 0;
13038 nSql = strlen30(zSql);
13039 while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
13041 case SQLITE_TRACE_ROW:
13042 case SQLITE_TRACE_STMT: {
13043 utf8_printf(p->traceOut, "%.*s;\n", nSql, zSql);
13046 case SQLITE_TRACE_PROFILE: {
13047 sqlite3_int64 nNanosec = *(sqlite3_int64*)pX;
13048 utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", nSql, zSql, nNanosec);
13057 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
13058 ** a useful spot to set a debugger breakpoint.
13060 static void test_breakpoint(void){
13061 static int nCall = 0;
13066 ** An object used to read a CSV and other files for import.
13068 typedef struct ImportCtx ImportCtx;
13070 const char *zFile; /* Name of the input file */
13071 FILE *in; /* Read the CSV text from this input stream */
13072 char *z; /* Accumulated text for a field */
13073 int n; /* Number of bytes in z */
13074 int nAlloc; /* Space allocated for z[] */
13075 int nLine; /* Current line number */
13076 int bNotFirst; /* True if one or more bytes already read */
13077 int cTerm; /* Character that terminated the most recent field */
13078 int cColSep; /* The column separator character. (Usually ",") */
13079 int cRowSep; /* The row separator character. (Usually "\n") */
13082 /* Append a single byte to z[] */
13083 static void import_append_char(ImportCtx *p, int c){
13084 if( p->n+1>=p->nAlloc ){
13085 p->nAlloc += p->nAlloc + 100;
13086 p->z = sqlite3_realloc64(p->z, p->nAlloc);
13087 if( p->z==0 ) shell_out_of_memory();
13089 p->z[p->n++] = (char)c;
13092 /* Read a single field of CSV text. Compatible with rfc4180 and extended
13093 ** with the option of having a separator other than ",".
13095 ** + Input comes from p->in.
13096 ** + Store results in p->z of length p->n. Space to hold p->z comes
13097 ** from sqlite3_malloc64().
13098 ** + Use p->cSep as the column separator. The default is ",".
13099 ** + Use p->rSep as the row separator. The default is "\n".
13100 ** + Keep track of the line number in p->nLine.
13101 ** + Store the character that terminates the field in p->cTerm. Store
13102 ** EOF on end-of-file.
13103 ** + Report syntax errors on stderr
13105 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
13107 int cSep = p->cColSep;
13108 int rSep = p->cRowSep;
13111 if( c==EOF || seenInterrupt ){
13117 int startLine = p->nLine;
13122 if( c==rSep ) p->nLine++;
13129 if( (c==cSep && pc==cQuote)
13130 || (c==rSep && pc==cQuote)
13131 || (c==rSep && pc=='\r' && ppc==cQuote)
13132 || (c==EOF && pc==cQuote)
13134 do{ p->n--; }while( p->z[p->n]!=cQuote );
13138 if( pc==cQuote && c!='\r' ){
13139 utf8_printf(stderr, "%s:%d: unescaped %c character\n",
13140 p->zFile, p->nLine, cQuote);
13143 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
13144 p->zFile, startLine, cQuote);
13148 import_append_char(p, c);
13153 /* If this is the first field being parsed and it begins with the
13154 ** UTF-8 BOM (0xEF BB BF) then skip the BOM */
13155 if( (c&0xff)==0xef && p->bNotFirst==0 ){
13156 import_append_char(p, c);
13158 if( (c&0xff)==0xbb ){
13159 import_append_char(p, c);
13161 if( (c&0xff)==0xbf ){
13164 return csv_read_one_field(p);
13168 while( c!=EOF && c!=cSep && c!=rSep ){
13169 import_append_char(p, c);
13174 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
13178 if( p->z ) p->z[p->n] = 0;
13183 /* Read a single field of ASCII delimited text.
13185 ** + Input comes from p->in.
13186 ** + Store results in p->z of length p->n. Space to hold p->z comes
13187 ** from sqlite3_malloc64().
13188 ** + Use p->cSep as the column separator. The default is "\x1F".
13189 ** + Use p->rSep as the row separator. The default is "\x1E".
13190 ** + Keep track of the row number in p->nLine.
13191 ** + Store the character that terminates the field in p->cTerm. Store
13192 ** EOF on end-of-file.
13193 ** + Report syntax errors on stderr
13195 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
13197 int cSep = p->cColSep;
13198 int rSep = p->cRowSep;
13201 if( c==EOF || seenInterrupt ){
13205 while( c!=EOF && c!=cSep && c!=rSep ){
13206 import_append_char(p, c);
13213 if( p->z ) p->z[p->n] = 0;
13218 ** Try to transfer data for table zTable. If an error is seen while
13219 ** moving forward, try to go backwards. The backwards movement won't
13220 ** work for WITHOUT ROWID tables.
13222 static void tryToCloneData(
13227 sqlite3_stmt *pQuery = 0;
13228 sqlite3_stmt *pInsert = 0;
13233 int nTable = strlen30(zTable);
13236 const int spinRate = 10000;
13238 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
13239 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13241 utf8_printf(stderr, "Error %d: %s on [%s]\n",
13242 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13244 goto end_data_xfer;
13246 n = sqlite3_column_count(pQuery);
13247 zInsert = sqlite3_malloc64(200 + nTable + n*3);
13248 if( zInsert==0 ) shell_out_of_memory();
13249 sqlite3_snprintf(200+nTable,zInsert,
13250 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
13251 i = strlen30(zInsert);
13252 for(j=1; j<n; j++){
13253 memcpy(zInsert+i, ",?", 2);
13256 memcpy(zInsert+i, ");", 3);
13257 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
13259 utf8_printf(stderr, "Error %d: %s on [%s]\n",
13260 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
13262 goto end_data_xfer;
13264 for(k=0; k<2; k++){
13265 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13266 for(i=0; i<n; i++){
13267 switch( sqlite3_column_type(pQuery, i) ){
13268 case SQLITE_NULL: {
13269 sqlite3_bind_null(pInsert, i+1);
13272 case SQLITE_INTEGER: {
13273 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
13276 case SQLITE_FLOAT: {
13277 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
13280 case SQLITE_TEXT: {
13281 sqlite3_bind_text(pInsert, i+1,
13282 (const char*)sqlite3_column_text(pQuery,i),
13283 -1, SQLITE_STATIC);
13286 case SQLITE_BLOB: {
13287 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
13288 sqlite3_column_bytes(pQuery,i),
13294 rc = sqlite3_step(pInsert);
13295 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
13296 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
13297 sqlite3_errmsg(newDb));
13299 sqlite3_reset(pInsert);
13301 if( (cnt%spinRate)==0 ){
13302 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
13306 if( rc==SQLITE_DONE ) break;
13307 sqlite3_finalize(pQuery);
13308 sqlite3_free(zQuery);
13309 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
13311 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13313 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
13316 } /* End for(k=0...) */
13319 sqlite3_finalize(pQuery);
13320 sqlite3_finalize(pInsert);
13321 sqlite3_free(zQuery);
13322 sqlite3_free(zInsert);
13327 ** Try to transfer all rows of the schema that match zWhere. For
13328 ** each row, invoke xForEach() on the object defined by that row.
13329 ** If an error is encountered while moving forward through the
13330 ** sqlite_master table, try again moving backwards.
13332 static void tryToCloneSchema(
13335 const char *zWhere,
13336 void (*xForEach)(ShellState*,sqlite3*,const char*)
13338 sqlite3_stmt *pQuery = 0;
13341 const unsigned char *zName;
13342 const unsigned char *zSql;
13345 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
13346 " WHERE %s", zWhere);
13347 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13349 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
13350 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13352 goto end_schema_xfer;
13354 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13355 zName = sqlite3_column_text(pQuery, 0);
13356 zSql = sqlite3_column_text(pQuery, 1);
13357 printf("%s... ", zName); fflush(stdout);
13358 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
13360 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
13361 sqlite3_free(zErrMsg);
13365 xForEach(p, newDb, (const char*)zName);
13369 if( rc!=SQLITE_DONE ){
13370 sqlite3_finalize(pQuery);
13371 sqlite3_free(zQuery);
13372 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
13373 " WHERE %s ORDER BY rowid DESC", zWhere);
13374 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
13376 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
13377 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
13379 goto end_schema_xfer;
13381 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
13382 zName = sqlite3_column_text(pQuery, 0);
13383 zSql = sqlite3_column_text(pQuery, 1);
13384 printf("%s... ", zName); fflush(stdout);
13385 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
13387 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
13388 sqlite3_free(zErrMsg);
13392 xForEach(p, newDb, (const char*)zName);
13398 sqlite3_finalize(pQuery);
13399 sqlite3_free(zQuery);
13403 ** Open a new database file named "zNewDb". Try to recover as much information
13404 ** as possible out of the main database (which might be corrupt) and write it
13407 static void tryToClone(ShellState *p, const char *zNewDb){
13409 sqlite3 *newDb = 0;
13410 if( access(zNewDb,0)==0 ){
13411 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
13414 rc = sqlite3_open(zNewDb, &newDb);
13416 utf8_printf(stderr, "Cannot create output database: %s\n",
13417 sqlite3_errmsg(newDb));
13419 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
13420 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
13421 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
13422 tryToCloneSchema(p, newDb, "type!='table'", 0);
13423 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
13424 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
13430 ** Change the output file back to stdout.
13432 ** If the p->doXdgOpen flag is set, that means the output was being
13433 ** redirected to a temporary file named by p->zTempFile. In that case,
13434 ** launch start/open/xdg-open on that temporary file.
13436 static void output_reset(ShellState *p){
13437 if( p->outfile[0]=='|' ){
13438 #ifndef SQLITE_OMIT_POPEN
13442 output_file_close(p->out);
13443 #ifndef SQLITE_NOHAVE_SYSTEM
13444 if( p->doXdgOpen ){
13445 const char *zXdgOpenCmd =
13446 #if defined(_WIN32)
13448 #elif defined(__APPLE__)
13454 zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
13455 if( system(zCmd) ){
13456 utf8_printf(stderr, "Failed: [%s]\n", zCmd);
13458 sqlite3_free(zCmd);
13461 sqlite3_sleep(100);
13463 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
13470 ** Run an SQL command and return the single integer result.
13472 static int db_int(ShellState *p, const char *zSql){
13473 sqlite3_stmt *pStmt;
13475 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
13476 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
13477 res = sqlite3_column_int(pStmt,0);
13479 sqlite3_finalize(pStmt);
13484 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
13486 static unsigned int get2byteInt(unsigned char *a){
13487 return (a[0]<<8) + a[1];
13489 static unsigned int get4byteInt(unsigned char *a){
13490 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
13494 ** Implementation of the ".dbinfo" command.
13496 ** Return 1 on error, 2 to exit, and 0 otherwise.
13498 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
13499 static const struct { const char *zName; int ofst; } aField[] = {
13500 { "file change counter:", 24 },
13501 { "database page count:", 28 },
13502 { "freelist page count:", 36 },
13503 { "schema cookie:", 40 },
13504 { "schema format:", 44 },
13505 { "default cache size:", 48 },
13506 { "autovacuum top root:", 52 },
13507 { "incremental vacuum:", 64 },
13508 { "text encoding:", 56 },
13509 { "user version:", 60 },
13510 { "application id:", 68 },
13511 { "software version:", 96 },
13513 static const struct { const char *zName; const char *zSql; } aQuery[] = {
13514 { "number of tables:",
13515 "SELECT count(*) FROM %s WHERE type='table'" },
13516 { "number of indexes:",
13517 "SELECT count(*) FROM %s WHERE type='index'" },
13518 { "number of triggers:",
13519 "SELECT count(*) FROM %s WHERE type='trigger'" },
13520 { "number of views:",
13521 "SELECT count(*) FROM %s WHERE type='view'" },
13523 "SELECT total(length(sql)) FROM %s" },
13526 unsigned iDataVersion;
13528 char *zDb = nArg>=2 ? azArg[1] : "main";
13529 sqlite3_stmt *pStmt = 0;
13530 unsigned char aHdr[100];
13532 if( p->db==0 ) return 1;
13533 rc = sqlite3_prepare_v2(p->db,
13534 "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
13537 if( !sqlite3_compileoption_used("ENABLE_DBPAGE_VTAB") ){
13538 utf8_printf(stderr, "the \".dbinfo\" command requires the "
13539 "-DSQLITE_ENABLE_DBPAGE_VTAB compile-time options\n");
13541 utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db));
13543 sqlite3_finalize(pStmt);
13546 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
13547 if( sqlite3_step(pStmt)==SQLITE_ROW
13548 && sqlite3_column_bytes(pStmt,0)>100
13550 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100);
13551 sqlite3_finalize(pStmt);
13553 raw_printf(stderr, "unable to read database header\n");
13554 sqlite3_finalize(pStmt);
13557 i = get2byteInt(aHdr+16);
13558 if( i==1 ) i = 65536;
13559 utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
13560 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
13561 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
13562 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
13563 for(i=0; i<ArraySize(aField); i++){
13564 int ofst = aField[i].ofst;
13565 unsigned int val = get4byteInt(aHdr + ofst);
13566 utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
13569 if( val==1 ) raw_printf(p->out, " (utf8)");
13570 if( val==2 ) raw_printf(p->out, " (utf16le)");
13571 if( val==3 ) raw_printf(p->out, " (utf16be)");
13574 raw_printf(p->out, "\n");
13577 zSchemaTab = sqlite3_mprintf("main.sqlite_master");
13578 }else if( strcmp(zDb,"temp")==0 ){
13579 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
13581 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
13583 for(i=0; i<ArraySize(aQuery); i++){
13584 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
13585 int val = db_int(p, zSql);
13586 sqlite3_free(zSql);
13587 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
13589 sqlite3_free(zSchemaTab);
13590 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion);
13591 utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion);
13596 ** Print the current sqlite3_errmsg() value to stderr and return 1.
13598 static int shellDatabaseError(sqlite3 *db){
13599 const char *zErr = sqlite3_errmsg(db);
13600 utf8_printf(stderr, "Error: %s\n", zErr);
13605 ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
13606 ** if they match and FALSE (0) if they do not match.
13610 ** '*' Matches any sequence of zero or more characters.
13612 ** '?' Matches exactly one character.
13614 ** [...] Matches one character from the enclosed list of
13617 ** [^...] Matches one character not in the enclosed list.
13619 ** '#' Matches any sequence of one or more digits with an
13620 ** optional + or - sign in front
13622 ** ' ' Any span of whitespace matches any other span of
13625 ** Extra whitespace at the end of z[] is ignored.
13627 static int testcase_glob(const char *zGlob, const char *z){
13632 while( (c = (*(zGlob++)))!=0 ){
13634 if( !IsSpace(*z) ) return 0;
13635 while( IsSpace(*zGlob) ) zGlob++;
13636 while( IsSpace(*z) ) z++;
13637 }else if( c=='*' ){
13638 while( (c=(*(zGlob++))) == '*' || c=='?' ){
13639 if( c=='?' && (*(z++))==0 ) return 0;
13643 }else if( c=='[' ){
13644 while( *z && testcase_glob(zGlob-1,z)==0 ){
13649 while( (c2 = (*(z++)))!=0 ){
13652 if( c2==0 ) return 0;
13654 if( testcase_glob(zGlob,z) ) return 1;
13657 }else if( c=='?' ){
13658 if( (*(z++))==0 ) return 0;
13659 }else if( c=='[' ){
13664 if( c==0 ) return 0;
13671 if( c==']' ) seen = 1;
13674 while( c2 && c2!=']' ){
13675 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
13677 if( c>=prior_c && c<=c2 ) seen = 1;
13687 if( c2==0 || (seen ^ invert)==0 ) return 0;
13688 }else if( c=='#' ){
13689 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++;
13690 if( !IsDigit(z[0]) ) return 0;
13692 while( IsDigit(z[0]) ){ z++; }
13694 if( c!=(*(z++)) ) return 0;
13697 while( IsSpace(*z) ){ z++; }
13703 ** Compare the string as a command-line option with either one or two
13704 ** initial "-" characters.
13706 static int optionMatch(const char *zStr, const char *zOpt){
13707 if( zStr[0]!='-' ) return 0;
13709 if( zStr[0]=='-' ) zStr++;
13710 return strcmp(zStr, zOpt)==0;
13716 int shellDeleteFile(const char *zFilename){
13719 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename);
13723 rc = unlink(zFilename);
13729 ** Try to delete the temporary file (if there is one) and free the
13730 ** memory used to hold the name of the temp file.
13732 static void clearTempFile(ShellState *p){
13733 if( p->zTempFile==0 ) return;
13734 if( p->doXdgOpen ) return;
13735 if( shellDeleteFile(p->zTempFile) ) return;
13736 sqlite3_free(p->zTempFile);
13741 ** Create a new temp file name with the given suffix.
13743 static void newTempFile(ShellState *p, const char *zSuffix){
13745 sqlite3_free(p->zTempFile);
13748 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile);
13750 if( p->zTempFile==0 ){
13752 sqlite3_randomness(sizeof(r), &r);
13753 p->zTempFile = sqlite3_mprintf("temp%llx.%s", r, zSuffix);
13755 p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix);
13757 if( p->zTempFile==0 ){
13758 raw_printf(stderr, "out of memory\n");
13765 ** The implementation of SQL scalar function fkey_collate_clause(), used
13766 ** by the ".lint fkey-indexes" command. This scalar function is always
13767 ** called with four arguments - the parent table name, the parent column name,
13768 ** the child table name and the child column name.
13770 ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col')
13772 ** If either of the named tables or columns do not exist, this function
13773 ** returns an empty string. An empty string is also returned if both tables
13774 ** and columns exist but have the same default collation sequence. Or,
13775 ** if both exist but the default collation sequences are different, this
13776 ** function returns the string " COLLATE <parent-collation>", where
13777 ** <parent-collation> is the default collation sequence of the parent column.
13779 static void shellFkeyCollateClause(
13780 sqlite3_context *pCtx,
13782 sqlite3_value **apVal
13784 sqlite3 *db = sqlite3_context_db_handle(pCtx);
13785 const char *zParent;
13786 const char *zParentCol;
13787 const char *zParentSeq;
13788 const char *zChild;
13789 const char *zChildCol;
13790 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */
13794 zParent = (const char*)sqlite3_value_text(apVal[0]);
13795 zParentCol = (const char*)sqlite3_value_text(apVal[1]);
13796 zChild = (const char*)sqlite3_value_text(apVal[2]);
13797 zChildCol = (const char*)sqlite3_value_text(apVal[3]);
13799 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
13800 rc = sqlite3_table_column_metadata(
13801 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0
13803 if( rc==SQLITE_OK ){
13804 rc = sqlite3_table_column_metadata(
13805 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0
13809 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){
13810 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
13811 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
13818 ** The implementation of dot-command ".lint fkey-indexes".
13820 static int lintFkeyIndexes(
13821 ShellState *pState, /* Current shell tool state */
13822 char **azArg, /* Array of arguments passed to dot command */
13823 int nArg /* Number of entries in azArg[] */
13825 sqlite3 *db = pState->db; /* Database handle to query "main" db of */
13826 FILE *out = pState->out; /* Stream to write non-error output to */
13827 int bVerbose = 0; /* If -verbose is present */
13828 int bGroupByParent = 0; /* If -groupbyparent is present */
13829 int i; /* To iterate through azArg[] */
13830 const char *zIndent = ""; /* How much to indent CREATE INDEX by */
13831 int rc; /* Return code */
13832 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */
13835 ** This SELECT statement returns one row for each foreign key constraint
13836 ** in the schema of the main database. The column values are:
13838 ** 0. The text of an SQL statement similar to:
13840 ** "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?"
13842 ** This SELECT is similar to the one that the foreign keys implementation
13843 ** needs to run internally on child tables. If there is an index that can
13844 ** be used to optimize this query, then it can also be used by the FK
13845 ** implementation to optimize DELETE or UPDATE statements on the parent
13848 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
13849 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema
13850 ** contains an index that can be used to optimize the query.
13852 ** 2. Human readable text that describes the child table and columns. e.g.
13854 ** "child_table(child_key1, child_key2)"
13856 ** 3. Human readable text that describes the parent table and columns. e.g.
13858 ** "parent_table(parent_key1, parent_key2)"
13860 ** 4. A full CREATE INDEX statement for an index that could be used to
13861 ** optimize DELETE or UPDATE statements on the parent table. e.g.
13863 ** "CREATE INDEX child_table_child_key ON child_table(child_key)"
13865 ** 5. The name of the parent table.
13867 ** These six values are used by the C logic below to generate the report.
13871 " 'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '"
13872 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
13873 " || fkey_collate_clause("
13874 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
13876 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('"
13877 " || group_concat('*=?', ' AND ') || ')'"
13879 " s.name || '(' || group_concat(f.[from], ', ') || ')'"
13881 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
13883 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
13884 " || ' ON ' || quote(s.name) || '('"
13885 " || group_concat(quote(f.[from]) ||"
13886 " fkey_collate_clause("
13887 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
13891 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f "
13892 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
13893 "GROUP BY s.name, f.id "
13894 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
13896 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)";
13898 for(i=2; i<nArg; i++){
13899 int n = strlen30(azArg[i]);
13900 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){
13903 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
13904 bGroupByParent = 1;
13908 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
13911 return SQLITE_ERROR;
13915 /* Register the fkey_collate_clause() SQL function */
13916 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8,
13917 0, shellFkeyCollateClause, 0, 0
13921 if( rc==SQLITE_OK ){
13922 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
13924 if( rc==SQLITE_OK ){
13925 sqlite3_bind_int(pSql, 1, bGroupByParent);
13928 if( rc==SQLITE_OK ){
13931 while( SQLITE_ROW==sqlite3_step(pSql) ){
13933 sqlite3_stmt *pExplain = 0;
13934 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
13935 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
13936 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
13937 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
13938 const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
13939 const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
13941 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
13942 if( rc!=SQLITE_OK ) break;
13943 if( SQLITE_ROW==sqlite3_step(pExplain) ){
13944 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
13946 0==sqlite3_strglob(zGlob, zPlan)
13947 || 0==sqlite3_strglob(zGlobIPK, zPlan)
13950 rc = sqlite3_finalize(pExplain);
13951 if( rc!=SQLITE_OK ) break;
13954 raw_printf(stderr, "Error: internal error");
13958 && (bVerbose || res==0)
13959 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev))
13961 raw_printf(out, "-- Parent table %s\n", zParent);
13962 sqlite3_free(zPrev);
13963 zPrev = sqlite3_mprintf("%s", zParent);
13967 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
13968 }else if( bVerbose ){
13969 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n",
13970 zIndent, zFrom, zTarget
13975 sqlite3_free(zPrev);
13977 if( rc!=SQLITE_OK ){
13978 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13981 rc2 = sqlite3_finalize(pSql);
13982 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
13984 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13987 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
13994 ** Implementation of ".lint" dot command.
13996 static int lintDotCommand(
13997 ShellState *pState, /* Current shell tool state */
13998 char **azArg, /* Array of arguments passed to dot command */
13999 int nArg /* Number of entries in azArg[] */
14002 n = (nArg>=2 ? strlen30(azArg[1]) : 0);
14003 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
14004 return lintFkeyIndexes(pState, azArg, nArg);
14007 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]);
14008 raw_printf(stderr, "Where sub-commands are:\n");
14009 raw_printf(stderr, " fkey-indexes\n");
14010 return SQLITE_ERROR;
14013 #if !defined SQLITE_OMIT_VIRTUALTABLE
14014 static void shellPrepare(
14018 sqlite3_stmt **ppStmt
14021 if( *pRc==SQLITE_OK ){
14022 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
14023 if( rc!=SQLITE_OK ){
14024 raw_printf(stderr, "sql error: %s (%d)\n",
14025 sqlite3_errmsg(db), sqlite3_errcode(db)
14033 ** Create a prepared statement using printf-style arguments for the SQL.
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 shellPreparePrintf(
14042 sqlite3_stmt **ppStmt,
14047 if( *pRc==SQLITE_OK ){
14050 va_start(ap, zFmt);
14051 z = sqlite3_vmprintf(zFmt, ap);
14054 *pRc = SQLITE_NOMEM;
14056 shellPrepare(db, pRc, z, ppStmt);
14062 /* Finalize the prepared statement created using shellPreparePrintf().
14064 ** This routine is could be marked "static". But it is not always used,
14065 ** depending on compile-time options. By omitting the "static", we avoid
14066 ** nuisance compiler warnings about "defined but not used".
14068 void shellFinalize(
14070 sqlite3_stmt *pStmt
14073 sqlite3 *db = sqlite3_db_handle(pStmt);
14074 int rc = sqlite3_finalize(pStmt);
14075 if( *pRc==SQLITE_OK ){
14076 if( rc!=SQLITE_OK ){
14077 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
14084 /* Reset the prepared statement created using shellPreparePrintf().
14086 ** This routine is could be marked "static". But it is not always used,
14087 ** depending on compile-time options. By omitting the "static", we avoid
14088 ** nuisance compiler warnings about "defined but not used".
14092 sqlite3_stmt *pStmt
14094 int rc = sqlite3_reset(pStmt);
14095 if( *pRc==SQLITE_OK ){
14096 if( rc!=SQLITE_OK ){
14097 sqlite3 *db = sqlite3_db_handle(pStmt);
14098 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
14103 #endif /* !defined SQLITE_OMIT_VIRTUALTABLE */
14105 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
14106 /******************************************************************************
14107 ** The ".archive" or ".ar" command.
14110 ** Structure representing a single ".ar" command.
14112 typedef struct ArCommand ArCommand;
14114 u8 eCmd; /* An AR_CMD_* value */
14115 u8 bVerbose; /* True if --verbose */
14116 u8 bZip; /* True if the archive is a ZIP */
14117 u8 bDryRun; /* True if --dry-run */
14118 u8 bAppend; /* True if --append */
14119 u8 fromCmdLine; /* Run from -A instead of .archive */
14120 int nArg; /* Number of command arguments */
14121 char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */
14122 const char *zFile; /* --file argument, or NULL */
14123 const char *zDir; /* --directory argument, or NULL */
14124 char **azArg; /* Array of command arguments */
14125 ShellState *p; /* Shell state */
14126 sqlite3 *db; /* Database containing the archive */
14130 ** Print a usage message for the .ar command to stderr and return SQLITE_ERROR.
14132 static int arUsage(FILE *f){
14133 showHelp(f,"archive");
14134 return SQLITE_ERROR;
14138 ** Print an error message for the .ar command to stderr and return
14141 static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){
14144 va_start(ap, zFmt);
14145 z = sqlite3_vmprintf(zFmt, ap);
14147 utf8_printf(stderr, "Error: %s\n", z);
14148 if( pAr->fromCmdLine ){
14149 utf8_printf(stderr, "Use \"-A\" for more help\n");
14151 utf8_printf(stderr, "Use \".archive --help\" for more help\n");
14154 return SQLITE_ERROR;
14158 ** Values for ArCommand.eCmd.
14160 #define AR_CMD_CREATE 1
14161 #define AR_CMD_UPDATE 2
14162 #define AR_CMD_INSERT 3
14163 #define AR_CMD_EXTRACT 4
14164 #define AR_CMD_LIST 5
14165 #define AR_CMD_HELP 6
14168 ** Other (non-command) switches.
14170 #define AR_SWITCH_VERBOSE 7
14171 #define AR_SWITCH_FILE 8
14172 #define AR_SWITCH_DIRECTORY 9
14173 #define AR_SWITCH_APPEND 10
14174 #define AR_SWITCH_DRYRUN 11
14176 static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){
14178 case AR_CMD_CREATE:
14179 case AR_CMD_EXTRACT:
14181 case AR_CMD_UPDATE:
14182 case AR_CMD_INSERT:
14185 return arErrorMsg(pAr, "multiple command options");
14187 pAr->eCmd = eSwitch;
14190 case AR_SWITCH_DRYRUN:
14193 case AR_SWITCH_VERBOSE:
14196 case AR_SWITCH_APPEND:
14198 /* Fall thru into --file */
14199 case AR_SWITCH_FILE:
14202 case AR_SWITCH_DIRECTORY:
14211 ** Parse the command line for an ".ar" command. The results are written into
14212 ** structure (*pAr). SQLITE_OK is returned if the command line is parsed
14213 ** successfully, otherwise an error message is written to stderr and
14214 ** SQLITE_ERROR returned.
14216 static int arParseCommand(
14217 char **azArg, /* Array of arguments passed to dot command */
14218 int nArg, /* Number of entries in azArg[] */
14219 ArCommand *pAr /* Populate this object */
14227 { "create", 'c', AR_CMD_CREATE, 0 },
14228 { "extract", 'x', AR_CMD_EXTRACT, 0 },
14229 { "insert", 'i', AR_CMD_INSERT, 0 },
14230 { "list", 't', AR_CMD_LIST, 0 },
14231 { "update", 'u', AR_CMD_UPDATE, 0 },
14232 { "help", 'h', AR_CMD_HELP, 0 },
14233 { "verbose", 'v', AR_SWITCH_VERBOSE, 0 },
14234 { "file", 'f', AR_SWITCH_FILE, 1 },
14235 { "append", 'a', AR_SWITCH_APPEND, 1 },
14236 { "directory", 'C', AR_SWITCH_DIRECTORY, 1 },
14237 { "dryrun", 'n', AR_SWITCH_DRYRUN, 0 },
14239 int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch);
14240 struct ArSwitch *pEnd = &aSwitch[nSwitch];
14243 utf8_printf(stderr, "Wrong number of arguments. Usage:\n");
14244 return arUsage(stderr);
14246 char *z = azArg[1];
14248 /* Traditional style [tar] invocation */
14251 for(i=0; z[i]; i++){
14252 const char *zArg = 0;
14253 struct ArSwitch *pOpt;
14254 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14255 if( z[i]==pOpt->cShort ) break;
14258 return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
14262 return arErrorMsg(pAr, "option requires an argument: %c",z[i]);
14264 zArg = azArg[iArg++];
14266 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
14268 pAr->nArg = nArg-iArg;
14270 pAr->azArg = &azArg[iArg];
14273 /* Non-traditional invocation */
14275 for(iArg=1; iArg<nArg; iArg++){
14279 /* All remaining command line words are command arguments. */
14280 pAr->azArg = &azArg[iArg];
14281 pAr->nArg = nArg-iArg;
14288 /* One or more short options */
14289 for(i=1; i<n; i++){
14290 const char *zArg = 0;
14291 struct ArSwitch *pOpt;
14292 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14293 if( z[i]==pOpt->cShort ) break;
14296 return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
14303 if( iArg>=(nArg-1) ){
14304 return arErrorMsg(pAr, "option requires an argument: %c",
14307 zArg = azArg[++iArg];
14310 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
14312 }else if( z[2]=='\0' ){
14313 /* A -- option, indicating that all remaining command line words
14314 ** are command arguments. */
14315 pAr->azArg = &azArg[iArg+1];
14316 pAr->nArg = nArg-iArg-1;
14319 /* A long option */
14320 const char *zArg = 0; /* Argument for option, if any */
14321 struct ArSwitch *pMatch = 0; /* Matching option */
14322 struct ArSwitch *pOpt; /* Iterator */
14323 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){
14324 const char *zLong = pOpt->zLong;
14325 if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){
14327 return arErrorMsg(pAr, "ambiguous option: %s",z);
14335 return arErrorMsg(pAr, "unrecognized option: %s", z);
14337 if( pMatch->bArg ){
14338 if( iArg>=(nArg-1) ){
14339 return arErrorMsg(pAr, "option requires an argument: %s", z);
14341 zArg = azArg[++iArg];
14343 if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR;
14353 ** This function assumes that all arguments within the ArCommand.azArg[]
14354 ** array refer to archive members, as for the --extract or --list commands.
14355 ** It checks that each of them are present. If any specified file is not
14356 ** present in the archive, an error is printed to stderr and an error
14357 ** code returned. Otherwise, if all specified arguments are present in
14358 ** the archive, SQLITE_OK is returned.
14360 ** This function strips any trailing '/' characters from each argument.
14361 ** This is consistent with the way the [tar] command seems to work on
14364 static int arCheckEntries(ArCommand *pAr){
14365 int rc = SQLITE_OK;
14368 sqlite3_stmt *pTest = 0;
14370 shellPreparePrintf(pAr->db, &rc, &pTest,
14371 "SELECT name FROM %s WHERE name=$name",
14374 j = sqlite3_bind_parameter_index(pTest, "$name");
14375 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){
14376 char *z = pAr->azArg[i];
14377 int n = strlen30(z);
14379 while( n>0 && z[n-1]=='/' ) n--;
14381 sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC);
14382 if( SQLITE_ROW==sqlite3_step(pTest) ){
14385 shellReset(&rc, pTest);
14386 if( rc==SQLITE_OK && bOk==0 ){
14387 utf8_printf(stderr, "not found in archive: %s\n", z);
14391 shellFinalize(&rc, pTest);
14397 ** Format a WHERE clause that can be used against the "sqlar" table to
14398 ** identify all archive members that match the command arguments held
14399 ** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning.
14400 ** The caller is responsible for eventually calling sqlite3_free() on
14401 ** any non-NULL (*pzWhere) value.
14403 static void arWhereClause(
14406 char **pzWhere /* OUT: New WHERE clause */
14409 if( *pRc==SQLITE_OK ){
14410 if( pAr->nArg==0 ){
14411 zWhere = sqlite3_mprintf("1");
14414 const char *zSep = "";
14415 for(i=0; i<pAr->nArg; i++){
14416 const char *z = pAr->azArg[i];
14417 zWhere = sqlite3_mprintf(
14418 "%z%s name = '%q' OR substr(name,1,%d) = '%q/'",
14419 zWhere, zSep, z, strlen30(z)+1, z
14422 *pRc = SQLITE_NOMEM;
14433 ** Implementation of .ar "lisT" command.
14435 static int arListCommand(ArCommand *pAr){
14436 const char *zSql = "SELECT %s FROM %s WHERE %s";
14437 const char *azCols[] = {
14439 "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name"
14443 sqlite3_stmt *pSql = 0;
14446 rc = arCheckEntries(pAr);
14447 arWhereClause(&rc, pAr, &zWhere);
14449 shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose],
14450 pAr->zSrcTable, zWhere);
14451 if( pAr->bDryRun ){
14452 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
14454 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
14455 if( pAr->bVerbose ){
14456 utf8_printf(pAr->p->out, "%s % 10d %s %s\n",
14457 sqlite3_column_text(pSql, 0),
14458 sqlite3_column_int(pSql, 1),
14459 sqlite3_column_text(pSql, 2),
14460 sqlite3_column_text(pSql, 3)
14463 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
14467 shellFinalize(&rc, pSql);
14468 sqlite3_free(zWhere);
14474 ** Implementation of .ar "eXtract" command.
14476 static int arExtractCommand(ArCommand *pAr){
14477 const char *zSql1 =
14480 " writefile(($dir || name), %s, mode, mtime) "
14481 "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)"
14482 " AND name NOT GLOB '*..[/\\]*'";
14484 const char *azExtraArg[] = {
14485 "sqlar_uncompress(data, sz)",
14489 sqlite3_stmt *pSql = 0;
14490 int rc = SQLITE_OK;
14495 /* If arguments are specified, check that they actually exist within
14496 ** the archive before proceeding. And formulate a WHERE clause to
14498 rc = arCheckEntries(pAr);
14499 arWhereClause(&rc, pAr, &zWhere);
14501 if( rc==SQLITE_OK ){
14503 zDir = sqlite3_mprintf("%s/", pAr->zDir);
14505 zDir = sqlite3_mprintf("");
14507 if( zDir==0 ) rc = SQLITE_NOMEM;
14510 shellPreparePrintf(pAr->db, &rc, &pSql, zSql1,
14511 azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere
14514 if( rc==SQLITE_OK ){
14515 j = sqlite3_bind_parameter_index(pSql, "$dir");
14516 sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC);
14518 /* Run the SELECT statement twice. The first time, writefile() is called
14519 ** for all archive members that should be extracted. The second time,
14520 ** only for the directories. This is because the timestamps for
14521 ** extracted directories must be reset after they are populated (as
14522 ** populating them changes the timestamp). */
14523 for(i=0; i<2; i++){
14524 j = sqlite3_bind_parameter_index(pSql, "$dirOnly");
14525 sqlite3_bind_int(pSql, j, i);
14526 if( pAr->bDryRun ){
14527 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
14529 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
14530 if( i==0 && pAr->bVerbose ){
14531 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
14535 shellReset(&rc, pSql);
14537 shellFinalize(&rc, pSql);
14540 sqlite3_free(zDir);
14541 sqlite3_free(zWhere);
14546 ** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out.
14548 static int arExecSql(ArCommand *pAr, const char *zSql){
14550 if( pAr->bDryRun ){
14551 utf8_printf(pAr->p->out, "%s\n", zSql);
14555 rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
14557 utf8_printf(stdout, "ERROR: %s\n", zErr);
14558 sqlite3_free(zErr);
14566 ** Implementation of .ar "create", "insert", and "update" commands.
14568 ** create -> Create a new SQL archive
14569 ** insert -> Insert or reinsert all files listed
14570 ** update -> Insert files that have changed or that were not
14571 ** previously in the archive
14573 ** Create the "sqlar" table in the database if it does not already exist.
14574 ** Then add each file in the azFile[] array to the archive. Directories
14575 ** are added recursively. If argument bVerbose is non-zero, a message is
14576 ** printed on stdout for each file archived.
14578 ** The create command is the same as update, except that it drops
14579 ** any existing "sqlar" table before beginning. The "insert" command
14580 ** always overwrites every file named on the command-line, where as
14581 ** "update" only overwrites if the size or mtime or mode has changed.
14583 static int arCreateOrUpdateCommand(
14584 ArCommand *pAr, /* Command arguments and options */
14585 int bUpdate, /* true for a --create. */
14586 int bOnlyIfChanged /* Only update if file has changed */
14588 const char *zCreate =
14589 "CREATE TABLE IF NOT EXISTS sqlar(\n"
14590 " name TEXT PRIMARY KEY, -- name of the file\n"
14591 " mode INT, -- access permissions\n"
14592 " mtime INT, -- last modification time\n"
14593 " sz INT, -- original file size\n"
14594 " data BLOB -- compressed content\n"
14596 const char *zDrop = "DROP TABLE IF EXISTS sqlar";
14597 const char *zInsertFmt[2] = {
14598 "REPLACE INTO %s(name,mode,mtime,sz,data)\n"
14603 " CASE substr(lsmode(mode),1,1)\n"
14604 " WHEN '-' THEN length(data)\n"
14605 " WHEN 'd' THEN 0\n"
14607 " sqlar_compress(data)\n"
14608 " FROM fsdir(%Q,%Q) AS disk\n"
14609 " WHERE lsmode(mode) NOT LIKE '?%%'%s;"
14611 "REPLACE INTO %s(name,mode,mtime,data)\n"
14617 " FROM fsdir(%Q,%Q) AS disk\n"
14618 " WHERE lsmode(mode) NOT LIKE '?%%'%s;"
14620 int i; /* For iterating through azFile[] */
14621 int rc; /* Return code */
14622 const char *zTab = 0; /* SQL table into which to insert */
14627 arExecSql(pAr, "PRAGMA page_size=512");
14628 rc = arExecSql(pAr, "SAVEPOINT ar;");
14629 if( rc!=SQLITE_OK ) return rc;
14632 /* Initialize the zipfile virtual table, if necessary */
14635 sqlite3_randomness(sizeof(r),&r);
14636 sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r);
14638 zSql = sqlite3_mprintf(
14639 "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)",
14642 rc = arExecSql(pAr, zSql);
14643 sqlite3_free(zSql);
14648 /* Initialize the table for an SQLAR */
14651 rc = arExecSql(pAr, zDrop);
14652 if( rc!=SQLITE_OK ) goto end_ar_transaction;
14654 rc = arExecSql(pAr, zCreate);
14656 if( bOnlyIfChanged ){
14657 zExists = sqlite3_mprintf(
14659 "SELECT 1 FROM %s AS mem"
14660 " WHERE mem.name=disk.name"
14661 " AND mem.mtime=disk.mtime"
14662 " AND mem.mode=disk.mode)", zTab);
14664 zExists = sqlite3_mprintf("");
14666 if( zExists==0 ) rc = SQLITE_NOMEM;
14667 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){
14668 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab,
14669 pAr->bVerbose ? "shell_putsnl(name)" : "name",
14670 pAr->azArg[i], pAr->zDir, zExists);
14671 rc = arExecSql(pAr, zSql2);
14672 sqlite3_free(zSql2);
14674 end_ar_transaction:
14675 if( rc!=SQLITE_OK ){
14676 sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0);
14678 rc = arExecSql(pAr, "RELEASE ar;");
14679 if( pAr->bZip && pAr->zFile ){
14680 zSql = sqlite3_mprintf("DROP TABLE %s", zTemp);
14681 arExecSql(pAr, zSql);
14682 sqlite3_free(zSql);
14685 sqlite3_free(zExists);
14690 ** Implementation of ".ar" dot command.
14692 static int arDotCommand(
14693 ShellState *pState, /* Current shell tool state */
14694 int fromCmdLine, /* True if -A command-line option, not .ar cmd */
14695 char **azArg, /* Array of arguments passed to dot command */
14696 int nArg /* Number of entries in azArg[] */
14700 memset(&cmd, 0, sizeof(cmd));
14701 cmd.fromCmdLine = fromCmdLine;
14702 rc = arParseCommand(azArg, nArg, &cmd);
14703 if( rc==SQLITE_OK ){
14704 int eDbType = SHELL_OPEN_UNSPEC;
14706 cmd.db = pState->db;
14708 eDbType = deduceDatabaseType(cmd.zFile, 1);
14710 eDbType = pState->openMode;
14712 if( eDbType==SHELL_OPEN_ZIPFILE ){
14713 if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){
14714 if( cmd.zFile==0 ){
14715 cmd.zSrcTable = sqlite3_mprintf("zip");
14717 cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile);
14721 }else if( cmd.zFile ){
14723 if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS;
14724 if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT
14725 || cmd.eCmd==AR_CMD_UPDATE ){
14726 flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
14728 flags = SQLITE_OPEN_READONLY;
14732 utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile,
14733 eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
14735 rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags,
14736 eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0);
14737 if( rc!=SQLITE_OK ){
14738 utf8_printf(stderr, "cannot open file: %s (%s)\n",
14739 cmd.zFile, sqlite3_errmsg(cmd.db)
14741 goto end_ar_command;
14743 sqlite3_fileio_init(cmd.db, 0, 0);
14744 sqlite3_sqlar_init(cmd.db, 0, 0);
14745 sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p,
14746 shellPutsFunc, 0, 0);
14749 if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){
14750 if( cmd.eCmd!=AR_CMD_CREATE
14751 && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0)
14753 utf8_printf(stderr, "database does not contain an 'sqlar' table\n");
14755 goto end_ar_command;
14757 cmd.zSrcTable = sqlite3_mprintf("sqlar");
14760 switch( cmd.eCmd ){
14761 case AR_CMD_CREATE:
14762 rc = arCreateOrUpdateCommand(&cmd, 0, 0);
14765 case AR_CMD_EXTRACT:
14766 rc = arExtractCommand(&cmd);
14770 rc = arListCommand(&cmd);
14774 arUsage(pState->out);
14777 case AR_CMD_INSERT:
14778 rc = arCreateOrUpdateCommand(&cmd, 1, 0);
14782 assert( cmd.eCmd==AR_CMD_UPDATE );
14783 rc = arCreateOrUpdateCommand(&cmd, 1, 1);
14788 if( cmd.db!=pState->db ){
14791 sqlite3_free(cmd.zSrcTable);
14795 /* End of the ".archive" or ".ar" command logic
14796 *******************************************************************************/
14797 #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */
14799 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
14801 ** If (*pRc) is not SQLITE_OK when this function is called, it is a no-op.
14802 ** Otherwise, the SQL statement or statements in zSql are executed using
14803 ** database connection db and the error code written to *pRc before
14804 ** this function returns.
14806 static void shellExec(sqlite3 *db, int *pRc, const char *zSql){
14808 if( rc==SQLITE_OK ){
14810 rc = sqlite3_exec(db, zSql, 0, 0, &zErr);
14811 if( rc!=SQLITE_OK ){
14812 raw_printf(stderr, "SQL error: %s\n", zErr);
14819 ** Like shellExec(), except that zFmt is a printf() style format string.
14821 static void shellExecPrintf(sqlite3 *db, int *pRc, const char *zFmt, ...){
14823 if( *pRc==SQLITE_OK ){
14825 va_start(ap, zFmt);
14826 z = sqlite3_vmprintf(zFmt, ap);
14829 *pRc = SQLITE_NOMEM;
14831 shellExec(db, pRc, z);
14838 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
14839 ** Otherwise, an attempt is made to allocate, zero and return a pointer
14840 ** to a buffer nByte bytes in size. If an OOM error occurs, *pRc is set
14841 ** to SQLITE_NOMEM and NULL returned.
14843 static void *shellMalloc(int *pRc, sqlite3_int64 nByte){
14845 if( *pRc==SQLITE_OK ){
14846 pRet = sqlite3_malloc64(nByte);
14848 *pRc = SQLITE_NOMEM;
14850 memset(pRet, 0, nByte);
14857 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
14858 ** Otherwise, zFmt is treated as a printf() style string. The result of
14859 ** formatting it along with any trailing arguments is written into a
14860 ** buffer obtained from sqlite3_malloc(), and pointer to which is returned.
14861 ** It is the responsibility of the caller to eventually free this buffer
14862 ** using a call to sqlite3_free().
14864 ** If an OOM error occurs, (*pRc) is set to SQLITE_NOMEM and a NULL
14865 ** pointer returned.
14867 static char *shellMPrintf(int *pRc, const char *zFmt, ...){
14869 if( *pRc==SQLITE_OK ){
14871 va_start(ap, zFmt);
14872 z = sqlite3_vmprintf(zFmt, ap);
14875 *pRc = SQLITE_NOMEM;
14882 ** When running the ".recover" command, each output table, and the special
14883 ** orphaned row table if it is required, is represented by an instance
14884 ** of the following struct.
14886 typedef struct RecoverTable RecoverTable;
14887 struct RecoverTable {
14888 char *zQuoted; /* Quoted version of table name */
14889 int nCol; /* Number of columns in table */
14890 char **azlCol; /* Array of column lists */
14891 int iPk; /* Index of IPK column */
14895 ** Free a RecoverTable object allocated by recoverFindTable() or
14896 ** recoverOrphanTable().
14898 static void recoverFreeTable(RecoverTable *pTab){
14900 sqlite3_free(pTab->zQuoted);
14901 if( pTab->azlCol ){
14903 for(i=0; i<=pTab->nCol; i++){
14904 sqlite3_free(pTab->azlCol[i]);
14906 sqlite3_free(pTab->azlCol);
14908 sqlite3_free(pTab);
14913 ** This function is a no-op if (*pRc) is not SQLITE_OK when it is called.
14914 ** Otherwise, it allocates and returns a RecoverTable object based on the
14915 ** final four arguments passed to this function. It is the responsibility
14916 ** of the caller to eventually free the returned object using
14917 ** recoverFreeTable().
14919 static RecoverTable *recoverNewTable(
14920 int *pRc, /* IN/OUT: Error code */
14921 const char *zName, /* Name of table */
14922 const char *zSql, /* CREATE TABLE statement */
14926 sqlite3 *dbtmp = 0; /* sqlite3 handle for testing CREATE TABLE */
14928 RecoverTable *pTab = 0;
14930 pTab = (RecoverTable*)shellMalloc(&rc, sizeof(RecoverTable));
14931 if( rc==SQLITE_OK ){
14933 int bSqlIntkey = 0;
14934 sqlite3_stmt *pStmt = 0;
14936 rc = sqlite3_open("", &dbtmp);
14937 if( rc==SQLITE_OK ){
14938 sqlite3_create_function(dbtmp, "shell_idquote", 1, SQLITE_UTF8, 0,
14939 shellIdQuote, 0, 0);
14941 if( rc==SQLITE_OK ){
14942 rc = sqlite3_exec(dbtmp, "PRAGMA writable_schema = on", 0, 0, 0);
14944 if( rc==SQLITE_OK ){
14945 rc = sqlite3_exec(dbtmp, zSql, 0, 0, 0);
14946 if( rc==SQLITE_ERROR ){
14951 shellPreparePrintf(dbtmp, &rc, &pStmt,
14952 "SELECT count(*) FROM pragma_table_info(%Q)", zName
14954 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14955 nSqlCol = sqlite3_column_int(pStmt, 0);
14957 shellFinalize(&rc, pStmt);
14959 if( rc!=SQLITE_OK || nSqlCol<nCol ){
14963 shellPreparePrintf(dbtmp, &rc, &pStmt,
14965 " SELECT substr(data,1,1)==X'0D' FROM sqlite_dbpage WHERE pgno=rootpage"
14966 ") FROM sqlite_master WHERE name = %Q", zName
14968 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
14969 bSqlIntkey = sqlite3_column_int(pStmt, 0);
14971 shellFinalize(&rc, pStmt);
14973 if( bIntkey==bSqlIntkey ){
14975 const char *zPk = "_rowid_";
14976 sqlite3_stmt *pPkFinder = 0;
14978 /* If this is an intkey table and there is an INTEGER PRIMARY KEY,
14979 ** set zPk to the name of the PK column, and pTab->iPk to the index
14980 ** of the column, where columns are 0-numbered from left to right.
14981 ** Or, if this is a WITHOUT ROWID table or if there is no IPK column,
14982 ** leave zPk as "_rowid_" and pTab->iPk at -2. */
14985 shellPreparePrintf(dbtmp, &rc, &pPkFinder,
14986 "SELECT cid, name FROM pragma_table_info(%Q) "
14987 " WHERE pk=1 AND type='integer' COLLATE nocase"
14988 " AND NOT EXISTS (SELECT cid FROM pragma_table_info(%Q) WHERE pk=2)"
14991 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPkFinder) ){
14992 pTab->iPk = sqlite3_column_int(pPkFinder, 0);
14993 zPk = (const char*)sqlite3_column_text(pPkFinder, 1);
14997 pTab->zQuoted = shellMPrintf(&rc, "\"%w\"", zName);
14998 pTab->azlCol = (char**)shellMalloc(&rc, sizeof(char*) * (nSqlCol+1));
14999 pTab->nCol = nSqlCol;
15002 pTab->azlCol[0] = shellMPrintf(&rc, "\"%w\"", zPk);
15004 pTab->azlCol[0] = shellMPrintf(&rc, "");
15007 shellPreparePrintf(dbtmp, &rc, &pStmt,
15008 "SELECT %Q || group_concat(shell_idquote(name), ', ') "
15009 " FILTER (WHERE cid!=%d) OVER (ORDER BY %s cid) "
15010 "FROM pragma_table_info(%Q)",
15011 bIntkey ? ", " : "", pTab->iPk,
15012 bIntkey ? "" : "(CASE WHEN pk=0 THEN 1000000 ELSE pk END), ",
15015 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15016 const char *zText = (const char*)sqlite3_column_text(pStmt, 0);
15017 pTab->azlCol[i] = shellMPrintf(&rc, "%s%s", pTab->azlCol[0], zText);
15020 shellFinalize(&rc, pStmt);
15022 shellFinalize(&rc, pPkFinder);
15027 sqlite3_close(dbtmp);
15029 if( rc!=SQLITE_OK || (pTab && pTab->zQuoted==0) ){
15030 recoverFreeTable(pTab);
15037 ** This function is called to search the schema recovered from the
15038 ** sqlite_master table of the (possibly) corrupt database as part
15039 ** of a ".recover" command. Specifically, for a table with root page
15040 ** iRoot and at least nCol columns. Additionally, if bIntkey is 0, the
15041 ** table must be a WITHOUT ROWID table, or if non-zero, not one of
15044 ** If a table is found, a (RecoverTable*) object is returned. Or, if
15045 ** no such table is found, but bIntkey is false and iRoot is the
15046 ** root page of an index in the recovered schema, then (*pbNoop) is
15047 ** set to true and NULL returned. Or, if there is no such table or
15048 ** index, NULL is returned and (*pbNoop) set to 0, indicating that
15049 ** the caller should write data to the orphans table.
15051 static RecoverTable *recoverFindTable(
15052 ShellState *pState, /* Shell state object */
15053 int *pRc, /* IN/OUT: Error code */
15054 int iRoot, /* Root page of table */
15055 int bIntkey, /* True for an intkey table */
15056 int nCol, /* Number of columns in table */
15057 int *pbNoop /* OUT: True if iRoot is root of index */
15059 sqlite3_stmt *pStmt = 0;
15060 RecoverTable *pRet = 0;
15062 const char *zSql = 0;
15063 const char *zName = 0;
15065 /* Search the recovered schema for an object with root page iRoot. */
15066 shellPreparePrintf(pState->db, pRc, &pStmt,
15067 "SELECT type, name, sql FROM recovery.schema WHERE rootpage=%d", iRoot
15069 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15070 const char *zType = (const char*)sqlite3_column_text(pStmt, 0);
15071 if( bIntkey==0 && sqlite3_stricmp(zType, "index")==0 ){
15075 if( sqlite3_stricmp(zType, "table")==0 ){
15076 zName = (const char*)sqlite3_column_text(pStmt, 1);
15077 zSql = (const char*)sqlite3_column_text(pStmt, 2);
15078 pRet = recoverNewTable(pRc, zName, zSql, bIntkey, nCol);
15083 shellFinalize(pRc, pStmt);
15089 ** Return a RecoverTable object representing the orphans table.
15091 static RecoverTable *recoverOrphanTable(
15092 ShellState *pState, /* Shell state object */
15093 int *pRc, /* IN/OUT: Error code */
15094 const char *zLostAndFound, /* Base name for orphans table */
15095 int nCol /* Number of user data columns */
15097 RecoverTable *pTab = 0;
15098 if( nCol>=0 && *pRc==SQLITE_OK ){
15101 /* This block determines the name of the orphan table. The prefered
15102 ** name is zLostAndFound. But if that clashes with another name
15103 ** in the recovered schema, try zLostAndFound_0, zLostAndFound_1
15104 ** and so on until a non-clashing name is found. */
15106 char *zTab = shellMPrintf(pRc, "%s", zLostAndFound);
15107 sqlite3_stmt *pTest = 0;
15108 shellPrepare(pState->db, pRc,
15109 "SELECT 1 FROM recovery.schema WHERE name=?", &pTest
15111 if( pTest ) sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT);
15112 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pTest) ){
15113 shellReset(pRc, pTest);
15114 sqlite3_free(zTab);
15115 zTab = shellMPrintf(pRc, "%s_%d", zLostAndFound, iTab++);
15116 sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT);
15118 shellFinalize(pRc, pTest);
15120 pTab = (RecoverTable*)shellMalloc(pRc, sizeof(RecoverTable));
15122 pTab->zQuoted = shellMPrintf(pRc, "\"%w\"", zTab);
15126 pTab->azlCol = (char**)shellMalloc(pRc, sizeof(char*) * (nCol+1));
15127 if( pTab->azlCol ){
15128 pTab->azlCol[nCol] = shellMPrintf(pRc, "");
15129 for(i=nCol-1; i>=0; i--){
15130 pTab->azlCol[i] = shellMPrintf(pRc, "%s, NULL", pTab->azlCol[i+1]);
15135 if( *pRc!=SQLITE_OK ){
15136 recoverFreeTable(pTab);
15139 raw_printf(pState->out,
15140 "CREATE TABLE %s(rootpgno INTEGER, "
15141 "pgno INTEGER, nfield INTEGER, id INTEGER", pTab->zQuoted
15143 for(i=0; i<nCol; i++){
15144 raw_printf(pState->out, ", c%d", i);
15146 raw_printf(pState->out, ");\n");
15149 sqlite3_free(zTab);
15155 ** This function is called to recover data from the database. A script
15156 ** to construct a new database containing all recovered data is output
15157 ** on stream pState->out.
15159 static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){
15160 int rc = SQLITE_OK;
15161 sqlite3_stmt *pLoop = 0; /* Loop through all root pages */
15162 sqlite3_stmt *pPages = 0; /* Loop through all pages in a group */
15163 sqlite3_stmt *pCells = 0; /* Loop through all cells in a page */
15164 const char *zRecoveryDb = ""; /* Name of "recovery" database */
15165 const char *zLostAndFound = "lost_and_found";
15168 RecoverTable *pOrphan = 0;
15170 int bFreelist = 1; /* 0 if --freelist-corrupt is specified */
15171 int bRowids = 1; /* 0 if --no-rowids */
15172 for(i=1; i<nArg; i++){
15173 char *z = azArg[i];
15175 if( z[0]=='-' && z[1]=='-' ) z++;
15177 if( n<=17 && memcmp("-freelist-corrupt", z, n)==0 ){
15180 if( n<=12 && memcmp("-recovery-db", z, n)==0 && i<(nArg-1) ){
15182 zRecoveryDb = azArg[i];
15184 if( n<=15 && memcmp("-lost-and-found", z, n)==0 && i<(nArg-1) ){
15186 zLostAndFound = azArg[i];
15188 if( n<=10 && memcmp("-no-rowids", z, n)==0 ){
15192 utf8_printf(stderr, "unexpected option: %s\n", azArg[i]);
15193 showHelp(pState->out, azArg[0]);
15198 shellExecPrintf(pState->db, &rc,
15199 /* Attach an in-memory database named 'recovery'. Create an indexed
15200 ** cache of the sqlite_dbptr virtual table. */
15201 "PRAGMA writable_schema = on;"
15202 "ATTACH %Q AS recovery;"
15203 "DROP TABLE IF EXISTS recovery.dbptr;"
15204 "DROP TABLE IF EXISTS recovery.freelist;"
15205 "DROP TABLE IF EXISTS recovery.map;"
15206 "DROP TABLE IF EXISTS recovery.schema;"
15207 "CREATE TABLE recovery.freelist(pgno INTEGER PRIMARY KEY);", zRecoveryDb
15211 shellExec(pState->db, &rc,
15212 "WITH trunk(pgno) AS ("
15213 " SELECT shell_int32("
15214 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 8) AS x "
15217 " SELECT shell_int32("
15218 " (SELECT data FROM sqlite_dbpage WHERE pgno=trunk.pgno), 0) AS x "
15219 " FROM trunk WHERE x>0"
15221 "freelist(data, n, freepgno) AS ("
15222 " SELECT data, min(16384, shell_int32(data, 1)-1), t.pgno "
15223 " FROM trunk t, sqlite_dbpage s WHERE s.pgno=t.pgno"
15225 " SELECT data, n-1, shell_int32(data, 2+n) "
15226 " FROM freelist WHERE n>=0"
15228 "REPLACE INTO recovery.freelist SELECT freepgno FROM freelist;"
15232 /* If this is an auto-vacuum database, add all pointer-map pages to
15233 ** the freelist table. Do this regardless of whether or not
15234 ** --freelist-corrupt was specified. */
15235 shellExec(pState->db, &rc,
15236 "WITH ptrmap(pgno) AS ("
15237 " SELECT 2 WHERE shell_int32("
15238 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 13"
15241 " SELECT pgno+1+(SELECT page_size FROM pragma_page_size)/5 AS pp "
15242 " FROM ptrmap WHERE pp<=(SELECT page_count FROM pragma_page_count)"
15244 "REPLACE INTO recovery.freelist SELECT pgno FROM ptrmap"
15247 shellExec(pState->db, &rc,
15248 "CREATE TABLE recovery.dbptr("
15249 " pgno, child, PRIMARY KEY(child, pgno)"
15251 "INSERT OR IGNORE INTO recovery.dbptr(pgno, child) "
15252 " SELECT * FROM sqlite_dbptr"
15253 " WHERE pgno NOT IN freelist AND child NOT IN freelist;"
15255 /* Delete any pointer to page 1. This ensures that page 1 is considered
15256 ** a root page, regardless of how corrupt the db is. */
15257 "DELETE FROM recovery.dbptr WHERE child = 1;"
15259 /* Delete all pointers to any pages that have more than one pointer
15260 ** to them. Such pages will be treated as root pages when recovering
15262 "DELETE FROM recovery.dbptr WHERE child IN ("
15263 " SELECT child FROM recovery.dbptr GROUP BY child HAVING count(*)>1"
15266 /* Create the "map" table that will (eventually) contain instructions
15267 ** for dealing with each page in the db that contains one or more
15269 "CREATE TABLE recovery.map("
15270 "pgno INTEGER PRIMARY KEY, maxlen INT, intkey, root INT"
15273 /* Populate table [map]. If there are circular loops of pages in the
15274 ** database, the following adds all pages in such a loop to the map
15275 ** as individual root pages. This could be handled better. */
15276 "WITH pages(i, maxlen) AS ("
15277 " SELECT page_count, ("
15278 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=page_count"
15279 " ) FROM pragma_page_count WHERE page_count>0"
15282 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=i-1"
15283 " ) FROM pages WHERE i>=2"
15285 "INSERT INTO recovery.map(pgno, maxlen, intkey, root) "
15286 " SELECT i, maxlen, NULL, ("
15287 " WITH p(orig, pgno, parent) AS ("
15288 " SELECT 0, i, (SELECT pgno FROM recovery.dbptr WHERE child=i)"
15290 " SELECT i, p.parent, "
15291 " (SELECT pgno FROM recovery.dbptr WHERE child=p.parent) FROM p"
15293 " SELECT pgno FROM p WHERE (parent IS NULL OR pgno = orig)"
15295 "FROM pages WHERE maxlen IS NOT NULL AND i NOT IN freelist;"
15296 "UPDATE recovery.map AS o SET intkey = ("
15297 " SELECT substr(data, 1, 1)==X'0D' FROM sqlite_dbpage WHERE pgno=o.pgno"
15300 /* Extract data from page 1 and any linked pages into table
15301 ** recovery.schema. With the same schema as an sqlite_master table. */
15302 "CREATE TABLE recovery.schema(type, name, tbl_name, rootpage, sql);"
15303 "INSERT INTO recovery.schema SELECT "
15304 " max(CASE WHEN field=0 THEN value ELSE NULL END),"
15305 " max(CASE WHEN field=1 THEN value ELSE NULL END),"
15306 " max(CASE WHEN field=2 THEN value ELSE NULL END),"
15307 " max(CASE WHEN field=3 THEN value ELSE NULL END),"
15308 " max(CASE WHEN field=4 THEN value ELSE NULL END)"
15309 "FROM sqlite_dbdata WHERE pgno IN ("
15310 " SELECT pgno FROM recovery.map WHERE root=1"
15312 "GROUP BY pgno, cell;"
15313 "CREATE INDEX recovery.schema_rootpage ON schema(rootpage);"
15316 /* Open a transaction, then print out all non-virtual, non-"sqlite_%"
15317 ** CREATE TABLE statements that extracted from the existing schema. */
15318 if( rc==SQLITE_OK ){
15319 sqlite3_stmt *pStmt = 0;
15320 /* ".recover" might output content in an order which causes immediate
15321 ** foreign key constraints to be violated. So disable foreign-key
15322 ** constraint enforcement to prevent problems when running the output
15324 raw_printf(pState->out, "PRAGMA foreign_keys=OFF;\n");
15325 raw_printf(pState->out, "BEGIN;\n");
15326 raw_printf(pState->out, "PRAGMA writable_schema = on;\n");
15327 shellPrepare(pState->db, &rc,
15328 "SELECT sql FROM recovery.schema "
15329 "WHERE type='table' AND sql LIKE 'create table%'", &pStmt
15331 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15332 const char *zCreateTable = (const char*)sqlite3_column_text(pStmt, 0);
15333 raw_printf(pState->out, "CREATE TABLE IF NOT EXISTS %s;\n",
15337 shellFinalize(&rc, pStmt);
15340 /* Figure out if an orphan table will be required. And if so, how many
15341 ** user columns it should contain */
15342 shellPrepare(pState->db, &rc,
15343 "SELECT coalesce(max(maxlen), -2) FROM recovery.map WHERE root>1"
15346 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){
15347 nOrphan = sqlite3_column_int(pLoop, 0);
15349 shellFinalize(&rc, pLoop);
15352 shellPrepare(pState->db, &rc,
15353 "SELECT pgno FROM recovery.map WHERE root=?", &pPages
15356 shellPrepare(pState->db, &rc,
15357 "SELECT max(field), group_concat(shell_escape_crnl(quote"
15358 "(case when (? AND field<0) then NULL else value end)"
15361 "FROM sqlite_dbdata WHERE pgno = ? AND field != ?"
15362 "GROUP BY cell", &pCells
15365 /* Loop through each root page. */
15366 shellPrepare(pState->db, &rc,
15367 "SELECT root, intkey, max(maxlen) FROM recovery.map"
15368 " WHERE root>1 GROUP BY root, intkey ORDER BY root=("
15369 " SELECT rootpage FROM recovery.schema WHERE name='sqlite_sequence'"
15372 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){
15373 int iRoot = sqlite3_column_int(pLoop, 0);
15374 int bIntkey = sqlite3_column_int(pLoop, 1);
15375 int nCol = sqlite3_column_int(pLoop, 2);
15377 RecoverTable *pTab;
15379 assert( bIntkey==0 || bIntkey==1 );
15380 pTab = recoverFindTable(pState, &rc, iRoot, bIntkey, nCol, &bNoop);
15381 if( bNoop || rc ) continue;
15384 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan);
15387 if( pTab==0 ) break;
15390 if( 0==sqlite3_stricmp(pTab->zQuoted, "\"sqlite_sequence\"") ){
15391 raw_printf(pState->out, "DELETE FROM sqlite_sequence;\n");
15393 sqlite3_bind_int(pPages, 1, iRoot);
15394 if( bRowids==0 && pTab->iPk<0 ){
15395 sqlite3_bind_int(pCells, 1, 1);
15397 sqlite3_bind_int(pCells, 1, 0);
15399 sqlite3_bind_int(pCells, 3, pTab->iPk);
15401 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPages) ){
15402 int iPgno = sqlite3_column_int(pPages, 0);
15403 sqlite3_bind_int(pCells, 2, iPgno);
15404 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pCells) ){
15405 int nField = sqlite3_column_int(pCells, 0);
15406 int iMin = sqlite3_column_int(pCells, 2);
15407 const char *zVal = (const char*)sqlite3_column_text(pCells, 1);
15409 RecoverTable *pTab2 = pTab;
15410 if( pTab!=pOrphan && (iMin<0)!=bIntkey ){
15412 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan);
15415 if( pTab2==0 ) break;
15419 if( pTab2==pOrphan ){
15420 raw_printf(pState->out,
15421 "INSERT INTO %s VALUES(%d, %d, %d, %s%s%s);\n",
15422 pTab2->zQuoted, iRoot, iPgno, nField,
15423 iMin<0 ? "" : "NULL, ", zVal, pTab2->azlCol[nField]
15426 raw_printf(pState->out, "INSERT INTO %s(%s) VALUES( %s );\n",
15427 pTab2->zQuoted, pTab2->azlCol[nField], zVal
15431 shellReset(&rc, pCells);
15433 shellReset(&rc, pPages);
15434 if( pTab!=pOrphan ) recoverFreeTable(pTab);
15436 shellFinalize(&rc, pLoop);
15437 shellFinalize(&rc, pPages);
15438 shellFinalize(&rc, pCells);
15439 recoverFreeTable(pOrphan);
15441 /* The rest of the schema */
15442 if( rc==SQLITE_OK ){
15443 sqlite3_stmt *pStmt = 0;
15444 shellPrepare(pState->db, &rc,
15445 "SELECT sql, name FROM recovery.schema "
15446 "WHERE sql NOT LIKE 'create table%'", &pStmt
15448 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
15449 const char *zSql = (const char*)sqlite3_column_text(pStmt, 0);
15450 if( sqlite3_strnicmp(zSql, "create virt", 11)==0 ){
15451 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
15452 char *zPrint = shellMPrintf(&rc,
15453 "INSERT INTO sqlite_master VALUES('table', %Q, %Q, 0, %Q)",
15456 raw_printf(pState->out, "%s;\n", zPrint);
15457 sqlite3_free(zPrint);
15459 raw_printf(pState->out, "%s;\n", zSql);
15462 shellFinalize(&rc, pStmt);
15465 if( rc==SQLITE_OK ){
15466 raw_printf(pState->out, "PRAGMA writable_schema = off;\n");
15467 raw_printf(pState->out, "COMMIT;\n");
15469 sqlite3_exec(pState->db, "DETACH recovery", 0, 0, 0);
15472 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */
15476 ** If an input line begins with "." then invoke this routine to
15477 ** process that line.
15479 ** Return 1 on error, 2 to exit, and 0 otherwise.
15481 static int do_meta_command(char *zLine, ShellState *p){
15488 #ifndef SQLITE_OMIT_VIRTUALTABLE
15489 if( p->expert.pExpert ){
15490 expertFinish(p, 1, 0);
15494 /* Parse the input line into tokens.
15496 while( zLine[h] && nArg<ArraySize(azArg)-1 ){
15497 while( IsSpace(zLine[h]) ){ h++; }
15498 if( zLine[h]==0 ) break;
15499 if( zLine[h]=='\'' || zLine[h]=='"' ){
15500 int delim = zLine[h++];
15501 azArg[nArg++] = &zLine[h];
15502 while( zLine[h] && zLine[h]!=delim ){
15503 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
15506 if( zLine[h]==delim ){
15509 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
15511 azArg[nArg++] = &zLine[h];
15512 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
15513 if( zLine[h] ) zLine[h++] = 0;
15514 resolve_backslashes(azArg[nArg-1]);
15519 /* Process the input line.
15521 if( nArg==0 ) return 0; /* no tokens, no error */
15522 n = strlen30(azArg[0]);
15526 #ifndef SQLITE_OMIT_AUTHORIZATION
15527 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){
15529 raw_printf(stderr, "Usage: .auth ON|OFF\n");
15531 goto meta_command_exit;
15534 if( booleanValue(azArg[1]) ){
15535 sqlite3_set_authorizer(p->db, shellAuth, p);
15537 sqlite3_set_authorizer(p->db, 0, 0);
15542 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
15543 if( c=='a' && strncmp(azArg[0], "archive", n)==0 ){
15545 rc = arDotCommand(p, 0, azArg, nArg);
15549 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
15550 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
15552 const char *zDestFile = 0;
15553 const char *zDb = 0;
15555 sqlite3_backup *pBackup;
15558 const char *zVfs = 0;
15559 for(j=1; j<nArg; j++){
15560 const char *z = azArg[j];
15562 if( z[1]=='-' ) z++;
15563 if( strcmp(z, "-append")==0 ){
15566 if( strcmp(z, "-async")==0 ){
15570 utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
15573 }else if( zDestFile==0 ){
15574 zDestFile = azArg[j];
15575 }else if( zDb==0 ){
15577 zDestFile = azArg[j];
15579 raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
15583 if( zDestFile==0 ){
15584 raw_printf(stderr, "missing FILENAME argument on .backup\n");
15587 if( zDb==0 ) zDb = "main";
15588 rc = sqlite3_open_v2(zDestFile, &pDest,
15589 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs);
15590 if( rc!=SQLITE_OK ){
15591 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
15596 sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
15600 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
15602 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
15606 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
15607 sqlite3_backup_finish(pBackup);
15608 if( rc==SQLITE_DONE ){
15611 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
15617 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
15619 bail_on_error = booleanValue(azArg[1]);
15621 raw_printf(stderr, "Usage: .bail on|off\n");
15626 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
15628 if( booleanValue(azArg[1]) ){
15629 setBinaryMode(p->out, 1);
15631 setTextMode(p->out, 1);
15634 raw_printf(stderr, "Usage: .binary on|off\n");
15639 if( c=='c' && strcmp(azArg[0],"cd")==0 ){
15641 #if defined(_WIN32) || defined(WIN32)
15642 wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]);
15643 rc = !SetCurrentDirectoryW(z);
15646 rc = chdir(azArg[1]);
15649 utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]);
15653 raw_printf(stderr, "Usage: .cd DIRECTORY\n");
15658 /* The undocumented ".breakpoint" command causes a call to the no-op
15659 ** routine named test_breakpoint().
15661 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
15665 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
15667 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
15669 raw_printf(stderr, "Usage: .changes on|off\n");
15674 /* Cancel output redirection, if it is currently set (by .testcase)
15675 ** Then read the content of the testcase-out.txt file and compare against
15676 ** azArg[1]. If there are differences, report an error and exit.
15678 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){
15682 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n");
15684 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
15685 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n");
15687 }else if( testcase_glob(azArg[1],zRes)==0 ){
15688 utf8_printf(stderr,
15689 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
15690 p->zTestcase, azArg[1], zRes);
15693 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase);
15696 sqlite3_free(zRes);
15699 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
15701 tryToClone(p, azArg[1]);
15703 raw_printf(stderr, "Usage: .clone FILENAME\n");
15708 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
15712 memcpy(&data, p, sizeof(data));
15713 data.showHeader = 0;
15714 data.cMode = data.mode = MODE_List;
15715 sqlite3_snprintf(sizeof(data.colSeparator),data.colSeparator,": ");
15717 sqlite3_exec(p->db, "SELECT name, file FROM pragma_database_list",
15718 callback, &data, &zErrMsg);
15720 utf8_printf(stderr,"Error: %s\n", zErrMsg);
15721 sqlite3_free(zErrMsg);
15726 if( c=='d' && n>=3 && strncmp(azArg[0], "dbconfig", n)==0 ){
15727 static const struct DbConfigChoices {
15731 { "defensive", SQLITE_DBCONFIG_DEFENSIVE },
15732 { "dqs_ddl", SQLITE_DBCONFIG_DQS_DDL },
15733 { "dqs_dml", SQLITE_DBCONFIG_DQS_DML },
15734 { "enable_fkey", SQLITE_DBCONFIG_ENABLE_FKEY },
15735 { "enable_qpsg", SQLITE_DBCONFIG_ENABLE_QPSG },
15736 { "enable_trigger", SQLITE_DBCONFIG_ENABLE_TRIGGER },
15737 { "enable_view", SQLITE_DBCONFIG_ENABLE_VIEW },
15738 { "fts3_tokenizer", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
15739 { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE },
15740 { "legacy_file_format", SQLITE_DBCONFIG_LEGACY_FILE_FORMAT },
15741 { "load_extension", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
15742 { "no_ckpt_on_close", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE },
15743 { "reset_database", SQLITE_DBCONFIG_RESET_DATABASE },
15744 { "trigger_eqp", SQLITE_DBCONFIG_TRIGGER_EQP },
15745 { "trusted_schema", SQLITE_DBCONFIG_TRUSTED_SCHEMA },
15746 { "writable_schema", SQLITE_DBCONFIG_WRITABLE_SCHEMA },
15750 for(ii=0; ii<ArraySize(aDbConfig); ii++){
15751 if( nArg>1 && strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
15753 sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
15755 sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
15756 utf8_printf(p->out, "%19s %s\n", aDbConfig[ii].zName, v ? "on" : "off");
15757 if( nArg>1 ) break;
15759 if( nArg>1 && ii==ArraySize(aDbConfig) ){
15760 utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]);
15761 utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n");
15765 if( c=='d' && n>=3 && strncmp(azArg[0], "dbinfo", n)==0 ){
15766 rc = shell_dbinfo_command(p, nArg, azArg);
15769 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
15770 if( c=='r' && strncmp(azArg[0], "recover", n)==0 ){
15772 rc = recoverDatabaseCmd(p, nArg, azArg);
15774 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */
15776 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
15777 const char *zLike = 0;
15779 int savedShowHeader = p->showHeader;
15780 int savedShellFlags = p->shellFlgs;
15781 ShellClearFlag(p, SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo);
15782 for(i=1; i<nArg; i++){
15783 if( azArg[i][0]=='-' ){
15784 const char *z = azArg[i]+1;
15785 if( z[0]=='-' ) z++;
15786 if( strcmp(z,"preserve-rowids")==0 ){
15787 #ifdef SQLITE_OMIT_VIRTUALTABLE
15788 raw_printf(stderr, "The --preserve-rowids option is not compatible"
15789 " with SQLITE_OMIT_VIRTUALTABLE\n");
15791 goto meta_command_exit;
15793 ShellSetFlag(p, SHFLG_PreserveRowid);
15796 if( strcmp(z,"newlines")==0 ){
15797 ShellSetFlag(p, SHFLG_Newlines);
15800 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
15802 goto meta_command_exit;
15805 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? "
15806 "?--newlines? ?LIKE-PATTERN?\n");
15808 goto meta_command_exit;
15816 /* When playing back a "dump", the content might appear in an order
15817 ** which causes immediate foreign key constraints to be violated.
15818 ** So disable foreign-key constraint enforcement to prevent problems. */
15819 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
15820 raw_printf(p->out, "BEGIN TRANSACTION;\n");
15821 p->writableSchema = 0;
15823 /* Set writable_schema=ON since doing so forces SQLite to initialize
15824 ** as much of the schema as it can even if the sqlite_master table is
15826 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
15829 run_schema_dump_query(p,
15830 "SELECT name, type, sql FROM sqlite_master "
15831 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
15833 run_schema_dump_query(p,
15834 "SELECT name, type, sql FROM sqlite_master "
15835 "WHERE name=='sqlite_sequence'"
15837 run_table_dump_query(p,
15838 "SELECT sql FROM sqlite_master "
15839 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
15843 zSql = sqlite3_mprintf(
15844 "SELECT name, type, sql FROM sqlite_master "
15845 "WHERE tbl_name LIKE %Q AND type=='table'"
15846 " AND sql NOT NULL", zLike);
15847 run_schema_dump_query(p,zSql);
15848 sqlite3_free(zSql);
15849 zSql = sqlite3_mprintf(
15850 "SELECT sql FROM sqlite_master "
15851 "WHERE sql NOT NULL"
15852 " AND type IN ('index','trigger','view')"
15853 " AND tbl_name LIKE %Q", zLike);
15854 run_table_dump_query(p, zSql, 0);
15855 sqlite3_free(zSql);
15857 if( p->writableSchema ){
15858 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
15859 p->writableSchema = 0;
15861 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
15862 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
15863 raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n");
15864 p->showHeader = savedShowHeader;
15865 p->shellFlgs = savedShellFlags;
15868 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
15870 setOrClearFlag(p, SHFLG_Echo, azArg[1]);
15872 raw_printf(stderr, "Usage: .echo on|off\n");
15877 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
15879 p->autoEQPtest = 0;
15880 if( p->autoEQPtrace ){
15881 if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0);
15882 p->autoEQPtrace = 0;
15884 if( strcmp(azArg[1],"full")==0 ){
15885 p->autoEQP = AUTOEQP_full;
15886 }else if( strcmp(azArg[1],"trigger")==0 ){
15887 p->autoEQP = AUTOEQP_trigger;
15888 #ifdef SQLITE_DEBUG
15889 }else if( strcmp(azArg[1],"test")==0 ){
15890 p->autoEQP = AUTOEQP_on;
15891 p->autoEQPtest = 1;
15892 }else if( strcmp(azArg[1],"trace")==0 ){
15893 p->autoEQP = AUTOEQP_full;
15894 p->autoEQPtrace = 1;
15896 sqlite3_exec(p->db, "SELECT name FROM sqlite_master LIMIT 1", 0, 0, 0);
15897 sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0);
15900 p->autoEQP = (u8)booleanValue(azArg[1]);
15903 raw_printf(stderr, "Usage: .eqp off|on|trace|trigger|full\n");
15908 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
15909 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
15913 /* The ".explain" command is automatic now. It is largely pointless. It
15914 ** retained purely for backwards compatibility */
15915 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
15918 if( strcmp(azArg[1],"auto")==0 ){
15921 val = booleanValue(azArg[1]);
15924 if( val==1 && p->mode!=MODE_Explain ){
15925 p->normalMode = p->mode;
15926 p->mode = MODE_Explain;
15927 p->autoExplain = 0;
15928 }else if( val==0 ){
15929 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
15930 p->autoExplain = 0;
15931 }else if( val==99 ){
15932 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
15933 p->autoExplain = 1;
15937 #ifndef SQLITE_OMIT_VIRTUALTABLE
15938 if( c=='e' && strncmp(azArg[0], "expert", n)==0 ){
15940 expertDotCommand(p, azArg, nArg);
15944 if( c=='f' && strncmp(azArg[0], "filectrl", n)==0 ){
15945 static const struct {
15946 const char *zCtrlName; /* Name of a test-control option */
15947 int ctrlCode; /* Integer code for that option */
15948 const char *zUsage; /* Usage notes */
15950 { "size_limit", SQLITE_FCNTL_SIZE_LIMIT, "[LIMIT]" },
15951 { "chunk_size", SQLITE_FCNTL_CHUNK_SIZE, "SIZE" },
15952 /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY, "COUNT DELAY" },*/
15953 { "persist_wal", SQLITE_FCNTL_PERSIST_WAL, "[BOOLEAN]" },
15954 { "psow", SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]" },
15955 /* { "pragma", SQLITE_FCNTL_PRAGMA, "NAME ARG" },*/
15956 { "tempfilename", SQLITE_FCNTL_TEMPFILENAME, "" },
15957 { "has_moved", SQLITE_FCNTL_HAS_MOVED, "" },
15958 { "lock_timeout", SQLITE_FCNTL_LOCK_TIMEOUT, "MILLISEC" },
15962 sqlite3_int64 iRes = 0; /* Integer result to display if rc2==1 */
15963 int isOk = 0; /* 0: usage 1: %lld 2: no-result */
15965 const char *zCmd = 0;
15968 zCmd = nArg>=2 ? azArg[1] : "help";
15970 /* The argument can optionally begin with "-" or "--" */
15971 if( zCmd[0]=='-' && zCmd[1] ){
15973 if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
15976 /* --help lists all file-controls */
15977 if( strcmp(zCmd,"help")==0 ){
15978 utf8_printf(p->out, "Available file-controls:\n");
15979 for(i=0; i<ArraySize(aCtrl); i++){
15980 utf8_printf(p->out, " .filectrl %s %s\n",
15981 aCtrl[i].zCtrlName, aCtrl[i].zUsage);
15984 goto meta_command_exit;
15987 /* convert filectrl text option to value. allow any unique prefix
15988 ** of the option name, or a numerical value. */
15989 n2 = strlen30(zCmd);
15990 for(i=0; i<ArraySize(aCtrl); i++){
15991 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
15993 filectrl = aCtrl[i].ctrlCode;
15996 utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n"
15997 "Use \".filectrl --help\" for help\n", zCmd);
15999 goto meta_command_exit;
16004 utf8_printf(stderr,"Error: unknown file-control: %s\n"
16005 "Use \".filectrl --help\" for help\n", zCmd);
16008 case SQLITE_FCNTL_SIZE_LIMIT: {
16009 if( nArg!=2 && nArg!=3 ) break;
16010 iRes = nArg==3 ? integerValue(azArg[2]) : -1;
16011 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_SIZE_LIMIT, &iRes);
16015 case SQLITE_FCNTL_LOCK_TIMEOUT:
16016 case SQLITE_FCNTL_CHUNK_SIZE: {
16018 if( nArg!=3 ) break;
16019 x = (int)integerValue(azArg[2]);
16020 sqlite3_file_control(p->db, 0, filectrl, &x);
16024 case SQLITE_FCNTL_PERSIST_WAL:
16025 case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
16027 if( nArg!=2 && nArg!=3 ) break;
16028 x = nArg==3 ? booleanValue(azArg[2]) : -1;
16029 sqlite3_file_control(p->db, 0, filectrl, &x);
16034 case SQLITE_FCNTL_HAS_MOVED: {
16036 if( nArg!=2 ) break;
16037 sqlite3_file_control(p->db, 0, filectrl, &x);
16042 case SQLITE_FCNTL_TEMPFILENAME: {
16044 if( nArg!=2 ) break;
16045 sqlite3_file_control(p->db, 0, filectrl, &z);
16047 utf8_printf(p->out, "%s\n", z);
16055 if( isOk==0 && iCtrl>=0 ){
16056 utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
16058 }else if( isOk==1 ){
16060 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
16061 raw_printf(p->out, "%s\n", zBuf);
16065 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
16069 memcpy(&data, p, sizeof(data));
16070 data.showHeader = 0;
16071 data.cMode = data.mode = MODE_Semi;
16072 if( nArg==2 && optionMatch(azArg[1], "indent") ){
16073 data.cMode = data.mode = MODE_Pretty;
16077 raw_printf(stderr, "Usage: .fullschema ?--indent?\n");
16079 goto meta_command_exit;
16082 rc = sqlite3_exec(p->db,
16084 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
16085 " FROM sqlite_master UNION ALL"
16086 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
16087 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
16089 callback, &data, &zErrMsg
16091 if( rc==SQLITE_OK ){
16092 sqlite3_stmt *pStmt;
16093 rc = sqlite3_prepare_v2(p->db,
16094 "SELECT rowid FROM sqlite_master"
16095 " WHERE name GLOB 'sqlite_stat[134]'",
16097 doStats = sqlite3_step(pStmt)==SQLITE_ROW;
16098 sqlite3_finalize(pStmt);
16101 raw_printf(p->out, "/* No STAT tables available */\n");
16103 raw_printf(p->out, "ANALYZE sqlite_master;\n");
16104 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
16105 callback, &data, &zErrMsg);
16106 data.cMode = data.mode = MODE_Insert;
16107 data.zDestTable = "sqlite_stat1";
16108 shell_exec(&data, "SELECT * FROM sqlite_stat1", &zErrMsg);
16109 data.zDestTable = "sqlite_stat4";
16110 shell_exec(&data, "SELECT * FROM sqlite_stat4", &zErrMsg);
16111 raw_printf(p->out, "ANALYZE sqlite_master;\n");
16115 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
16117 p->showHeader = booleanValue(azArg[1]);
16119 raw_printf(stderr, "Usage: .headers on|off\n");
16124 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
16126 n = showHelp(p->out, azArg[1]);
16128 utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]);
16131 showHelp(p->out, 0);
16135 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
16136 char *zTable; /* Insert data into this table */
16137 char *zFile; /* Name of file to extra content from */
16138 sqlite3_stmt *pStmt = NULL; /* A statement */
16139 int nCol; /* Number of columns in the table */
16140 int nByte; /* Number of bytes in an SQL string */
16141 int i, j; /* Loop counters */
16142 int needCommit; /* True to COMMIT or ROLLBACK at end */
16143 int nSep; /* Number of bytes in p->colSeparator[] */
16144 char *zSql; /* An SQL statement */
16145 ImportCtx sCtx; /* Reader context */
16146 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
16147 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
16150 raw_printf(stderr, "Usage: .import FILE TABLE\n");
16151 goto meta_command_exit;
16156 memset(&sCtx, 0, sizeof(sCtx));
16158 nSep = strlen30(p->colSeparator);
16161 "Error: non-null column separator required for import\n");
16165 raw_printf(stderr, "Error: multi-character column separators not allowed"
16169 nSep = strlen30(p->rowSeparator);
16171 raw_printf(stderr, "Error: non-null row separator required for import\n");
16174 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
16175 /* When importing CSV (only), if the row separator is set to the
16176 ** default output row separator, change it to the default input
16177 ** row separator. This avoids having to maintain different input
16178 ** and output row separators. */
16179 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16180 nSep = strlen30(p->rowSeparator);
16183 raw_printf(stderr, "Error: multi-character row separators not allowed"
16187 sCtx.zFile = zFile;
16189 if( sCtx.zFile[0]=='|' ){
16190 #ifdef SQLITE_OMIT_POPEN
16191 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
16194 sCtx.in = popen(sCtx.zFile+1, "r");
16195 sCtx.zFile = "<pipe>";
16199 sCtx.in = fopen(sCtx.zFile, "rb");
16202 if( p->mode==MODE_Ascii ){
16203 xRead = ascii_read_one_field;
16205 xRead = csv_read_one_field;
16208 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
16211 sCtx.cColSep = p->colSeparator[0];
16212 sCtx.cRowSep = p->rowSeparator[0];
16213 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
16216 shell_out_of_memory();
16218 nByte = strlen30(zSql);
16219 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16220 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
16221 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
16222 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
16224 while( xRead(&sCtx) ){
16225 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z);
16227 if( sCtx.cTerm!=sCtx.cColSep ) break;
16230 sqlite3_free(zCreate);
16231 sqlite3_free(sCtx.z);
16233 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
16236 zCreate = sqlite3_mprintf("%z\n)", zCreate);
16237 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
16238 sqlite3_free(zCreate);
16240 utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
16241 sqlite3_errmsg(p->db));
16242 sqlite3_free(sCtx.z);
16246 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16248 sqlite3_free(zSql);
16250 if (pStmt) sqlite3_finalize(pStmt);
16251 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
16255 nCol = sqlite3_column_count(pStmt);
16256 sqlite3_finalize(pStmt);
16258 if( nCol==0 ) return 0; /* no columns, no error */
16259 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
16262 shell_out_of_memory();
16264 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
16265 j = strlen30(zSql);
16266 for(i=1; i<nCol; i++){
16272 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16273 sqlite3_free(zSql);
16275 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16276 if (pStmt) sqlite3_finalize(pStmt);
16280 needCommit = sqlite3_get_autocommit(p->db);
16281 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
16283 int startLine = sCtx.nLine;
16284 for(i=0; i<nCol; i++){
16285 char *z = xRead(&sCtx);
16287 ** Did we reach end-of-file before finding any columns?
16288 ** If so, stop instead of NULL filling the remaining columns.
16290 if( z==0 && i==0 ) break;
16292 ** Did we reach end-of-file OR end-of-line before finding any
16293 ** columns in ASCII mode? If so, stop instead of NULL filling
16294 ** the remaining columns.
16296 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
16297 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
16298 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
16299 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
16300 "filling the rest with NULL\n",
16301 sCtx.zFile, startLine, nCol, i+1);
16303 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
16306 if( sCtx.cTerm==sCtx.cColSep ){
16310 }while( sCtx.cTerm==sCtx.cColSep );
16311 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
16312 "extras ignored\n",
16313 sCtx.zFile, startLine, nCol, i);
16316 sqlite3_step(pStmt);
16317 rc = sqlite3_reset(pStmt);
16318 if( rc!=SQLITE_OK ){
16319 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
16320 startLine, sqlite3_errmsg(p->db));
16323 }while( sCtx.cTerm!=EOF );
16326 sqlite3_free(sCtx.z);
16327 sqlite3_finalize(pStmt);
16328 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
16331 #ifndef SQLITE_UNTESTABLE
16332 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){
16334 char *zCollist = 0;
16335 sqlite3_stmt *pStmt;
16337 int isWO = 0; /* True if making an imposter of a WITHOUT ROWID table */
16338 int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */
16340 if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
16341 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n"
16342 " .imposter off\n");
16343 /* Also allowed, but not documented:
16345 ** .imposter TABLE IMPOSTER
16347 ** where TABLE is a WITHOUT ROWID table. In that case, the
16348 ** imposter is another WITHOUT ROWID table with the columns in
16349 ** storage order. */
16351 goto meta_command_exit;
16355 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1);
16356 goto meta_command_exit;
16358 zSql = sqlite3_mprintf(
16359 "SELECT rootpage, 0 FROM sqlite_master"
16360 " WHERE name='%q' AND type='index'"
16362 "SELECT rootpage, 1 FROM sqlite_master"
16363 " WHERE name='%q' AND type='table'"
16364 " AND sql LIKE '%%without%%rowid%%'",
16367 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16368 sqlite3_free(zSql);
16369 if( sqlite3_step(pStmt)==SQLITE_ROW ){
16370 tnum = sqlite3_column_int(pStmt, 0);
16371 isWO = sqlite3_column_int(pStmt, 1);
16373 sqlite3_finalize(pStmt);
16374 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]);
16375 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16376 sqlite3_free(zSql);
16378 while( sqlite3_step(pStmt)==SQLITE_ROW ){
16380 const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
16383 if( sqlite3_column_int(pStmt,1)==-1 ){
16386 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i);
16390 if( isWO && lenPK==0 && sqlite3_column_int(pStmt,5)==0 && zCollist ){
16391 lenPK = (int)strlen(zCollist);
16394 zCollist = sqlite3_mprintf("\"%w\"", zCol);
16396 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
16399 sqlite3_finalize(pStmt);
16400 if( i==0 || tnum==0 ){
16401 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]);
16403 sqlite3_free(zCollist);
16404 goto meta_command_exit;
16406 if( lenPK==0 ) lenPK = 100000;
16407 zSql = sqlite3_mprintf(
16408 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%.*s))WITHOUT ROWID",
16409 azArg[2], zCollist, lenPK, zCollist);
16410 sqlite3_free(zCollist);
16411 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
16412 if( rc==SQLITE_OK ){
16413 rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
16414 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
16416 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
16418 utf8_printf(stdout, "%s;\n", zSql);
16420 "WARNING: writing to an imposter table will corrupt the \"%s\" %s!\n",
16421 azArg[1], isWO ? "table" : "index"
16425 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
16428 sqlite3_free(zSql);
16430 #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
16432 #ifdef SQLITE_ENABLE_IOTRACE
16433 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
16434 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
16435 if( iotrace && iotrace!=stdout ) fclose(iotrace);
16438 sqlite3IoTrace = 0;
16439 }else if( strcmp(azArg[1], "-")==0 ){
16440 sqlite3IoTrace = iotracePrintf;
16443 iotrace = fopen(azArg[1], "w");
16445 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
16446 sqlite3IoTrace = 0;
16449 sqlite3IoTrace = iotracePrintf;
16455 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
16456 static const struct {
16457 const char *zLimitName; /* Name of a limit */
16458 int limitCode; /* Integer code for that limit */
16460 { "length", SQLITE_LIMIT_LENGTH },
16461 { "sql_length", SQLITE_LIMIT_SQL_LENGTH },
16462 { "column", SQLITE_LIMIT_COLUMN },
16463 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH },
16464 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT },
16465 { "vdbe_op", SQLITE_LIMIT_VDBE_OP },
16466 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG },
16467 { "attached", SQLITE_LIMIT_ATTACHED },
16468 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
16469 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER },
16470 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH },
16471 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS },
16476 for(i=0; i<ArraySize(aLimit); i++){
16477 printf("%20s %d\n", aLimit[i].zLimitName,
16478 sqlite3_limit(p->db, aLimit[i].limitCode, -1));
16480 }else if( nArg>3 ){
16481 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
16483 goto meta_command_exit;
16486 n2 = strlen30(azArg[1]);
16487 for(i=0; i<ArraySize(aLimit); i++){
16488 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
16492 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
16494 goto meta_command_exit;
16499 utf8_printf(stderr, "unknown limit: \"%s\"\n"
16500 "enter \".limits\" with no arguments for a list.\n",
16503 goto meta_command_exit;
16506 sqlite3_limit(p->db, aLimit[iLimit].limitCode,
16507 (int)integerValue(azArg[2]));
16509 printf("%20s %d\n", aLimit[iLimit].zLimitName,
16510 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
16514 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){
16516 lintDotCommand(p, azArg, nArg);
16519 #ifndef SQLITE_OMIT_LOAD_EXTENSION
16520 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
16521 const char *zFile, *zProc;
16524 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
16526 goto meta_command_exit;
16529 zProc = nArg>=3 ? azArg[2] : 0;
16531 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
16532 if( rc!=SQLITE_OK ){
16533 utf8_printf(stderr, "Error: %s\n", zErrMsg);
16534 sqlite3_free(zErrMsg);
16540 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
16542 raw_printf(stderr, "Usage: .log FILENAME\n");
16545 const char *zFile = azArg[1];
16546 output_file_close(p->pLog);
16547 p->pLog = output_file_open(zFile, 0);
16551 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
16552 const char *zMode = nArg>=2 ? azArg[1] : "";
16553 int n2 = strlen30(zMode);
16555 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
16556 p->mode = MODE_Line;
16557 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16558 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
16559 p->mode = MODE_Column;
16560 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16561 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
16562 p->mode = MODE_List;
16563 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column);
16564 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16565 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
16566 p->mode = MODE_Html;
16567 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
16568 p->mode = MODE_Tcl;
16569 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
16570 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
16571 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
16572 p->mode = MODE_Csv;
16573 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
16574 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
16575 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
16576 p->mode = MODE_List;
16577 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
16578 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
16579 p->mode = MODE_Insert;
16580 set_table_name(p, nArg>=3 ? azArg[2] : "table");
16581 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){
16582 p->mode = MODE_Quote;
16583 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
16584 p->mode = MODE_Ascii;
16585 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
16586 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
16587 }else if( nArg==1 ){
16588 raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]);
16590 raw_printf(stderr, "Error: mode should be one of: "
16591 "ascii column csv html insert line list quote tabs tcl\n");
16594 p->cMode = p->mode;
16597 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
16599 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
16600 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
16602 raw_printf(stderr, "Usage: .nullvalue STRING\n");
16607 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
16608 char *zNewFilename; /* Name of the database file to open */
16609 int iName = 1; /* Index in azArg[] of the filename */
16610 int newFlag = 0; /* True to delete file before opening */
16611 /* Close the existing database */
16612 session_close_all(p);
16615 p->zDbFilename = 0;
16616 sqlite3_free(p->zFreeOnClose);
16617 p->zFreeOnClose = 0;
16618 p->openMode = SHELL_OPEN_UNSPEC;
16621 /* Check for command-line arguments */
16622 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){
16623 const char *z = azArg[iName];
16624 if( optionMatch(z,"new") ){
16626 #ifdef SQLITE_HAVE_ZLIB
16627 }else if( optionMatch(z, "zip") ){
16628 p->openMode = SHELL_OPEN_ZIPFILE;
16630 }else if( optionMatch(z, "append") ){
16631 p->openMode = SHELL_OPEN_APPENDVFS;
16632 }else if( optionMatch(z, "readonly") ){
16633 p->openMode = SHELL_OPEN_READONLY;
16634 }else if( optionMatch(z, "nofollow") ){
16635 p->openFlags |= SQLITE_OPEN_NOFOLLOW;
16636 #ifdef SQLITE_ENABLE_DESERIALIZE
16637 }else if( optionMatch(z, "deserialize") ){
16638 p->openMode = SHELL_OPEN_DESERIALIZE;
16639 }else if( optionMatch(z, "hexdb") ){
16640 p->openMode = SHELL_OPEN_HEXDB;
16641 }else if( optionMatch(z, "maxsize") && iName+1<nArg ){
16642 p->szMax = integerValue(azArg[++iName]);
16643 #endif /* SQLITE_ENABLE_DESERIALIZE */
16644 }else if( z[0]=='-' ){
16645 utf8_printf(stderr, "unknown option: %s\n", z);
16647 goto meta_command_exit;
16650 /* If a filename is specified, try to open it first */
16651 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0;
16652 if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){
16653 if( newFlag ) shellDeleteFile(zNewFilename);
16654 p->zDbFilename = zNewFilename;
16655 open_db(p, OPEN_DB_KEEPALIVE);
16657 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
16658 sqlite3_free(zNewFilename);
16660 p->zFreeOnClose = zNewFilename;
16664 /* As a fall-back open a TEMP database */
16665 p->zDbFilename = 0;
16671 && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0))
16672 || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0)
16674 const char *zFile = nArg>=2 ? azArg[1] : "stdout";
16676 if( azArg[0][0]=='e' ){
16677 /* Transform the ".excel" command into ".once -x" */
16680 zFile = azArg[1] = "-x";
16684 utf8_printf(stderr, "Usage: .%s [-e|-x|FILE]\n", azArg[0]);
16686 goto meta_command_exit;
16688 if( n>1 && strncmp(azArg[0], "once", n)==0 ){
16690 raw_printf(stderr, "Usage: .once (-e|-x|FILE)\n");
16692 goto meta_command_exit;
16699 if( zFile[0]=='-' && zFile[1]=='-' ) zFile++;
16700 #ifndef SQLITE_NOHAVE_SYSTEM
16701 if( strcmp(zFile, "-e")==0 || strcmp(zFile, "-x")==0 ){
16704 if( zFile[1]=='x' ){
16705 newTempFile(p, "csv");
16706 p->mode = MODE_Csv;
16707 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
16708 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
16710 newTempFile(p, "txt");
16713 zFile = p->zTempFile;
16715 #endif /* SQLITE_NOHAVE_SYSTEM */
16716 if( zFile[0]=='|' ){
16717 #ifdef SQLITE_OMIT_POPEN
16718 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
16722 p->out = popen(zFile + 1, "w");
16724 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
16728 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
16732 p->out = output_file_open(zFile, bTxtMode);
16734 if( strcmp(zFile,"off")!=0 ){
16735 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
16740 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
16745 if( c=='p' && n>=3 && strncmp(azArg[0], "parameter", n)==0 ){
16747 if( nArg<=1 ) goto parameter_syntax_error;
16749 /* .parameter clear
16750 ** Clear all bind parameters by dropping the TEMP table that holds them.
16752 if( nArg==2 && strcmp(azArg[1],"clear")==0 ){
16753 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;",
16758 ** List all bind parameters.
16760 if( nArg==2 && strcmp(azArg[1],"list")==0 ){
16761 sqlite3_stmt *pStmt = 0;
16764 rx = sqlite3_prepare_v2(p->db,
16765 "SELECT max(length(key)) "
16766 "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
16767 if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
16768 len = sqlite3_column_int(pStmt, 0);
16769 if( len>40 ) len = 40;
16771 sqlite3_finalize(pStmt);
16774 rx = sqlite3_prepare_v2(p->db,
16775 "SELECT key, quote(value) "
16776 "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
16777 while( sqlite3_step(pStmt)==SQLITE_ROW ){
16778 utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
16779 sqlite3_column_text(pStmt,1));
16781 sqlite3_finalize(pStmt);
16786 ** Make sure the TEMP table used to hold bind parameters exists.
16787 ** Create it if necessary.
16789 if( nArg==2 && strcmp(azArg[1],"init")==0 ){
16790 bind_table_init(p);
16793 /* .parameter set NAME VALUE
16794 ** Set or reset a bind parameter. NAME should be the full parameter
16795 ** name exactly as it appears in the query. (ex: $abc, @def). The
16796 ** VALUE can be in either SQL literal notation, or if not it will be
16797 ** understood to be a text string.
16799 if( nArg==4 && strcmp(azArg[1],"set")==0 ){
16802 sqlite3_stmt *pStmt;
16803 const char *zKey = azArg[2];
16804 const char *zValue = azArg[3];
16805 bind_table_init(p);
16806 zSql = sqlite3_mprintf(
16807 "REPLACE INTO temp.sqlite_parameters(key,value)"
16808 "VALUES(%Q,%s);", zKey, zValue);
16809 if( zSql==0 ) shell_out_of_memory();
16811 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16812 sqlite3_free(zSql);
16813 if( rx!=SQLITE_OK ){
16814 sqlite3_finalize(pStmt);
16816 zSql = sqlite3_mprintf(
16817 "REPLACE INTO temp.sqlite_parameters(key,value)"
16818 "VALUES(%Q,%Q);", zKey, zValue);
16819 if( zSql==0 ) shell_out_of_memory();
16820 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
16821 sqlite3_free(zSql);
16822 if( rx!=SQLITE_OK ){
16823 utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
16824 sqlite3_finalize(pStmt);
16829 sqlite3_step(pStmt);
16830 sqlite3_finalize(pStmt);
16833 /* .parameter unset NAME
16834 ** Remove the NAME binding from the parameter binding table, if it
16837 if( nArg==3 && strcmp(azArg[1],"unset")==0 ){
16838 char *zSql = sqlite3_mprintf(
16839 "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]);
16840 if( zSql==0 ) shell_out_of_memory();
16841 sqlite3_exec(p->db, zSql, 0, 0, 0);
16842 sqlite3_free(zSql);
16844 /* If no command name matches, show a syntax error */
16845 parameter_syntax_error:
16846 showHelp(p->out, "parameter");
16849 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
16851 for(i=1; i<nArg; i++){
16852 if( i>1 ) raw_printf(p->out, " ");
16853 utf8_printf(p->out, "%s", azArg[i]);
16855 raw_printf(p->out, "\n");
16858 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
16859 if( c=='p' && n>=3 && strncmp(azArg[0], "progress", n)==0 ){
16862 p->flgProgress = 0;
16865 for(i=1; i<nArg; i++){
16866 const char *z = azArg[i];
16869 if( z[0]=='-' ) z++;
16870 if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){
16871 p->flgProgress |= SHELL_PROGRESS_QUIET;
16874 if( strcmp(z,"reset")==0 ){
16875 p->flgProgress |= SHELL_PROGRESS_RESET;
16878 if( strcmp(z,"once")==0 ){
16879 p->flgProgress |= SHELL_PROGRESS_ONCE;
16882 if( strcmp(z,"limit")==0 ){
16884 utf8_printf(stderr, "Error: missing argument on --limit\n");
16886 goto meta_command_exit;
16888 p->mxProgress = (int)integerValue(azArg[++i]);
16892 utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]);
16894 goto meta_command_exit;
16896 nn = (int)integerValue(z);
16900 sqlite3_progress_handler(p->db, nn, progress_handler, p);
16902 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
16904 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
16906 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
16909 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
16913 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
16917 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
16918 FILE *inSaved = p->in;
16919 int savedLineno = p->lineno;
16921 raw_printf(stderr, "Usage: .read FILE\n");
16923 goto meta_command_exit;
16925 p->in = fopen(azArg[1], "rb");
16927 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
16930 rc = process_input(p);
16934 p->lineno = savedLineno;
16937 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
16938 const char *zSrcFile;
16941 sqlite3_backup *pBackup;
16945 zSrcFile = azArg[1];
16947 }else if( nArg==3 ){
16948 zSrcFile = azArg[2];
16951 raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
16953 goto meta_command_exit;
16955 rc = sqlite3_open(zSrcFile, &pSrc);
16956 if( rc!=SQLITE_OK ){
16957 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
16962 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
16964 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16968 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
16969 || rc==SQLITE_BUSY ){
16970 if( rc==SQLITE_BUSY ){
16971 if( nTimeout++ >= 3 ) break;
16972 sqlite3_sleep(100);
16975 sqlite3_backup_finish(pBackup);
16976 if( rc==SQLITE_DONE ){
16978 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
16979 raw_printf(stderr, "Error: source database is busy\n");
16982 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
16988 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
16990 p->scanstatsOn = (u8)booleanValue(azArg[1]);
16991 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
16992 raw_printf(stderr, "Warning: .scanstats not available in this build.\n");
16995 raw_printf(stderr, "Usage: .scanstats on|off\n");
17000 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
17004 const char *zDiv = "(";
17005 const char *zName = 0;
17011 memcpy(&data, p, sizeof(data));
17012 data.showHeader = 0;
17013 data.cMode = data.mode = MODE_Semi;
17014 initText(&sSelect);
17015 for(ii=1; ii<nArg; ii++){
17016 if( optionMatch(azArg[ii],"indent") ){
17017 data.cMode = data.mode = MODE_Pretty;
17018 }else if( optionMatch(azArg[ii],"debug") ){
17020 }else if( zName==0 ){
17023 raw_printf(stderr, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n");
17025 goto meta_command_exit;
17029 int isMaster = sqlite3_strlike(zName, "sqlite_master", '\\')==0;
17030 if( isMaster || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0 ){
17031 char *new_argv[2], *new_colv[2];
17032 new_argv[0] = sqlite3_mprintf(
17033 "CREATE TABLE %s (\n"
17036 " tbl_name text,\n"
17037 " rootpage integer,\n"
17039 ")", isMaster ? "sqlite_master" : "sqlite_temp_master");
17041 new_colv[0] = "sql";
17043 callback(&data, 1, new_argv, new_colv);
17044 sqlite3_free(new_argv[0]);
17048 sqlite3_stmt *pStmt = 0;
17049 rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
17052 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
17053 sqlite3_finalize(pStmt);
17055 goto meta_command_exit;
17057 appendText(&sSelect, "SELECT sql FROM", 0);
17059 while( sqlite3_step(pStmt)==SQLITE_ROW ){
17060 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0);
17062 sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema);
17063 appendText(&sSelect, zDiv, 0);
17064 zDiv = " UNION ALL ";
17065 appendText(&sSelect, "SELECT shell_add_schema(sql,", 0);
17066 if( sqlite3_stricmp(zDb, "main")!=0 ){
17067 appendText(&sSelect, zDb, '\'');
17069 appendText(&sSelect, "NULL", 0);
17071 appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0);
17072 appendText(&sSelect, zScNum, 0);
17073 appendText(&sSelect, " AS snum, ", 0);
17074 appendText(&sSelect, zDb, '\'');
17075 appendText(&sSelect, " AS sname FROM ", 0);
17076 appendText(&sSelect, zDb, quoteChar(zDb));
17077 appendText(&sSelect, ".sqlite_master", 0);
17079 sqlite3_finalize(pStmt);
17080 #ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS
17082 appendText(&sSelect,
17083 " UNION ALL SELECT shell_module_schema(name),"
17084 " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list",
17088 appendText(&sSelect, ") WHERE ", 0);
17090 char *zQarg = sqlite3_mprintf("%Q", zName);
17091 int bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 ||
17092 strchr(zName, '[') != 0;
17093 if( strchr(zName, '.') ){
17094 appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0);
17096 appendText(&sSelect, "lower(tbl_name)", 0);
17098 appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0);
17099 appendText(&sSelect, zQarg, 0);
17101 appendText(&sSelect, " ESCAPE '\\' ", 0);
17103 appendText(&sSelect, " AND ", 0);
17104 sqlite3_free(zQarg);
17106 appendText(&sSelect, "type!='meta' AND sql IS NOT NULL"
17107 " ORDER BY snum, rowid", 0);
17109 utf8_printf(p->out, "SQL: %s;\n", sSelect.z);
17111 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
17113 freeText(&sSelect);
17116 utf8_printf(stderr,"Error: %s\n", zErrMsg);
17117 sqlite3_free(zErrMsg);
17119 }else if( rc != SQLITE_OK ){
17120 raw_printf(stderr,"Error: querying schema information\n");
17127 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
17128 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
17129 sqlite3SelectTrace = (int)integerValue(azArg[1]);
17133 #if defined(SQLITE_ENABLE_SESSION)
17134 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){
17135 OpenSession *pSession = &p->aSession[0];
17136 char **azCmd = &azArg[1];
17138 int nCmd = nArg - 1;
17140 if( nArg<=1 ) goto session_syntax_error;
17143 for(iSes=0; iSes<p->nSession; iSes++){
17144 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break;
17146 if( iSes<p->nSession ){
17147 pSession = &p->aSession[iSes];
17151 pSession = &p->aSession[0];
17156 /* .session attach TABLE
17157 ** Invoke the sqlite3session_attach() interface to attach a particular
17158 ** table so that it is never filtered.
17160 if( strcmp(azCmd[0],"attach")==0 ){
17161 if( nCmd!=2 ) goto session_syntax_error;
17162 if( pSession->p==0 ){
17164 raw_printf(stderr, "ERROR: No sessions are open\n");
17166 rc = sqlite3session_attach(pSession->p, azCmd[1]);
17168 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc);
17174 /* .session changeset FILE
17175 ** .session patchset FILE
17176 ** Write a changeset or patchset into a file. The file is overwritten.
17178 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){
17180 if( nCmd!=2 ) goto session_syntax_error;
17181 if( pSession->p==0 ) goto session_not_open;
17182 out = fopen(azCmd[1], "wb");
17184 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n",
17189 if( azCmd[0][0]=='c' ){
17190 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
17192 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
17195 printf("Error: error code %d\n", rc);
17199 && fwrite(pChng, szChng, 1, out)!=1 ){
17200 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n",
17203 sqlite3_free(pChng);
17209 ** Close the identified session
17211 if( strcmp(azCmd[0], "close")==0 ){
17212 if( nCmd!=1 ) goto session_syntax_error;
17214 session_close(pSession);
17215 p->aSession[iSes] = p->aSession[--p->nSession];
17219 /* .session enable ?BOOLEAN?
17220 ** Query or set the enable flag
17222 if( strcmp(azCmd[0], "enable")==0 ){
17224 if( nCmd>2 ) goto session_syntax_error;
17225 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
17227 ii = sqlite3session_enable(pSession->p, ii);
17228 utf8_printf(p->out, "session %s enable flag = %d\n",
17229 pSession->zName, ii);
17233 /* .session filter GLOB ....
17234 ** Set a list of GLOB patterns of table names to be excluded.
17236 if( strcmp(azCmd[0], "filter")==0 ){
17238 if( nCmd<2 ) goto session_syntax_error;
17240 for(ii=0; ii<pSession->nFilter; ii++){
17241 sqlite3_free(pSession->azFilter[ii]);
17243 sqlite3_free(pSession->azFilter);
17244 nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
17245 pSession->azFilter = sqlite3_malloc( nByte );
17246 if( pSession->azFilter==0 ){
17247 raw_printf(stderr, "Error: out or memory\n");
17250 for(ii=1; ii<nCmd; ii++){
17251 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
17253 pSession->nFilter = ii-1;
17257 /* .session indirect ?BOOLEAN?
17258 ** Query or set the indirect flag
17260 if( strcmp(azCmd[0], "indirect")==0 ){
17262 if( nCmd>2 ) goto session_syntax_error;
17263 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
17265 ii = sqlite3session_indirect(pSession->p, ii);
17266 utf8_printf(p->out, "session %s indirect flag = %d\n",
17267 pSession->zName, ii);
17271 /* .session isempty
17272 ** Determine if the session is empty
17274 if( strcmp(azCmd[0], "isempty")==0 ){
17276 if( nCmd!=1 ) goto session_syntax_error;
17278 ii = sqlite3session_isempty(pSession->p);
17279 utf8_printf(p->out, "session %s isempty flag = %d\n",
17280 pSession->zName, ii);
17285 ** List all currently open sessions
17287 if( strcmp(azCmd[0],"list")==0 ){
17288 for(i=0; i<p->nSession; i++){
17289 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName);
17293 /* .session open DB NAME
17294 ** Open a new session called NAME on the attached database DB.
17295 ** DB is normally "main".
17297 if( strcmp(azCmd[0],"open")==0 ){
17299 if( nCmd!=3 ) goto session_syntax_error;
17301 if( zName[0]==0 ) goto session_syntax_error;
17302 for(i=0; i<p->nSession; i++){
17303 if( strcmp(p->aSession[i].zName,zName)==0 ){
17304 utf8_printf(stderr, "Session \"%s\" already exists\n", zName);
17305 goto meta_command_exit;
17308 if( p->nSession>=ArraySize(p->aSession) ){
17309 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession));
17310 goto meta_command_exit;
17312 pSession = &p->aSession[p->nSession];
17313 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
17315 raw_printf(stderr, "Cannot open session: error code=%d\n", rc);
17317 goto meta_command_exit;
17319 pSession->nFilter = 0;
17320 sqlite3session_table_filter(pSession->p, session_filter, pSession);
17322 pSession->zName = sqlite3_mprintf("%s", zName);
17324 /* If no command name matches, show a syntax error */
17325 session_syntax_error:
17326 showHelp(p->out, "session");
17330 #ifdef SQLITE_DEBUG
17331 /* Undocumented commands for internal testing. Subject to change
17332 ** without notice. */
17333 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
17334 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
17336 for(i=1; i<nArg; i++){
17337 v = booleanValue(azArg[i]);
17338 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
17341 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
17342 int i; sqlite3_int64 v;
17343 for(i=1; i<nArg; i++){
17345 v = integerValue(azArg[i]);
17346 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
17347 utf8_printf(p->out, "%s", zBuf);
17353 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
17354 int bIsInit = 0; /* True to initialize the SELFTEST table */
17355 int bVerbose = 0; /* Verbose output */
17356 int bSelftestExists; /* True if SELFTEST already exists */
17357 int i, k; /* Loop counters */
17358 int nTest = 0; /* Number of tests runs */
17359 int nErr = 0; /* Number of errors seen */
17360 ShellText str; /* Answer for a query */
17361 sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */
17364 for(i=1; i<nArg; i++){
17365 const char *z = azArg[i];
17366 if( z[0]=='-' && z[1]=='-' ) z++;
17367 if( strcmp(z,"-init")==0 ){
17370 if( strcmp(z,"-v")==0 ){
17374 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
17375 azArg[i], azArg[0]);
17376 raw_printf(stderr, "Should be one of: --init -v\n");
17378 goto meta_command_exit;
17381 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
17383 bSelftestExists = 0;
17385 bSelftestExists = 1;
17388 createSelftestTable(p);
17389 bSelftestExists = 1;
17392 appendText(&str, "x", 0);
17393 for(k=bSelftestExists; k>=0; k--){
17395 rc = sqlite3_prepare_v2(p->db,
17396 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
17399 rc = sqlite3_prepare_v2(p->db,
17400 "VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
17401 " (1,'run','PRAGMA integrity_check','ok')",
17405 raw_printf(stderr, "Error querying the selftest table\n");
17407 sqlite3_finalize(pStmt);
17408 goto meta_command_exit;
17410 for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
17411 int tno = sqlite3_column_int(pStmt, 0);
17412 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1);
17413 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2);
17414 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3);
17418 char *zQuote = sqlite3_mprintf("%q", zSql);
17419 printf("%d: %s %s\n", tno, zOp, zSql);
17420 sqlite3_free(zQuote);
17422 if( strcmp(zOp,"memo")==0 ){
17423 utf8_printf(p->out, "%s\n", zSql);
17425 if( strcmp(zOp,"run")==0 ){
17429 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
17432 utf8_printf(p->out, "Result: %s\n", str.z);
17434 if( rc || zErrMsg ){
17437 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
17438 sqlite3_free(zErrMsg);
17439 }else if( strcmp(zAns,str.z)!=0 ){
17442 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
17443 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
17447 utf8_printf(stderr,
17448 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
17452 } /* End loop over rows of content from SELFTEST */
17453 sqlite3_finalize(pStmt);
17454 } /* End loop over k */
17456 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
17459 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
17460 if( nArg<2 || nArg>3 ){
17461 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
17465 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
17466 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
17469 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
17470 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
17474 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
17475 const char *zLike = 0; /* Which table to checksum. 0 means everything */
17476 int i; /* Loop counter */
17477 int bSchema = 0; /* Also hash the schema */
17478 int bSeparate = 0; /* Hash each table separately */
17479 int iSize = 224; /* Hash algorithm to use */
17480 int bDebug = 0; /* Only show the query that would have run */
17481 sqlite3_stmt *pStmt; /* For querying tables names */
17482 char *zSql; /* SQL to be run */
17483 char *zSep; /* Separator */
17484 ShellText sSql; /* Complete SQL for the query to run the hash */
17485 ShellText sQuery; /* Set of queries used to read all content */
17487 for(i=1; i<nArg; i++){
17488 const char *z = azArg[i];
17491 if( z[0]=='-' ) z++;
17492 if( strcmp(z,"schema")==0 ){
17495 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
17496 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
17498 iSize = atoi(&z[5]);
17500 if( strcmp(z,"debug")==0 ){
17504 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
17505 azArg[i], azArg[0]);
17506 showHelp(p->out, azArg[0]);
17508 goto meta_command_exit;
17511 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
17513 goto meta_command_exit;
17517 if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1;
17521 zSql = "SELECT lower(name) FROM sqlite_master"
17522 " WHERE type='table' AND coalesce(rootpage,0)>1"
17523 " UNION ALL SELECT 'sqlite_master'"
17524 " ORDER BY 1 collate nocase";
17526 zSql = "SELECT lower(name) FROM sqlite_master"
17527 " WHERE type='table' AND coalesce(rootpage,0)>1"
17528 " AND name NOT LIKE 'sqlite_%'"
17529 " ORDER BY 1 collate nocase";
17531 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
17534 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
17536 while( SQLITE_ROW==sqlite3_step(pStmt) ){
17537 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
17538 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
17539 if( strncmp(zTab, "sqlite_",7)!=0 ){
17540 appendText(&sQuery,"SELECT * FROM ", 0);
17541 appendText(&sQuery,zTab,'"');
17542 appendText(&sQuery," NOT INDEXED;", 0);
17543 }else if( strcmp(zTab, "sqlite_master")==0 ){
17544 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
17545 " ORDER BY name;", 0);
17546 }else if( strcmp(zTab, "sqlite_sequence")==0 ){
17547 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
17548 " ORDER BY name;", 0);
17549 }else if( strcmp(zTab, "sqlite_stat1")==0 ){
17550 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
17551 " ORDER BY tbl,idx;", 0);
17552 }else if( strcmp(zTab, "sqlite_stat4")==0 ){
17553 appendText(&sQuery, "SELECT * FROM ", 0);
17554 appendText(&sQuery, zTab, 0);
17555 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
17557 appendText(&sSql, zSep, 0);
17558 appendText(&sSql, sQuery.z, '\'');
17560 appendText(&sSql, ",", 0);
17561 appendText(&sSql, zTab, '\'');
17564 sqlite3_finalize(pStmt);
17566 zSql = sqlite3_mprintf(
17568 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
17569 " FROM [sha3sum$query]",
17572 zSql = sqlite3_mprintf(
17574 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
17575 " FROM [sha3sum$query]",
17581 utf8_printf(p->out, "%s\n", zSql);
17583 shell_exec(p, zSql, 0);
17585 sqlite3_free(zSql);
17588 #ifndef SQLITE_NOHAVE_SYSTEM
17590 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
17595 raw_printf(stderr, "Usage: .system COMMAND\n");
17597 goto meta_command_exit;
17599 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
17600 for(i=2; i<nArg; i++){
17601 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
17605 sqlite3_free(zCmd);
17606 if( x ) raw_printf(stderr, "System command returns %d\n", x);
17608 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
17610 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
17611 static const char *azBool[] = { "off", "on", "trigger", "full"};
17614 raw_printf(stderr, "Usage: .show\n");
17616 goto meta_command_exit;
17618 utf8_printf(p->out, "%12.12s: %s\n","echo",
17619 azBool[ShellHasFlag(p, SHFLG_Echo)]);
17620 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
17621 utf8_printf(p->out, "%12.12s: %s\n","explain",
17622 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
17623 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
17624 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
17625 utf8_printf(p->out, "%12.12s: ", "nullvalue");
17626 output_c_string(p->out, p->nullValue);
17627 raw_printf(p->out, "\n");
17628 utf8_printf(p->out,"%12.12s: %s\n","output",
17629 strlen30(p->outfile) ? p->outfile : "stdout");
17630 utf8_printf(p->out,"%12.12s: ", "colseparator");
17631 output_c_string(p->out, p->colSeparator);
17632 raw_printf(p->out, "\n");
17633 utf8_printf(p->out,"%12.12s: ", "rowseparator");
17634 output_c_string(p->out, p->rowSeparator);
17635 raw_printf(p->out, "\n");
17636 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]);
17637 utf8_printf(p->out, "%12.12s: ", "width");
17638 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
17639 raw_printf(p->out, "%d ", p->colWidth[i]);
17641 raw_printf(p->out, "\n");
17642 utf8_printf(p->out, "%12.12s: %s\n", "filename",
17643 p->zDbFilename ? p->zDbFilename : "");
17646 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
17648 p->statsOn = (u8)booleanValue(azArg[1]);
17649 }else if( nArg==1 ){
17650 display_stats(p->db, p, 0);
17652 raw_printf(stderr, "Usage: .stats ?on|off?\n");
17657 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0)
17658 || (c=='i' && (strncmp(azArg[0], "indices", n)==0
17659 || strncmp(azArg[0], "indexes", n)==0) )
17661 sqlite3_stmt *pStmt;
17668 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
17670 sqlite3_finalize(pStmt);
17671 return shellDatabaseError(p->db);
17674 if( nArg>2 && c=='i' ){
17675 /* It is an historical accident that the .indexes command shows an error
17676 ** when called with the wrong number of arguments whereas the .tables
17677 ** command does not. */
17678 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
17680 sqlite3_finalize(pStmt);
17681 goto meta_command_exit;
17683 for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
17684 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
17685 if( zDbName==0 ) continue;
17686 if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0);
17687 if( sqlite3_stricmp(zDbName, "main")==0 ){
17688 appendText(&s, "SELECT name FROM ", 0);
17690 appendText(&s, "SELECT ", 0);
17691 appendText(&s, zDbName, '\'');
17692 appendText(&s, "||'.'||name FROM ", 0);
17694 appendText(&s, zDbName, '"');
17695 appendText(&s, ".sqlite_master ", 0);
17697 appendText(&s," WHERE type IN ('table','view')"
17698 " AND name NOT LIKE 'sqlite_%'"
17699 " AND name LIKE ?1", 0);
17701 appendText(&s," WHERE type='index'"
17702 " AND tbl_name LIKE ?1", 0);
17705 rc = sqlite3_finalize(pStmt);
17706 appendText(&s, " ORDER BY 1", 0);
17707 rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0);
17709 if( rc ) return shellDatabaseError(p->db);
17711 /* Run the SQL statement prepared by the above block. Store the results
17712 ** as an array of nul-terminated strings in azResult[]. */
17716 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
17718 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
17720 while( sqlite3_step(pStmt)==SQLITE_ROW ){
17721 if( nRow>=nAlloc ){
17723 int n2 = nAlloc*2 + 10;
17724 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
17725 if( azNew==0 ) shell_out_of_memory();
17729 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
17730 if( 0==azResult[nRow] ) shell_out_of_memory();
17733 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
17734 rc = shellDatabaseError(p->db);
17737 /* Pretty-print the contents of array azResult[] to the output */
17738 if( rc==0 && nRow>0 ){
17739 int len, maxlen = 0;
17741 int nPrintCol, nPrintRow;
17742 for(i=0; i<nRow; i++){
17743 len = strlen30(azResult[i]);
17744 if( len>maxlen ) maxlen = len;
17746 nPrintCol = 80/(maxlen+2);
17747 if( nPrintCol<1 ) nPrintCol = 1;
17748 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
17749 for(i=0; i<nPrintRow; i++){
17750 for(j=i; j<nRow; j+=nPrintRow){
17751 char *zSp = j<nPrintRow ? "" : " ";
17752 utf8_printf(p->out, "%s%-*s", zSp, maxlen,
17753 azResult[j] ? azResult[j]:"");
17755 raw_printf(p->out, "\n");
17759 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
17760 sqlite3_free(azResult);
17763 /* Begin redirecting output to the file "testcase-out.txt" */
17764 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){
17766 p->out = output_file_open("testcase-out.txt", 0);
17768 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n");
17771 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
17773 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
17777 #ifndef SQLITE_UNTESTABLE
17778 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 ){
17779 static const struct {
17780 const char *zCtrlName; /* Name of a test-control option */
17781 int ctrlCode; /* Integer code for that option */
17782 const char *zUsage; /* Usage notes */
17784 { "always", SQLITE_TESTCTRL_ALWAYS, "BOOLEAN" },
17785 { "assert", SQLITE_TESTCTRL_ASSERT, "BOOLEAN" },
17786 /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, "" },*/
17787 /*{ "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST, "" },*/
17788 { "byteorder", SQLITE_TESTCTRL_BYTEORDER, "" },
17789 { "extra_schema_checks",SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS,"BOOLEAN" },
17790 /*{ "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL, "" },*/
17791 { "imposter", SQLITE_TESTCTRL_IMPOSTER, "SCHEMA ON/OFF ROOTPAGE"},
17792 { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "" },
17793 { "localtime_fault", SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN" },
17794 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN" },
17795 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK" },
17797 { "parser_coverage", SQLITE_TESTCTRL_PARSER_COVERAGE, "" },
17799 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE, "OFFSET " },
17800 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE, "" },
17801 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE, "" },
17802 { "prng_seed", SQLITE_TESTCTRL_PRNG_SEED, "SEED ?db?" },
17803 { "reserve", SQLITE_TESTCTRL_RESERVE, "BYTES-OF-RESERVE"},
17807 int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */
17810 const char *zCmd = 0;
17813 zCmd = nArg>=2 ? azArg[1] : "help";
17815 /* The argument can optionally begin with "-" or "--" */
17816 if( zCmd[0]=='-' && zCmd[1] ){
17818 if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
17821 /* --help lists all test-controls */
17822 if( strcmp(zCmd,"help")==0 ){
17823 utf8_printf(p->out, "Available test-controls:\n");
17824 for(i=0; i<ArraySize(aCtrl); i++){
17825 utf8_printf(p->out, " .testctrl %s %s\n",
17826 aCtrl[i].zCtrlName, aCtrl[i].zUsage);
17829 goto meta_command_exit;
17832 /* convert testctrl text option to value. allow any unique prefix
17833 ** of the option name, or a numerical value. */
17834 n2 = strlen30(zCmd);
17835 for(i=0; i<ArraySize(aCtrl); i++){
17836 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
17838 testctrl = aCtrl[i].ctrlCode;
17841 utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n"
17842 "Use \".testctrl --help\" for help\n", zCmd);
17844 goto meta_command_exit;
17849 utf8_printf(stderr,"Error: unknown test-control: %s\n"
17850 "Use \".testctrl --help\" for help\n", zCmd);
17854 /* sqlite3_test_control(int, db, int) */
17855 case SQLITE_TESTCTRL_OPTIMIZATIONS:
17856 case SQLITE_TESTCTRL_RESERVE:
17858 int opt = (int)strtol(azArg[2], 0, 0);
17859 rc2 = sqlite3_test_control(testctrl, p->db, opt);
17864 /* sqlite3_test_control(int) */
17865 case SQLITE_TESTCTRL_PRNG_SAVE:
17866 case SQLITE_TESTCTRL_PRNG_RESTORE:
17867 case SQLITE_TESTCTRL_PRNG_RESET:
17868 case SQLITE_TESTCTRL_BYTEORDER:
17870 rc2 = sqlite3_test_control(testctrl);
17871 isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3;
17875 /* sqlite3_test_control(int, uint) */
17876 case SQLITE_TESTCTRL_PENDING_BYTE:
17878 unsigned int opt = (unsigned int)integerValue(azArg[2]);
17879 rc2 = sqlite3_test_control(testctrl, opt);
17884 /* sqlite3_test_control(int, int, sqlite3*) */
17885 case SQLITE_TESTCTRL_PRNG_SEED:
17886 if( nArg==3 || nArg==4 ){
17887 int ii = (int)integerValue(azArg[2]);
17889 if( ii==0 && strcmp(azArg[2],"random")==0 ){
17890 sqlite3_randomness(sizeof(ii),&ii);
17891 printf("-- random seed: %d\n", ii);
17897 /* Make sure the schema has been loaded */
17898 sqlite3_table_column_metadata(db, 0, "x", 0, 0, 0, 0, 0, 0);
17900 rc2 = sqlite3_test_control(testctrl, ii, db);
17905 /* sqlite3_test_control(int, int) */
17906 case SQLITE_TESTCTRL_ASSERT:
17907 case SQLITE_TESTCTRL_ALWAYS:
17909 int opt = booleanValue(azArg[2]);
17910 rc2 = sqlite3_test_control(testctrl, opt);
17915 /* sqlite3_test_control(int, int) */
17916 case SQLITE_TESTCTRL_LOCALTIME_FAULT:
17917 case SQLITE_TESTCTRL_NEVER_CORRUPT:
17919 int opt = booleanValue(azArg[2]);
17920 rc2 = sqlite3_test_control(testctrl, opt);
17925 /* sqlite3_test_control(sqlite3*) */
17926 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS:
17927 rc2 = sqlite3_test_control(testctrl, p->db);
17931 case SQLITE_TESTCTRL_IMPOSTER:
17933 rc2 = sqlite3_test_control(testctrl, p->db,
17935 integerValue(azArg[3]),
17936 integerValue(azArg[4]));
17942 case SQLITE_TESTCTRL_PARSER_COVERAGE:
17944 sqlite3_test_control(testctrl, p->out);
17950 if( isOk==0 && iCtrl>=0 ){
17951 utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
17953 }else if( isOk==1 ){
17954 raw_printf(p->out, "%d\n", rc2);
17955 }else if( isOk==2 ){
17956 raw_printf(p->out, "0x%08x\n", rc2);
17959 #endif /* !defined(SQLITE_UNTESTABLE) */
17961 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
17963 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
17966 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
17968 enableTimer = booleanValue(azArg[1]);
17969 if( enableTimer && !HAS_TIMER ){
17970 raw_printf(stderr, "Error: timer not available on this system.\n");
17974 raw_printf(stderr, "Usage: .timer on|off\n");
17979 #ifndef SQLITE_OMIT_TRACE
17980 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
17984 for(jj=1; jj<nArg; jj++){
17985 const char *z = azArg[jj];
17987 if( optionMatch(z, "expanded") ){
17988 p->eTraceType = SHELL_TRACE_EXPANDED;
17990 #ifdef SQLITE_ENABLE_NORMALIZE
17991 else if( optionMatch(z, "normalized") ){
17992 p->eTraceType = SHELL_TRACE_NORMALIZED;
17995 else if( optionMatch(z, "plain") ){
17996 p->eTraceType = SHELL_TRACE_PLAIN;
17998 else if( optionMatch(z, "profile") ){
17999 mType |= SQLITE_TRACE_PROFILE;
18001 else if( optionMatch(z, "row") ){
18002 mType |= SQLITE_TRACE_ROW;
18004 else if( optionMatch(z, "stmt") ){
18005 mType |= SQLITE_TRACE_STMT;
18007 else if( optionMatch(z, "close") ){
18008 mType |= SQLITE_TRACE_CLOSE;
18011 raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z);
18013 goto meta_command_exit;
18016 output_file_close(p->traceOut);
18017 p->traceOut = output_file_open(azArg[1], 0);
18020 if( p->traceOut==0 ){
18021 sqlite3_trace_v2(p->db, 0, 0, 0);
18023 if( mType==0 ) mType = SQLITE_TRACE_STMT;
18024 sqlite3_trace_v2(p->db, mType, sql_trace_callback, p);
18027 #endif /* !defined(SQLITE_OMIT_TRACE) */
18029 #if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_VIRTUALTABLE)
18030 if( c=='u' && strncmp(azArg[0], "unmodule", n)==0 ){
18035 raw_printf(stderr, "Usage: .unmodule [--allexcept] NAME ...\n");
18037 goto meta_command_exit;
18041 if( zOpt[0]=='-' && zOpt[1]=='-' && zOpt[2]!=0 ) zOpt++;
18042 lenOpt = (int)strlen(zOpt);
18043 if( lenOpt>=3 && strncmp(zOpt, "-allexcept",lenOpt)==0 ){
18044 assert( azArg[nArg]==0 );
18045 sqlite3_drop_modules(p->db, nArg>2 ? (const char**)(azArg+2) : 0);
18047 for(ii=1; ii<nArg; ii++){
18048 sqlite3_create_module(p->db, azArg[ii], 0, 0);
18054 #if SQLITE_USER_AUTHENTICATION
18055 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
18057 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
18059 goto meta_command_exit;
18062 if( strcmp(azArg[1],"login")==0 ){
18064 raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
18066 goto meta_command_exit;
18068 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
18069 strlen30(azArg[3]));
18071 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
18074 }else if( strcmp(azArg[1],"add")==0 ){
18076 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
18078 goto meta_command_exit;
18080 rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
18081 booleanValue(azArg[4]));
18083 raw_printf(stderr, "User-Add failed: %d\n", rc);
18086 }else if( strcmp(azArg[1],"edit")==0 ){
18088 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
18090 goto meta_command_exit;
18092 rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
18093 booleanValue(azArg[4]));
18095 raw_printf(stderr, "User-Edit failed: %d\n", rc);
18098 }else if( strcmp(azArg[1],"delete")==0 ){
18100 raw_printf(stderr, "Usage: .user delete USER\n");
18102 goto meta_command_exit;
18104 rc = sqlite3_user_delete(p->db, azArg[2]);
18106 raw_printf(stderr, "User-Delete failed: %d\n", rc);
18110 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n");
18112 goto meta_command_exit;
18115 #endif /* SQLITE_USER_AUTHENTICATION */
18117 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
18118 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
18119 sqlite3_libversion(), sqlite3_sourceid());
18120 #if SQLITE_HAVE_ZLIB
18121 utf8_printf(p->out, "zlib version %s\n", zlibVersion());
18123 #define CTIMEOPT_VAL_(opt) #opt
18124 #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
18125 #if defined(__clang__) && defined(__clang_major__)
18126 utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "."
18127 CTIMEOPT_VAL(__clang_minor__) "."
18128 CTIMEOPT_VAL(__clang_patchlevel__) "\n");
18129 #elif defined(_MSC_VER)
18130 utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) "\n");
18131 #elif defined(__GNUC__) && defined(__VERSION__)
18132 utf8_printf(p->out, "gcc-" __VERSION__ "\n");
18136 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){
18137 const char *zDbName = nArg==2 ? azArg[1] : "main";
18138 sqlite3_vfs *pVfs = 0;
18140 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
18142 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName);
18143 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
18144 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
18145 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
18150 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){
18152 sqlite3_vfs *pCurrent = 0;
18154 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
18156 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
18157 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName,
18158 pVfs==pCurrent ? " <--- CURRENT" : "");
18159 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
18160 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
18161 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
18163 raw_printf(p->out, "-----------------------------------\n");
18168 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
18169 const char *zDbName = nArg==2 ? azArg[1] : "main";
18170 char *zVfsName = 0;
18172 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
18174 utf8_printf(p->out, "%s\n", zVfsName);
18175 sqlite3_free(zVfsName);
18180 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
18181 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
18182 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
18186 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
18188 assert( nArg<=ArraySize(azArg) );
18189 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
18190 p->colWidth[j-1] = (int)integerValue(azArg[j]);
18195 utf8_printf(stderr, "Error: unknown command or invalid arguments: "
18196 " \"%s\". Enter \".help\" for help\n", azArg[0]);
18203 if( p->outCount==0 ) output_reset(p);
18209 ** Return TRUE if a semicolon occurs anywhere in the first N characters
18212 static int line_contains_semicolon(const char *z, int N){
18214 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
18219 ** Test to see if a line consists entirely of whitespace.
18221 static int _all_whitespace(const char *z){
18223 if( IsSpace(z[0]) ) continue;
18224 if( *z=='/' && z[1]=='*' ){
18226 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
18227 if( *z==0 ) return 0;
18231 if( *z=='-' && z[1]=='-' ){
18233 while( *z && *z!='\n' ){ z++; }
18234 if( *z==0 ) return 1;
18243 ** Return TRUE if the line typed in is an SQL command terminator other
18244 ** than a semi-colon. The SQL Server style "go" command is understood
18245 ** as is the Oracle "/".
18247 static int line_is_command_terminator(const char *zLine){
18248 while( IsSpace(zLine[0]) ){ zLine++; };
18249 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
18250 return 1; /* Oracle */
18252 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
18253 && _all_whitespace(&zLine[2]) ){
18254 return 1; /* SQL Server */
18260 ** We need a default sqlite3_complete() implementation to use in case
18261 ** the shell is compiled with SQLITE_OMIT_COMPLETE. The default assumes
18262 ** any arbitrary text is a complete SQL statement. This is not very
18263 ** user-friendly, but it does seem to work.
18265 #ifdef SQLITE_OMIT_COMPLETE
18266 #define sqlite3_complete(x) 1
18270 ** Return true if zSql is a complete SQL statement. Return false if it
18271 ** ends in the middle of a string literal or C-style comment.
18273 static int line_is_complete(char *zSql, int nSql){
18275 if( zSql==0 ) return 1;
18278 rc = sqlite3_complete(zSql);
18284 ** Run a single line of SQL. Return the number of errors.
18286 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
18291 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
18292 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
18294 rc = shell_exec(p, zSql, &zErrMsg);
18296 if( rc || zErrMsg ){
18298 if( in!=0 || !stdin_is_interactive ){
18299 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
18300 "Error: near line %d:", startline);
18302 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
18305 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg);
18306 sqlite3_free(zErrMsg);
18309 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
18312 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
18313 raw_printf(p->out, "changes: %3d total_changes: %d\n",
18314 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
18321 ** Read input from *in and process it. If *in==0 then input
18322 ** is interactive - the user is typing it it. Otherwise, input
18323 ** is coming from a file or device. A prompt is issued and history
18324 ** is saved only if input is interactive. An interrupt signal will
18325 ** cause this routine to exit immediately, unless input is interactive.
18327 ** Return the number of errors.
18329 static int process_input(ShellState *p){
18330 char *zLine = 0; /* A single input line */
18331 char *zSql = 0; /* Accumulated SQL text */
18332 int nLine; /* Length of current line */
18333 int nSql = 0; /* Bytes of zSql[] used */
18334 int nAlloc = 0; /* Allocated zSql[] space */
18335 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
18336 int rc; /* Error code */
18337 int errCnt = 0; /* Number of errors seen */
18338 int startline = 0; /* Line number for start of current input */
18341 while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){
18343 zLine = one_input_line(p->in, zLine, nSql>0);
18346 if( p->in==0 && stdin_is_interactive ) printf("\n");
18349 if( seenInterrupt ){
18350 if( p->in!=0 ) break;
18354 if( nSql==0 && _all_whitespace(zLine) ){
18355 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
18358 if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){
18359 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
18360 if( zLine[0]=='.' ){
18361 rc = do_meta_command(zLine, p);
18362 if( rc==2 ){ /* exit requested */
18370 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
18371 memcpy(zLine,";",2);
18373 nLine = strlen30(zLine);
18374 if( nSql+nLine+2>=nAlloc ){
18375 nAlloc = nSql+nLine+100;
18376 zSql = realloc(zSql, nAlloc);
18377 if( zSql==0 ) shell_out_of_memory();
18382 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
18383 assert( nAlloc>0 && zSql!=0 );
18384 memcpy(zSql, zLine+i, nLine+1-i);
18385 startline = p->lineno;
18388 zSql[nSql++] = '\n';
18389 memcpy(zSql+nSql, zLine, nLine+1);
18392 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
18393 && sqlite3_complete(zSql) ){
18394 errCnt += runOneSqlLine(p, zSql, p->in, startline);
18402 }else if( nSql && _all_whitespace(zSql) ){
18403 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
18407 if( nSql && !_all_whitespace(zSql) ){
18408 errCnt += runOneSqlLine(p, zSql, p->in, startline);
18416 ** Return a pathname which is the user's home directory. A
18417 ** 0 return indicates an error of some kind.
18419 static char *find_home_dir(int clearFlag){
18420 static char *home_dir = NULL;
18426 if( home_dir ) return home_dir;
18428 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
18429 && !defined(__RTP__) && !defined(_WRS_KERNEL)
18431 struct passwd *pwent;
18432 uid_t uid = getuid();
18433 if( (pwent=getpwuid(uid)) != NULL) {
18434 home_dir = pwent->pw_dir;
18439 #if defined(_WIN32_WCE)
18440 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
18445 #if defined(_WIN32) || defined(WIN32)
18447 home_dir = getenv("USERPROFILE");
18452 home_dir = getenv("HOME");
18455 #if defined(_WIN32) || defined(WIN32)
18457 char *zDrive, *zPath;
18459 zDrive = getenv("HOMEDRIVE");
18460 zPath = getenv("HOMEPATH");
18461 if( zDrive && zPath ){
18462 n = strlen30(zDrive) + strlen30(zPath) + 1;
18463 home_dir = malloc( n );
18464 if( home_dir==0 ) return 0;
18465 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
18472 #endif /* !_WIN32_WCE */
18475 int n = strlen30(home_dir) + 1;
18476 char *z = malloc( n );
18477 if( z ) memcpy(z, home_dir, n);
18485 ** Read input from the file given by sqliterc_override. Or if that
18486 ** parameter is NULL, take input from ~/.sqliterc
18488 ** Returns the number of errors.
18490 static void process_sqliterc(
18491 ShellState *p, /* Configuration data */
18492 const char *sqliterc_override /* Name of config file. NULL to use default */
18494 char *home_dir = NULL;
18495 const char *sqliterc = sqliterc_override;
18497 FILE *inSaved = p->in;
18498 int savedLineno = p->lineno;
18500 if (sqliterc == NULL) {
18501 home_dir = find_home_dir(0);
18503 raw_printf(stderr, "-- warning: cannot find home directory;"
18504 " cannot read ~/.sqliterc\n");
18507 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
18510 p->in = fopen(sqliterc,"rb");
18512 if( stdin_is_interactive ){
18513 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
18519 p->lineno = savedLineno;
18520 sqlite3_free(zBuf);
18524 ** Show available command line options
18526 static const char zOptions[] =
18527 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
18528 " -A ARGS... run \".archive ARGS\" and exit\n"
18530 " -append append the database to the end of the file\n"
18531 " -ascii set output mode to 'ascii'\n"
18532 " -bail stop after hitting an error\n"
18533 " -batch force batch I/O\n"
18534 " -column set output mode to 'column'\n"
18535 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
18536 " -csv set output mode to 'csv'\n"
18537 #if defined(SQLITE_ENABLE_DESERIALIZE)
18538 " -deserialize open the database using sqlite3_deserialize()\n"
18540 " -echo print commands before execution\n"
18541 " -init FILENAME read/process named file\n"
18542 " -[no]header turn headers on or off\n"
18543 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
18544 " -heap SIZE Size of heap for memsys3 or memsys5\n"
18546 " -help show this message\n"
18547 " -html set output mode to HTML\n"
18548 " -interactive force interactive I/O\n"
18549 " -line set output mode to 'line'\n"
18550 " -list set output mode to 'list'\n"
18551 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
18552 #if defined(SQLITE_ENABLE_DESERIALIZE)
18553 " -maxsize N maximum size for a --deserialize database\n"
18555 " -memtrace trace all memory allocations and deallocations\n"
18556 " -mmap N default mmap size set to N\n"
18557 #ifdef SQLITE_ENABLE_MULTIPLEX
18558 " -multiplex enable the multiplexor VFS\n"
18560 " -newline SEP set output row separator. Default: '\\n'\n"
18561 " -nofollow refuse to open symbolic links to database files\n"
18562 " -nullvalue TEXT set text string for NULL values. Default ''\n"
18563 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
18564 " -quote set output mode to 'quote'\n"
18565 " -readonly open the database read-only\n"
18566 " -separator SEP set output column separator. Default: '|'\n"
18567 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18568 " -sorterref SIZE sorter references threshold size\n"
18570 " -stats print memory stats before each finalize\n"
18571 " -version show SQLite version\n"
18572 " -vfs NAME use NAME as the default VFS\n"
18573 #ifdef SQLITE_ENABLE_VFSTRACE
18574 " -vfstrace enable tracing of all VFS calls\n"
18576 #ifdef SQLITE_HAVE_ZLIB
18577 " -zip open the file as a ZIP Archive\n"
18580 static void usage(int showDetail){
18581 utf8_printf(stderr,
18582 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
18583 "FILENAME is the name of an SQLite database. A new database is created\n"
18584 "if the file does not previously exist.\n", Argv0);
18586 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
18588 raw_printf(stderr, "Use the -help option for additional information\n");
18594 ** Internal check: Verify that the SQLite is uninitialized. Print a
18595 ** error message if it is initialized.
18597 static void verify_uninitialized(void){
18598 if( sqlite3_config(-1)==SQLITE_MISUSE ){
18599 utf8_printf(stdout, "WARNING: attempt to configure SQLite after"
18600 " initialization.\n");
18605 ** Initialize the state information in data
18607 static void main_init(ShellState *data) {
18608 memset(data, 0, sizeof(*data));
18609 data->normalMode = data->cMode = data->mode = MODE_List;
18610 data->autoExplain = 1;
18611 memcpy(data->colSeparator,SEP_Column, 2);
18612 memcpy(data->rowSeparator,SEP_Row, 2);
18613 data->showHeader = 0;
18614 data->shellFlgs = SHFLG_Lookaside;
18615 verify_uninitialized();
18616 sqlite3_config(SQLITE_CONFIG_URI, 1);
18617 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
18618 sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
18619 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
18620 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
18624 ** Output text to the console in a font that attracts extra attention.
18627 static void printBold(const char *zText){
18628 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
18629 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
18630 GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
18631 SetConsoleTextAttribute(out,
18632 FOREGROUND_RED|FOREGROUND_INTENSITY
18634 printf("%s", zText);
18635 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
18638 static void printBold(const char *zText){
18639 printf("\033[1m%s\033[0m", zText);
18644 ** Get the argument to an --option. Throw an error and die if no argument
18647 static char *cmdline_option_value(int argc, char **argv, int i){
18649 utf8_printf(stderr, "%s: Error: missing argument to %s\n",
18650 argv[0], argv[argc-1]);
18656 #ifndef SQLITE_SHELL_IS_UTF8
18657 # if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
18658 # define SQLITE_SHELL_IS_UTF8 (0)
18660 # define SQLITE_SHELL_IS_UTF8 (1)
18664 #if SQLITE_SHELL_IS_UTF8
18665 int SQLITE_CDECL main(int argc, char **argv){
18667 int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
18672 const char *zInitFile = 0;
18675 int warnInmemoryDb = 0;
18679 const char *zVfs = 0; /* Value of -vfs command-line option */
18680 #if !SQLITE_SHELL_IS_UTF8
18681 char **argvToFree = 0;
18682 int argcToFree = 0;
18685 setBinaryMode(stdin, 0);
18686 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
18687 stdin_is_interactive = isatty(0);
18688 stdout_is_console = isatty(1);
18690 #if !defined(_WIN32_WCE)
18691 if( getenv("SQLITE_DEBUG_BREAK") ){
18692 if( isatty(0) && isatty(2) ){
18694 "attach debugger to process %d and press any key to continue.\n",
18698 #if defined(_WIN32) || defined(WIN32)
18700 #elif defined(SIGTRAP)
18707 #if USE_SYSTEM_SQLITE+0!=1
18708 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
18709 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
18710 sqlite3_sourceid(), SQLITE_SOURCE_ID);
18716 /* On Windows, we must translate command-line arguments into UTF-8.
18717 ** The SQLite memory allocator subsystem has to be enabled in order to
18718 ** do this. But we want to run an sqlite3_shutdown() afterwards so that
18719 ** subsequent sqlite3_config() calls will work. So copy all results into
18720 ** memory that does not come from the SQLite memory allocator.
18722 #if !SQLITE_SHELL_IS_UTF8
18723 sqlite3_initialize();
18724 argvToFree = malloc(sizeof(argv[0])*argc*2);
18726 argv = argvToFree + argc;
18727 if( argv==0 ) shell_out_of_memory();
18728 for(i=0; i<argc; i++){
18729 char *z = sqlite3_win32_unicode_to_utf8(wargv[i]);
18731 if( z==0 ) shell_out_of_memory();
18732 n = (int)strlen(z);
18733 argv[i] = malloc( n+1 );
18734 if( argv[i]==0 ) shell_out_of_memory();
18735 memcpy(argv[i], z, n+1);
18736 argvToFree[i] = argv[i];
18739 sqlite3_shutdown();
18742 assert( argc>=1 && argv && argv[0] );
18745 /* Make sure we have a valid signal handler early, before anything
18749 signal(SIGINT, interrupt_handler);
18750 #elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE)
18751 SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
18754 #ifdef SQLITE_SHELL_DBNAME_PROC
18756 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
18757 ** of a C-function that will provide the name of the database file. Use
18758 ** this compile-time option to embed this shell program in larger
18759 ** applications. */
18760 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
18761 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
18762 warnInmemoryDb = 0;
18766 /* Do an initial pass through the command-line argument to locate
18767 ** the name of the database file, the name of the initialization file,
18768 ** the size of the alternative malloc heap,
18769 ** and the first command to execute.
18771 verify_uninitialized();
18772 for(i=1; i<argc; i++){
18776 if( data.zDbFilename==0 ){
18777 data.zDbFilename = z;
18779 /* Excesss arguments are interpreted as SQL (or dot-commands) and
18780 ** mean that nothing is read from stdin */
18783 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
18784 if( azCmd==0 ) shell_out_of_memory();
18788 if( z[1]=='-' ) z++;
18789 if( strcmp(z,"-separator")==0
18790 || strcmp(z,"-nullvalue")==0
18791 || strcmp(z,"-newline")==0
18792 || strcmp(z,"-cmd")==0
18794 (void)cmdline_option_value(argc, argv, ++i);
18795 }else if( strcmp(z,"-init")==0 ){
18796 zInitFile = cmdline_option_value(argc, argv, ++i);
18797 }else if( strcmp(z,"-batch")==0 ){
18798 /* Need to check for batch mode here to so we can avoid printing
18799 ** informational messages (like from process_sqliterc) before
18800 ** we do the actual processing of arguments later in a second pass.
18802 stdin_is_interactive = 0;
18803 }else if( strcmp(z,"-heap")==0 ){
18804 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
18806 sqlite3_int64 szHeap;
18808 zSize = cmdline_option_value(argc, argv, ++i);
18809 szHeap = integerValue(zSize);
18810 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
18811 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
18813 (void)cmdline_option_value(argc, argv, ++i);
18815 }else if( strcmp(z,"-pagecache")==0 ){
18817 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
18818 if( sz>70000 ) sz = 70000;
18820 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
18821 sqlite3_config(SQLITE_CONFIG_PAGECACHE,
18822 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
18823 data.shellFlgs |= SHFLG_Pagecache;
18824 }else if( strcmp(z,"-lookaside")==0 ){
18826 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
18828 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
18830 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
18831 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
18832 #ifdef SQLITE_ENABLE_VFSTRACE
18833 }else if( strcmp(z,"-vfstrace")==0 ){
18834 extern int vfstrace_register(
18835 const char *zTraceName,
18836 const char *zOldVfsName,
18837 int (*xOut)(const char*,void*),
18841 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
18843 #ifdef SQLITE_ENABLE_MULTIPLEX
18844 }else if( strcmp(z,"-multiplex")==0 ){
18845 extern int sqlite3_multiple_initialize(const char*,int);
18846 sqlite3_multiplex_initialize(0, 1);
18848 }else if( strcmp(z,"-mmap")==0 ){
18849 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
18850 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
18851 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
18852 }else if( strcmp(z,"-sorterref")==0 ){
18853 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
18854 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz);
18856 }else if( strcmp(z,"-vfs")==0 ){
18857 zVfs = cmdline_option_value(argc, argv, ++i);
18858 #ifdef SQLITE_HAVE_ZLIB
18859 }else if( strcmp(z,"-zip")==0 ){
18860 data.openMode = SHELL_OPEN_ZIPFILE;
18862 }else if( strcmp(z,"-append")==0 ){
18863 data.openMode = SHELL_OPEN_APPENDVFS;
18864 #ifdef SQLITE_ENABLE_DESERIALIZE
18865 }else if( strcmp(z,"-deserialize")==0 ){
18866 data.openMode = SHELL_OPEN_DESERIALIZE;
18867 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){
18868 data.szMax = integerValue(argv[++i]);
18870 }else if( strcmp(z,"-readonly")==0 ){
18871 data.openMode = SHELL_OPEN_READONLY;
18872 }else if( strcmp(z,"-nofollow")==0 ){
18873 data.openFlags = SQLITE_OPEN_NOFOLLOW;
18874 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
18875 }else if( strncmp(z, "-A",2)==0 ){
18876 /* All remaining command-line arguments are passed to the ".archive"
18877 ** command, so ignore them */
18880 }else if( strcmp(z, "-memtrace")==0 ){
18881 sqlite3MemTraceActivate(stderr);
18884 verify_uninitialized();
18887 #ifdef SQLITE_SHELL_INIT_PROC
18889 /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name
18890 ** of a C-function that will perform initialization actions on SQLite that
18891 ** occur just before or after sqlite3_initialize(). Use this compile-time
18892 ** option to embed this shell program in larger applications. */
18893 extern void SQLITE_SHELL_INIT_PROC(void);
18894 SQLITE_SHELL_INIT_PROC();
18897 /* All the sqlite3_config() calls have now been made. So it is safe
18898 ** to call sqlite3_initialize() and process any command line -vfs option. */
18899 sqlite3_initialize();
18903 sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
18905 sqlite3_vfs_register(pVfs, 1);
18907 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]);
18912 if( data.zDbFilename==0 ){
18913 #ifndef SQLITE_OMIT_MEMORYDB
18914 data.zDbFilename = ":memory:";
18915 warnInmemoryDb = argc==1;
18917 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
18922 sqlite3_appendvfs_init(0,0,0);
18924 /* Go ahead and open the database file if it already exists. If the
18925 ** file does not exist, delay opening it. This prevents empty database
18926 ** files from being created if a user mistypes the database name argument
18927 ** to the sqlite command-line tool.
18929 if( access(data.zDbFilename, 0)==0 ){
18933 /* Process the initialization file if there is one. If no -init option
18934 ** is given on the command line, look for a file named ~/.sqliterc and
18935 ** try to process it.
18937 process_sqliterc(&data,zInitFile);
18939 /* Make a second pass through the command-line argument and set
18940 ** options. This second pass is delayed until after the initialization
18941 ** file is processed so that the command-line arguments will override
18942 ** settings in the initialization file.
18944 for(i=1; i<argc; i++){
18946 if( z[0]!='-' ) continue;
18947 if( z[1]=='-' ){ z++; }
18948 if( strcmp(z,"-init")==0 ){
18950 }else if( strcmp(z,"-html")==0 ){
18951 data.mode = MODE_Html;
18952 }else if( strcmp(z,"-list")==0 ){
18953 data.mode = MODE_List;
18954 }else if( strcmp(z,"-quote")==0 ){
18955 data.mode = MODE_Quote;
18956 }else if( strcmp(z,"-line")==0 ){
18957 data.mode = MODE_Line;
18958 }else if( strcmp(z,"-column")==0 ){
18959 data.mode = MODE_Column;
18960 }else if( strcmp(z,"-csv")==0 ){
18961 data.mode = MODE_Csv;
18962 memcpy(data.colSeparator,",",2);
18963 #ifdef SQLITE_HAVE_ZLIB
18964 }else if( strcmp(z,"-zip")==0 ){
18965 data.openMode = SHELL_OPEN_ZIPFILE;
18967 }else if( strcmp(z,"-append")==0 ){
18968 data.openMode = SHELL_OPEN_APPENDVFS;
18969 #ifdef SQLITE_ENABLE_DESERIALIZE
18970 }else if( strcmp(z,"-deserialize")==0 ){
18971 data.openMode = SHELL_OPEN_DESERIALIZE;
18972 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){
18973 data.szMax = integerValue(argv[++i]);
18975 }else if( strcmp(z,"-readonly")==0 ){
18976 data.openMode = SHELL_OPEN_READONLY;
18977 }else if( strcmp(z,"-nofollow")==0 ){
18978 data.openFlags |= SQLITE_OPEN_NOFOLLOW;
18979 }else if( strcmp(z,"-ascii")==0 ){
18980 data.mode = MODE_Ascii;
18981 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
18983 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
18985 }else if( strcmp(z,"-separator")==0 ){
18986 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
18987 "%s",cmdline_option_value(argc,argv,++i));
18988 }else if( strcmp(z,"-newline")==0 ){
18989 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
18990 "%s",cmdline_option_value(argc,argv,++i));
18991 }else if( strcmp(z,"-nullvalue")==0 ){
18992 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
18993 "%s",cmdline_option_value(argc,argv,++i));
18994 }else if( strcmp(z,"-header")==0 ){
18995 data.showHeader = 1;
18996 }else if( strcmp(z,"-noheader")==0 ){
18997 data.showHeader = 0;
18998 }else if( strcmp(z,"-echo")==0 ){
18999 ShellSetFlag(&data, SHFLG_Echo);
19000 }else if( strcmp(z,"-eqp")==0 ){
19001 data.autoEQP = AUTOEQP_on;
19002 }else if( strcmp(z,"-eqpfull")==0 ){
19003 data.autoEQP = AUTOEQP_full;
19004 }else if( strcmp(z,"-stats")==0 ){
19006 }else if( strcmp(z,"-scanstats")==0 ){
19007 data.scanstatsOn = 1;
19008 }else if( strcmp(z,"-backslash")==0 ){
19009 /* Undocumented command-line option: -backslash
19010 ** Causes C-style backslash escapes to be evaluated in SQL statements
19011 ** prior to sending the SQL into SQLite. Useful for injecting
19012 ** crazy bytes in the middle of SQL statements for testing and debugging.
19014 ShellSetFlag(&data, SHFLG_Backslash);
19015 }else if( strcmp(z,"-bail")==0 ){
19017 }else if( strcmp(z,"-version")==0 ){
19018 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
19020 }else if( strcmp(z,"-interactive")==0 ){
19021 stdin_is_interactive = 1;
19022 }else if( strcmp(z,"-batch")==0 ){
19023 stdin_is_interactive = 0;
19024 }else if( strcmp(z,"-heap")==0 ){
19026 }else if( strcmp(z,"-pagecache")==0 ){
19028 }else if( strcmp(z,"-lookaside")==0 ){
19030 }else if( strcmp(z,"-mmap")==0 ){
19032 }else if( strcmp(z,"-memtrace")==0 ){
19034 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
19035 }else if( strcmp(z,"-sorterref")==0 ){
19038 }else if( strcmp(z,"-vfs")==0 ){
19040 #ifdef SQLITE_ENABLE_VFSTRACE
19041 }else if( strcmp(z,"-vfstrace")==0 ){
19044 #ifdef SQLITE_ENABLE_MULTIPLEX
19045 }else if( strcmp(z,"-multiplex")==0 ){
19048 }else if( strcmp(z,"-help")==0 ){
19050 }else if( strcmp(z,"-cmd")==0 ){
19051 /* Run commands that follow -cmd first and separately from commands
19052 ** that simply appear on the command-line. This seems goofy. It would
19053 ** be better if all commands ran in the order that they appear. But
19054 ** we retain the goofy behavior for historical compatibility. */
19055 if( i==argc-1 ) break;
19056 z = cmdline_option_value(argc,argv,++i);
19058 rc = do_meta_command(z, &data);
19059 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
19062 rc = shell_exec(&data, z, &zErrMsg);
19064 utf8_printf(stderr,"Error: %s\n", zErrMsg);
19065 if( bail_on_error ) return rc!=0 ? rc : 1;
19067 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
19068 if( bail_on_error ) return rc;
19071 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
19072 }else if( strncmp(z, "-A", 2)==0 ){
19074 utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands"
19075 " with \"%s\"\n", z);
19078 open_db(&data, OPEN_DB_ZIPFILE);
19081 arDotCommand(&data, 1, argv+(i-1), argc-(i-1));
19083 arDotCommand(&data, 1, argv+i, argc-i);
19089 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
19090 raw_printf(stderr,"Use -help for a list of options.\n");
19093 data.cMode = data.mode;
19097 /* Run all arguments that do not begin with '-' as if they were separate
19098 ** command-line inputs, except for the argToSkip argument which contains
19099 ** the database filename.
19101 for(i=0; i<nCmd; i++){
19102 if( azCmd[i][0]=='.' ){
19103 rc = do_meta_command(azCmd[i], &data);
19104 if( rc ) return rc==2 ? 0 : rc;
19107 rc = shell_exec(&data, azCmd[i], &zErrMsg);
19109 utf8_printf(stderr,"Error: %s\n", zErrMsg);
19110 return rc!=0 ? rc : 1;
19112 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
19119 /* Run commands received from standard input
19121 if( stdin_is_interactive ){
19126 "SQLite version %s %.19s\n" /*extra-version-info*/
19127 "Enter \".help\" for usage hints.\n",
19128 sqlite3_libversion(), sqlite3_sourceid()
19130 if( warnInmemoryDb ){
19131 printf("Connected to a ");
19132 printBold("transient in-memory database");
19133 printf(".\nUse \".open FILENAME\" to reopen on a "
19134 "persistent database.\n");
19136 zHistory = getenv("SQLITE_HISTORY");
19138 zHistory = strdup(zHistory);
19139 }else if( (zHome = find_home_dir(0))!=0 ){
19140 nHistory = strlen30(zHome) + 20;
19141 if( (zHistory = malloc(nHistory))!=0 ){
19142 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
19145 if( zHistory ){ shell_read_history(zHistory); }
19146 #if HAVE_READLINE || HAVE_EDITLINE
19147 rl_attempted_completion_function = readline_completion;
19148 #elif HAVE_LINENOISE
19149 linenoiseSetCompletionCallback(linenoise_completion);
19152 rc = process_input(&data);
19154 shell_stifle_history(2000);
19155 shell_write_history(zHistory);
19160 rc = process_input(&data);
19163 set_table_name(&data, 0);
19165 session_close_all(&data);
19168 sqlite3_free(data.zFreeOnClose);
19170 output_reset(&data);
19171 data.doXdgOpen = 0;
19172 clearTempFile(&data);
19173 #if !SQLITE_SHELL_IS_UTF8
19174 for(i=0; i<argcToFree; i++) free(argvToFree[i]);
19177 /* Clear the global data structure so that valgrind will detect memory
19179 memset(&data, 0, sizeof(data));