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 #if SQLITE_USER_AUTHENTICATION
83 # include "sqlite3userauth.h"
88 #if !defined(_WIN32) && !defined(WIN32)
90 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
94 # include <sys/types.h>
98 # include <readline/readline.h>
99 # include <readline/history.h>
103 # include <editline/readline.h>
106 #if HAVE_EDITLINE || HAVE_READLINE
108 # define shell_add_history(X) add_history(X)
109 # define shell_read_history(X) read_history(X)
110 # define shell_write_history(X) write_history(X)
111 # define shell_stifle_history(X) stifle_history(X)
112 # define shell_readline(X) readline(X)
116 # include "linenoise.h"
117 # define shell_add_history(X) linenoiseHistoryAdd(X)
118 # define shell_read_history(X) linenoiseHistoryLoad(X)
119 # define shell_write_history(X) linenoiseHistorySave(X)
120 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
121 # define shell_readline(X) linenoise(X)
125 # define shell_read_history(X)
126 # define shell_write_history(X)
127 # define shell_stifle_history(X)
129 # define SHELL_USE_LOCAL_GETLINE 1
133 #if defined(_WIN32) || defined(WIN32)
136 # define isatty(h) _isatty(h)
138 # define access(f,m) _access((f),(m))
141 # define popen _popen
143 # define pclose _pclose
145 /* Make sure isatty() has a prototype. */
146 extern int isatty(int);
148 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
149 /* popen and pclose are not C89 functions and so are
150 ** sometimes omitted from the <stdio.h> header */
151 extern FILE *popen(const char*,const char*);
152 extern int pclose(FILE*);
154 # define SQLITE_OMIT_POPEN 1
158 #if defined(_WIN32_WCE)
159 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
160 * thus we always assume that we have a console. That can be
161 * overridden with the -batch command line option.
166 /* ctype macros that work with signed characters */
167 #define IsSpace(X) isspace((unsigned char)X)
168 #define IsDigit(X) isdigit((unsigned char)X)
169 #define ToLower(X) (char)tolower((unsigned char)X)
171 #if defined(_WIN32) || defined(WIN32)
174 /* string conversion routines only needed on Win32 */
175 extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
176 extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int);
177 extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int);
178 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);
181 /* On Windows, we normally run with output mode of TEXT so that \n characters
182 ** are automatically translated into \r\n. However, this behavior needs
183 ** to be disabled in some cases (ex: when generating CSV output and when
184 ** rendering quoted strings that contain \n characters). The following
185 ** routines take care of that.
187 #if defined(_WIN32) || defined(WIN32)
188 static void setBinaryMode(FILE *file, int isOutput){
189 if( isOutput ) fflush(file);
190 _setmode(_fileno(file), _O_BINARY);
192 static void setTextMode(FILE *file, int isOutput){
193 if( isOutput ) fflush(file);
194 _setmode(_fileno(file), _O_TEXT);
197 # define setBinaryMode(X,Y)
198 # define setTextMode(X,Y)
202 /* True if the timer is enabled */
203 static int enableTimer = 0;
205 /* Return the current wall-clock time */
206 static sqlite3_int64 timeOfDay(void){
207 static sqlite3_vfs *clockVfs = 0;
209 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
210 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
211 clockVfs->xCurrentTimeInt64(clockVfs, &t);
214 clockVfs->xCurrentTime(clockVfs, &r);
215 t = (sqlite3_int64)(r*86400000.0);
220 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
221 #include <sys/time.h>
222 #include <sys/resource.h>
224 /* VxWorks does not support getrusage() as far as we can determine */
225 #if defined(_WRS_KERNEL) || defined(__RTP__)
227 struct timeval ru_utime; /* user CPU time used */
228 struct timeval ru_stime; /* system CPU time used */
230 #define getrusage(A,B) memset(B,0,sizeof(*B))
233 /* Saved resource information for the beginning of an operation */
234 static struct rusage sBegin; /* CPU time at start */
235 static sqlite3_int64 iBegin; /* Wall-clock time at start */
238 ** Begin timing an operation
240 static void beginTimer(void){
242 getrusage(RUSAGE_SELF, &sBegin);
243 iBegin = timeOfDay();
247 /* Return the difference of two time_structs in seconds */
248 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
249 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
250 (double)(pEnd->tv_sec - pStart->tv_sec);
254 ** Print the timing results.
256 static void endTimer(void){
258 sqlite3_int64 iEnd = timeOfDay();
260 getrusage(RUSAGE_SELF, &sEnd);
261 printf("Run Time: real %.3f user %f sys %f\n",
262 (iEnd - iBegin)*0.001,
263 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
264 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
268 #define BEGIN_TIMER beginTimer()
269 #define END_TIMER endTimer()
272 #elif (defined(_WIN32) || defined(WIN32))
274 /* Saved resource information for the beginning of an operation */
275 static HANDLE hProcess;
276 static FILETIME ftKernelBegin;
277 static FILETIME ftUserBegin;
278 static sqlite3_int64 ftWallBegin;
279 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
280 LPFILETIME, LPFILETIME);
281 static GETPROCTIMES getProcessTimesAddr = NULL;
284 ** Check to see if we have timer support. Return 1 if necessary
285 ** support found (or found previously).
287 static int hasTimer(void){
288 if( getProcessTimesAddr ){
291 /* GetProcessTimes() isn't supported in WIN95 and some other Windows
292 ** versions. See if the version we are running on has it, and if it
293 ** does, save off a pointer to it and the current process handle.
295 hProcess = GetCurrentProcess();
297 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
298 if( NULL != hinstLib ){
299 getProcessTimesAddr =
300 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
301 if( NULL != getProcessTimesAddr ){
304 FreeLibrary(hinstLib);
312 ** Begin timing an operation
314 static void beginTimer(void){
315 if( enableTimer && getProcessTimesAddr ){
316 FILETIME ftCreation, ftExit;
317 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
318 &ftKernelBegin,&ftUserBegin);
319 ftWallBegin = timeOfDay();
323 /* Return the difference of two FILETIME structs in seconds */
324 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
325 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
326 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
327 return (double) ((i64End - i64Start) / 10000000.0);
331 ** Print the timing results.
333 static void endTimer(void){
334 if( enableTimer && getProcessTimesAddr){
335 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
336 sqlite3_int64 ftWallEnd = timeOfDay();
337 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
338 printf("Run Time: real %.3f user %f sys %f\n",
339 (ftWallEnd - ftWallBegin)*0.001,
340 timeDiff(&ftUserBegin, &ftUserEnd),
341 timeDiff(&ftKernelBegin, &ftKernelEnd));
345 #define BEGIN_TIMER beginTimer()
346 #define END_TIMER endTimer()
347 #define HAS_TIMER hasTimer()
356 ** Used to prevent warnings about unused parameters
358 #define UNUSED_PARAMETER(x) (void)(x)
361 ** If the following flag is set, then command execution stops
362 ** at an error if we are not interactive.
364 static int bail_on_error = 0;
367 ** Threat stdin as an interactive input if the following variable
368 ** is true. Otherwise, assume stdin is connected to a file or pipe.
370 static int stdin_is_interactive = 1;
373 ** On Windows systems we have to know if standard output is a console
374 ** in order to translate UTF-8 into MBCS. The following variable is
375 ** true if translation is required.
377 static int stdout_is_console = 1;
380 ** The following is the open SQLite database. We make a pointer
381 ** to this database a static variable so that it can be accessed
382 ** by the SIGINT handler to interrupt database processing.
384 static sqlite3 *globalDb = 0;
387 ** True if an interrupt (Control-C) has been received.
389 static volatile int seenInterrupt = 0;
392 ** This is the name of our program. It is set in main(), used
393 ** in a number of other places, mostly for error messages.
398 ** Prompt strings. Initialized in main. Settable with
399 ** .prompt main continue
401 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
402 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
405 ** Render output like fprintf(). Except, if the output is going to the
406 ** console and if this is running on a Windows machine, translate the
407 ** output from UTF-8 into MBCS.
409 #if defined(_WIN32) || defined(WIN32)
410 void utf8_printf(FILE *out, const char *zFormat, ...){
412 va_start(ap, zFormat);
413 if( stdout_is_console && (out==stdout || out==stderr) ){
414 char *z1 = sqlite3_vmprintf(zFormat, ap);
415 char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0);
420 vfprintf(out, zFormat, ap);
424 #elif !defined(utf8_printf)
425 # define utf8_printf fprintf
429 ** Render output like fprintf(). This should not be used on anything that
430 ** includes string formatting (e.g. "%s").
432 #if !defined(raw_printf)
433 # define raw_printf fprintf
437 ** Write I/O traces to the following stream.
439 #ifdef SQLITE_ENABLE_IOTRACE
440 static FILE *iotrace = 0;
444 ** This routine works like printf in that its first argument is a
445 ** format string and subsequent arguments are values to be substituted
446 ** in place of % fields. The result of formatting this string
447 ** is written to iotrace.
449 #ifdef SQLITE_ENABLE_IOTRACE
450 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
453 if( iotrace==0 ) return;
454 va_start(ap, zFormat);
455 z = sqlite3_vmprintf(zFormat, ap);
457 utf8_printf(iotrace, "%s", z);
463 ** Output string zUtf to stream pOut as w characters. If w is negative,
464 ** then right-justify the text. W is the width in UTF-8 characters, not
465 ** in bytes. This is different from the %*.*s specification in printf
466 ** since with %*.*s the width is measured in bytes, not characters.
468 static void utf8_width_print(FILE *pOut, int w, const char *zUtf){
471 int aw = w<0 ? -w : w;
473 if( aw>(int)sizeof(zBuf)/3 ) aw = (int)sizeof(zBuf)/3;
474 for(i=n=0; zUtf[i]; i++){
475 if( (zUtf[i]&0xc0)!=0x80 ){
478 do{ i++; }while( (zUtf[i]&0xc0)==0x80 );
484 utf8_printf(pOut, "%.*s", i, zUtf);
486 utf8_printf(pOut, "%*s%s", aw-n, "", zUtf);
488 utf8_printf(pOut, "%s%*s", zUtf, aw-n, "");
494 ** Determines if a string is a number of not.
496 static int isNumber(const char *z, int *realnum){
497 if( *z=='-' || *z=='+' ) z++;
502 if( realnum ) *realnum = 0;
503 while( IsDigit(*z) ){ z++; }
506 if( !IsDigit(*z) ) return 0;
507 while( IsDigit(*z) ){ z++; }
508 if( realnum ) *realnum = 1;
510 if( *z=='e' || *z=='E' ){
512 if( *z=='+' || *z=='-' ) z++;
513 if( !IsDigit(*z) ) return 0;
514 while( IsDigit(*z) ){ z++; }
515 if( realnum ) *realnum = 1;
521 ** Compute a string length that is limited to what can be stored in
522 ** lower 30 bits of a 32-bit signed integer.
524 static int strlen30(const char *z){
526 while( *z2 ){ z2++; }
527 return 0x3fffffff & (int)(z2 - z);
531 ** Return the length of a string in characters. Multibyte UTF8 characters
532 ** count as a single character.
534 static int strlenChar(const char *z){
537 if( (0xc0&*(z++))!=0x80 ) n++;
543 ** This routine reads a line of text from FILE in, stores
544 ** the text in memory obtained from malloc() and returns a pointer
545 ** to the text. NULL is returned at end of file, or if malloc()
548 ** If zLine is not NULL then it is a malloced buffer returned from
549 ** a previous call to this routine that may be reused.
551 static char *local_getline(char *zLine, FILE *in){
552 int nLine = zLine==0 ? 0 : 100;
557 nLine = nLine*2 + 100;
558 zLine = realloc(zLine, nLine);
559 if( zLine==0 ) return 0;
561 if( fgets(&zLine[n], nLine - n, in)==0 ){
569 while( zLine[n] ) n++;
570 if( n>0 && zLine[n-1]=='\n' ){
572 if( n>0 && zLine[n-1]=='\r' ) n--;
577 #if defined(_WIN32) || defined(WIN32)
578 /* For interactive input on Windows systems, translate the
579 ** multi-byte characterset characters into UTF-8. */
580 if( stdin_is_interactive && in==stdin ){
581 char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0);
583 int nTrans = strlen30(zTrans)+1;
585 zLine = realloc(zLine, nTrans);
587 sqlite3_free(zTrans);
591 memcpy(zLine, zTrans, nTrans);
592 sqlite3_free(zTrans);
595 #endif /* defined(_WIN32) || defined(WIN32) */
600 ** Retrieve a single line of input text.
602 ** If in==0 then read from standard input and prompt before each line.
603 ** If isContinuation is true, then a continuation prompt is appropriate.
604 ** If isContinuation is zero, then the main prompt should be used.
606 ** If zPrior is not NULL then it is a buffer from a prior call to this
607 ** routine that can be reused.
609 ** The result is stored in space obtained from malloc() and must either
610 ** be freed by the caller or else passed back into this routine via the
611 ** zPrior argument for reuse.
613 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
617 zResult = local_getline(zPrior, in);
619 zPrompt = isContinuation ? continuePrompt : mainPrompt;
620 #if SHELL_USE_LOCAL_GETLINE
621 printf("%s", zPrompt);
623 zResult = local_getline(zPrior, stdin);
626 zResult = shell_readline(zPrompt);
627 if( zResult && *zResult ) shell_add_history(zResult);
633 ** A variable length string to which one can append text.
635 typedef struct ShellText ShellText;
643 ** Initialize and destroy a ShellText object
645 static void initText(ShellText *p){
646 memset(p, 0, sizeof(*p));
648 static void freeText(ShellText *p){
653 /* zIn is either a pointer to a NULL-terminated string in memory obtained
654 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
655 ** added to zIn, and the result returned in memory obtained from malloc().
656 ** zIn, if it was not NULL, is freed.
658 ** If the third argument, quote, is not '\0', then it is used as a
659 ** quote character for zAppend.
661 static void appendText(ShellText *p, char const *zAppend, char quote){
664 int nAppend = strlen30(zAppend);
666 len = nAppend+p->n+1;
669 for(i=0; i<nAppend; i++){
670 if( zAppend[i]==quote ) len++;
674 if( p->n+len>=p->nAlloc ){
675 p->nAlloc = p->nAlloc*2 + len + 20;
676 p->z = realloc(p->z, p->nAlloc);
678 memset(p, 0, sizeof(*p));
684 char *zCsr = p->z+p->n;
686 for(i=0; i<nAppend; i++){
687 *zCsr++ = zAppend[i];
688 if( zAppend[i]==quote ) *zCsr++ = quote;
691 p->n = (int)(zCsr - p->z);
694 memcpy(p->z+p->n, zAppend, nAppend);
701 ** Attempt to determine if identifier zName needs to be quoted, either
702 ** because it contains non-alphanumeric characters, or because it is an
703 ** SQLite keyword. Be conservative in this estimate: When in doubt assume
704 ** that quoting is required.
706 ** Return '"' if quoting is required. Return 0 if no quoting is required.
708 static char quoteChar(const char *zName){
709 /* All SQLite keywords, in alphabetical order */
710 static const char *azKeywords[] = {
711 "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
712 "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
713 "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
714 "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
715 "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
716 "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
717 "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
718 "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
719 "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
720 "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
721 "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
722 "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
723 "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
724 "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
725 "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
726 "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
727 "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
730 int i, lwr, upr, mid, c;
731 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
732 for(i=0; zName[i]; i++){
733 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
736 upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
739 c = sqlite3_stricmp(azKeywords[mid], zName);
740 if( c==0 ) return '"';
751 ** SQL function: shell_add_schema(S,X)
753 ** Add the schema name X to the CREATE statement in S and return the result.
756 ** CREATE TABLE t1(x) -> CREATE TABLE xyz.t1(x);
761 ** CREATE UNIQUE INDEX
764 ** CREATE VIRTUAL TABLE
766 ** This UDF is used by the .schema command to insert the schema name of
767 ** attached databases into the middle of the sqlite_master.sql field.
769 static void shellAddSchemaName(
770 sqlite3_context *pCtx,
772 sqlite3_value **apVal
774 static const char *aPrefix[] = {
783 const char *zIn = (const char*)sqlite3_value_text(apVal[0]);
784 const char *zSchema = (const char*)sqlite3_value_text(apVal[1]);
786 if( zIn!=0 && strncmp(zIn, "CREATE ", 7)==0 ){
787 for(i=0; i<(int)(sizeof(aPrefix)/sizeof(aPrefix[0])); i++){
788 int n = strlen30(aPrefix[i]);
789 if( strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){
790 char cQuote = quoteChar(zSchema);
793 z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8);
795 z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8);
797 sqlite3_result_text(pCtx, z, -1, sqlite3_free);
802 sqlite3_result_value(pCtx, apVal[0]);
806 ** The source code for several run-time loadable extensions is inserted
807 ** below by the ../tool/mkshellc.tcl script. Before processing that included
808 ** code, we need to override some macros to make the included program code
809 ** work here in the middle of this regular program.
811 #define SQLITE_EXTENSION_INIT1
812 #define SQLITE_EXTENSION_INIT2(X) (void)(X)
814 /************************* Begin ../ext/misc/shathree.c ******************/
818 ** The author disclaims copyright to this source code. In place of
819 ** a legal notice, here is a blessing:
821 ** May you do good and not evil.
822 ** May you find forgiveness for yourself and forgive others.
823 ** May you share freely, never taking more than you give.
825 ******************************************************************************
827 ** This SQLite extension implements a functions that compute SHA1 hashes.
828 ** Two SQL functions are implemented:
831 ** sha3_query(Y,SIZE)
833 ** The sha3(X) function computes the SHA3 hash of the input X, or NULL if
836 ** The sha3_query(Y) function evalutes all queries in the SQL statements of Y
837 ** and returns a hash of their results.
839 ** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm
840 ** is used. If SIZE is included it must be one of the integers 224, 256,
841 ** 384, or 512, to determine SHA3 hash variant that is computed.
843 SQLITE_EXTENSION_INIT1
847 typedef sqlite3_uint64 u64;
849 /******************************************************************************
853 ** Macros to determine whether the machine is big or little endian,
854 ** and whether or not that determination is run-time or compile-time.
856 ** For best performance, an attempt is made to guess at the byte-order
857 ** using C-preprocessor macros. If that is unsuccessful, or if
858 ** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
861 #ifndef SHA3_BYTEORDER
862 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
863 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
864 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
866 # define SHA3_BYTEORDER 1234
867 # elif defined(sparc) || defined(__ppc__)
868 # define SHA3_BYTEORDER 4321
870 # define SHA3_BYTEORDER 0
876 ** State structure for a SHA3 hash in progress
878 typedef struct SHA3Context SHA3Context;
881 u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
882 unsigned char x[1600]; /* ... or 1600 bytes */
884 unsigned nRate; /* Bytes of input accepted per Keccak iteration */
885 unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
886 unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
890 ** A single step of the Keccak mixing function for a 1600-bit state
892 static void KeccakF1600Step(SHA3Context *p){
894 u64 B0, B1, B2, B3, B4;
895 u64 C0, C1, C2, C3, C4;
896 u64 D0, D1, D2, D3, D4;
897 static const u64 RC[] = {
898 0x0000000000000001ULL, 0x0000000000008082ULL,
899 0x800000000000808aULL, 0x8000000080008000ULL,
900 0x000000000000808bULL, 0x0000000080000001ULL,
901 0x8000000080008081ULL, 0x8000000000008009ULL,
902 0x000000000000008aULL, 0x0000000000000088ULL,
903 0x0000000080008009ULL, 0x000000008000000aULL,
904 0x000000008000808bULL, 0x800000000000008bULL,
905 0x8000000000008089ULL, 0x8000000000008003ULL,
906 0x8000000000008002ULL, 0x8000000000000080ULL,
907 0x000000000000800aULL, 0x800000008000000aULL,
908 0x8000000080008081ULL, 0x8000000000008080ULL,
909 0x0000000080000001ULL, 0x8000000080008008ULL
911 # define A00 (p->u.s[0])
912 # define A01 (p->u.s[1])
913 # define A02 (p->u.s[2])
914 # define A03 (p->u.s[3])
915 # define A04 (p->u.s[4])
916 # define A10 (p->u.s[5])
917 # define A11 (p->u.s[6])
918 # define A12 (p->u.s[7])
919 # define A13 (p->u.s[8])
920 # define A14 (p->u.s[9])
921 # define A20 (p->u.s[10])
922 # define A21 (p->u.s[11])
923 # define A22 (p->u.s[12])
924 # define A23 (p->u.s[13])
925 # define A24 (p->u.s[14])
926 # define A30 (p->u.s[15])
927 # define A31 (p->u.s[16])
928 # define A32 (p->u.s[17])
929 # define A33 (p->u.s[18])
930 # define A34 (p->u.s[19])
931 # define A40 (p->u.s[20])
932 # define A41 (p->u.s[21])
933 # define A42 (p->u.s[22])
934 # define A43 (p->u.s[23])
935 # define A44 (p->u.s[24])
936 # define ROL64(a,x) ((a<<x)|(a>>(64-x)))
938 for(i=0; i<24; i+=4){
939 C0 = A00^A10^A20^A30^A40;
940 C1 = A01^A11^A21^A31^A41;
941 C2 = A02^A12^A22^A32^A42;
942 C3 = A03^A13^A23^A33^A43;
943 C4 = A04^A14^A24^A34^A44;
944 D0 = C4^ROL64(C1, 1);
945 D1 = C0^ROL64(C2, 1);
946 D2 = C1^ROL64(C3, 1);
947 D3 = C2^ROL64(C4, 1);
948 D4 = C3^ROL64(C0, 1);
951 B1 = ROL64((A11^D1), 44);
952 B2 = ROL64((A22^D2), 43);
953 B3 = ROL64((A33^D3), 21);
954 B4 = ROL64((A44^D4), 14);
955 A00 = B0 ^((~B1)& B2 );
957 A11 = B1 ^((~B2)& B3 );
958 A22 = B2 ^((~B3)& B4 );
959 A33 = B3 ^((~B4)& B0 );
960 A44 = B4 ^((~B0)& B1 );
962 B2 = ROL64((A20^D0), 3);
963 B3 = ROL64((A31^D1), 45);
964 B4 = ROL64((A42^D2), 61);
965 B0 = ROL64((A03^D3), 28);
966 B1 = ROL64((A14^D4), 20);
967 A20 = B0 ^((~B1)& B2 );
968 A31 = B1 ^((~B2)& B3 );
969 A42 = B2 ^((~B3)& B4 );
970 A03 = B3 ^((~B4)& B0 );
971 A14 = B4 ^((~B0)& B1 );
973 B4 = ROL64((A40^D0), 18);
974 B0 = ROL64((A01^D1), 1);
975 B1 = ROL64((A12^D2), 6);
976 B2 = ROL64((A23^D3), 25);
977 B3 = ROL64((A34^D4), 8);
978 A40 = B0 ^((~B1)& B2 );
979 A01 = B1 ^((~B2)& B3 );
980 A12 = B2 ^((~B3)& B4 );
981 A23 = B3 ^((~B4)& B0 );
982 A34 = B4 ^((~B0)& B1 );
984 B1 = ROL64((A10^D0), 36);
985 B2 = ROL64((A21^D1), 10);
986 B3 = ROL64((A32^D2), 15);
987 B4 = ROL64((A43^D3), 56);
988 B0 = ROL64((A04^D4), 27);
989 A10 = B0 ^((~B1)& B2 );
990 A21 = B1 ^((~B2)& B3 );
991 A32 = B2 ^((~B3)& B4 );
992 A43 = B3 ^((~B4)& B0 );
993 A04 = B4 ^((~B0)& B1 );
995 B3 = ROL64((A30^D0), 41);
996 B4 = ROL64((A41^D1), 2);
997 B0 = ROL64((A02^D2), 62);
998 B1 = ROL64((A13^D3), 55);
999 B2 = ROL64((A24^D4), 39);
1000 A30 = B0 ^((~B1)& B2 );
1001 A41 = B1 ^((~B2)& B3 );
1002 A02 = B2 ^((~B3)& B4 );
1003 A13 = B3 ^((~B4)& B0 );
1004 A24 = B4 ^((~B0)& B1 );
1006 C0 = A00^A20^A40^A10^A30;
1007 C1 = A11^A31^A01^A21^A41;
1008 C2 = A22^A42^A12^A32^A02;
1009 C3 = A33^A03^A23^A43^A13;
1010 C4 = A44^A14^A34^A04^A24;
1011 D0 = C4^ROL64(C1, 1);
1012 D1 = C0^ROL64(C2, 1);
1013 D2 = C1^ROL64(C3, 1);
1014 D3 = C2^ROL64(C4, 1);
1015 D4 = C3^ROL64(C0, 1);
1018 B1 = ROL64((A31^D1), 44);
1019 B2 = ROL64((A12^D2), 43);
1020 B3 = ROL64((A43^D3), 21);
1021 B4 = ROL64((A24^D4), 14);
1022 A00 = B0 ^((~B1)& B2 );
1024 A31 = B1 ^((~B2)& B3 );
1025 A12 = B2 ^((~B3)& B4 );
1026 A43 = B3 ^((~B4)& B0 );
1027 A24 = B4 ^((~B0)& B1 );
1029 B2 = ROL64((A40^D0), 3);
1030 B3 = ROL64((A21^D1), 45);
1031 B4 = ROL64((A02^D2), 61);
1032 B0 = ROL64((A33^D3), 28);
1033 B1 = ROL64((A14^D4), 20);
1034 A40 = B0 ^((~B1)& B2 );
1035 A21 = B1 ^((~B2)& B3 );
1036 A02 = B2 ^((~B3)& B4 );
1037 A33 = B3 ^((~B4)& B0 );
1038 A14 = B4 ^((~B0)& B1 );
1040 B4 = ROL64((A30^D0), 18);
1041 B0 = ROL64((A11^D1), 1);
1042 B1 = ROL64((A42^D2), 6);
1043 B2 = ROL64((A23^D3), 25);
1044 B3 = ROL64((A04^D4), 8);
1045 A30 = B0 ^((~B1)& B2 );
1046 A11 = B1 ^((~B2)& B3 );
1047 A42 = B2 ^((~B3)& B4 );
1048 A23 = B3 ^((~B4)& B0 );
1049 A04 = B4 ^((~B0)& B1 );
1051 B1 = ROL64((A20^D0), 36);
1052 B2 = ROL64((A01^D1), 10);
1053 B3 = ROL64((A32^D2), 15);
1054 B4 = ROL64((A13^D3), 56);
1055 B0 = ROL64((A44^D4), 27);
1056 A20 = B0 ^((~B1)& B2 );
1057 A01 = B1 ^((~B2)& B3 );
1058 A32 = B2 ^((~B3)& B4 );
1059 A13 = B3 ^((~B4)& B0 );
1060 A44 = B4 ^((~B0)& B1 );
1062 B3 = ROL64((A10^D0), 41);
1063 B4 = ROL64((A41^D1), 2);
1064 B0 = ROL64((A22^D2), 62);
1065 B1 = ROL64((A03^D3), 55);
1066 B2 = ROL64((A34^D4), 39);
1067 A10 = B0 ^((~B1)& B2 );
1068 A41 = B1 ^((~B2)& B3 );
1069 A22 = B2 ^((~B3)& B4 );
1070 A03 = B3 ^((~B4)& B0 );
1071 A34 = B4 ^((~B0)& B1 );
1073 C0 = A00^A40^A30^A20^A10;
1074 C1 = A31^A21^A11^A01^A41;
1075 C2 = A12^A02^A42^A32^A22;
1076 C3 = A43^A33^A23^A13^A03;
1077 C4 = A24^A14^A04^A44^A34;
1078 D0 = C4^ROL64(C1, 1);
1079 D1 = C0^ROL64(C2, 1);
1080 D2 = C1^ROL64(C3, 1);
1081 D3 = C2^ROL64(C4, 1);
1082 D4 = C3^ROL64(C0, 1);
1085 B1 = ROL64((A21^D1), 44);
1086 B2 = ROL64((A42^D2), 43);
1087 B3 = ROL64((A13^D3), 21);
1088 B4 = ROL64((A34^D4), 14);
1089 A00 = B0 ^((~B1)& B2 );
1091 A21 = B1 ^((~B2)& B3 );
1092 A42 = B2 ^((~B3)& B4 );
1093 A13 = B3 ^((~B4)& B0 );
1094 A34 = B4 ^((~B0)& B1 );
1096 B2 = ROL64((A30^D0), 3);
1097 B3 = ROL64((A01^D1), 45);
1098 B4 = ROL64((A22^D2), 61);
1099 B0 = ROL64((A43^D3), 28);
1100 B1 = ROL64((A14^D4), 20);
1101 A30 = B0 ^((~B1)& B2 );
1102 A01 = B1 ^((~B2)& B3 );
1103 A22 = B2 ^((~B3)& B4 );
1104 A43 = B3 ^((~B4)& B0 );
1105 A14 = B4 ^((~B0)& B1 );
1107 B4 = ROL64((A10^D0), 18);
1108 B0 = ROL64((A31^D1), 1);
1109 B1 = ROL64((A02^D2), 6);
1110 B2 = ROL64((A23^D3), 25);
1111 B3 = ROL64((A44^D4), 8);
1112 A10 = B0 ^((~B1)& B2 );
1113 A31 = B1 ^((~B2)& B3 );
1114 A02 = B2 ^((~B3)& B4 );
1115 A23 = B3 ^((~B4)& B0 );
1116 A44 = B4 ^((~B0)& B1 );
1118 B1 = ROL64((A40^D0), 36);
1119 B2 = ROL64((A11^D1), 10);
1120 B3 = ROL64((A32^D2), 15);
1121 B4 = ROL64((A03^D3), 56);
1122 B0 = ROL64((A24^D4), 27);
1123 A40 = B0 ^((~B1)& B2 );
1124 A11 = B1 ^((~B2)& B3 );
1125 A32 = B2 ^((~B3)& B4 );
1126 A03 = B3 ^((~B4)& B0 );
1127 A24 = B4 ^((~B0)& B1 );
1129 B3 = ROL64((A20^D0), 41);
1130 B4 = ROL64((A41^D1), 2);
1131 B0 = ROL64((A12^D2), 62);
1132 B1 = ROL64((A33^D3), 55);
1133 B2 = ROL64((A04^D4), 39);
1134 A20 = B0 ^((~B1)& B2 );
1135 A41 = B1 ^((~B2)& B3 );
1136 A12 = B2 ^((~B3)& B4 );
1137 A33 = B3 ^((~B4)& B0 );
1138 A04 = B4 ^((~B0)& B1 );
1140 C0 = A00^A30^A10^A40^A20;
1141 C1 = A21^A01^A31^A11^A41;
1142 C2 = A42^A22^A02^A32^A12;
1143 C3 = A13^A43^A23^A03^A33;
1144 C4 = A34^A14^A44^A24^A04;
1145 D0 = C4^ROL64(C1, 1);
1146 D1 = C0^ROL64(C2, 1);
1147 D2 = C1^ROL64(C3, 1);
1148 D3 = C2^ROL64(C4, 1);
1149 D4 = C3^ROL64(C0, 1);
1152 B1 = ROL64((A01^D1), 44);
1153 B2 = ROL64((A02^D2), 43);
1154 B3 = ROL64((A03^D3), 21);
1155 B4 = ROL64((A04^D4), 14);
1156 A00 = B0 ^((~B1)& B2 );
1158 A01 = B1 ^((~B2)& B3 );
1159 A02 = B2 ^((~B3)& B4 );
1160 A03 = B3 ^((~B4)& B0 );
1161 A04 = B4 ^((~B0)& B1 );
1163 B2 = ROL64((A10^D0), 3);
1164 B3 = ROL64((A11^D1), 45);
1165 B4 = ROL64((A12^D2), 61);
1166 B0 = ROL64((A13^D3), 28);
1167 B1 = ROL64((A14^D4), 20);
1168 A10 = B0 ^((~B1)& B2 );
1169 A11 = B1 ^((~B2)& B3 );
1170 A12 = B2 ^((~B3)& B4 );
1171 A13 = B3 ^((~B4)& B0 );
1172 A14 = B4 ^((~B0)& B1 );
1174 B4 = ROL64((A20^D0), 18);
1175 B0 = ROL64((A21^D1), 1);
1176 B1 = ROL64((A22^D2), 6);
1177 B2 = ROL64((A23^D3), 25);
1178 B3 = ROL64((A24^D4), 8);
1179 A20 = B0 ^((~B1)& B2 );
1180 A21 = B1 ^((~B2)& B3 );
1181 A22 = B2 ^((~B3)& B4 );
1182 A23 = B3 ^((~B4)& B0 );
1183 A24 = B4 ^((~B0)& B1 );
1185 B1 = ROL64((A30^D0), 36);
1186 B2 = ROL64((A31^D1), 10);
1187 B3 = ROL64((A32^D2), 15);
1188 B4 = ROL64((A33^D3), 56);
1189 B0 = ROL64((A34^D4), 27);
1190 A30 = B0 ^((~B1)& B2 );
1191 A31 = B1 ^((~B2)& B3 );
1192 A32 = B2 ^((~B3)& B4 );
1193 A33 = B3 ^((~B4)& B0 );
1194 A34 = B4 ^((~B0)& B1 );
1196 B3 = ROL64((A40^D0), 41);
1197 B4 = ROL64((A41^D1), 2);
1198 B0 = ROL64((A42^D2), 62);
1199 B1 = ROL64((A43^D3), 55);
1200 B2 = ROL64((A44^D4), 39);
1201 A40 = B0 ^((~B1)& B2 );
1202 A41 = B1 ^((~B2)& B3 );
1203 A42 = B2 ^((~B3)& B4 );
1204 A43 = B3 ^((~B4)& B0 );
1205 A44 = B4 ^((~B0)& B1 );
1210 ** Initialize a new hash. iSize determines the size of the hash
1211 ** in bits and should be one of 224, 256, 384, or 512. Or iSize
1212 ** can be zero to use the default hash size of 256 bits.
1214 static void SHA3Init(SHA3Context *p, int iSize){
1215 memset(p, 0, sizeof(*p));
1216 if( iSize>=128 && iSize<=512 ){
1217 p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1219 p->nRate = (1600 - 2*256)/8;
1221 #if SHA3_BYTEORDER==1234
1222 /* Known to be little-endian at compile-time. No-op */
1223 #elif SHA3_BYTEORDER==4321
1224 p->ixMask = 7; /* Big-endian */
1227 static unsigned int one = 1;
1228 if( 1==*(unsigned char*)&one ){
1229 /* Little endian. No byte swapping. */
1232 /* Big endian. Byte swap. */
1240 ** Make consecutive calls to the SHA3Update function to add new content
1243 static void SHA3Update(
1245 const unsigned char *aData,
1249 #if SHA3_BYTEORDER==1234
1250 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1251 for(; i+7<nData; i+=8){
1252 p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
1254 if( p->nLoaded>=p->nRate ){
1261 for(; i<nData; i++){
1262 #if SHA3_BYTEORDER==1234
1263 p->u.x[p->nLoaded] ^= aData[i];
1264 #elif SHA3_BYTEORDER==4321
1265 p->u.x[p->nLoaded^0x07] ^= aData[i];
1267 p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1270 if( p->nLoaded==p->nRate ){
1278 ** After all content has been added, invoke SHA3Final() to compute
1279 ** the final hash. The function returns a pointer to the binary
1282 static unsigned char *SHA3Final(SHA3Context *p){
1284 if( p->nLoaded==p->nRate-1 ){
1285 const unsigned char c1 = 0x86;
1286 SHA3Update(p, &c1, 1);
1288 const unsigned char c2 = 0x06;
1289 const unsigned char c3 = 0x80;
1290 SHA3Update(p, &c2, 1);
1291 p->nLoaded = p->nRate - 1;
1292 SHA3Update(p, &c3, 1);
1294 for(i=0; i<p->nRate; i++){
1295 p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1297 return &p->u.x[p->nRate];
1299 /* End of the hashing logic
1300 *****************************************************************************/
1303 ** Implementation of the sha3(X,SIZE) function.
1305 ** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1306 ** size is 256. If X is a BLOB, it is hashed as is.
1307 ** For all other non-NULL types of input, X is converted into a UTF-8 string
1308 ** and the string is hashed without the trailing 0x00 terminator. The hash
1309 ** of a NULL value is NULL.
1311 static void sha3Func(
1312 sqlite3_context *context,
1314 sqlite3_value **argv
1317 int eType = sqlite3_value_type(argv[0]);
1318 int nByte = sqlite3_value_bytes(argv[0]);
1323 iSize = sqlite3_value_int(argv[1]);
1324 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1325 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1330 if( eType==SQLITE_NULL ) return;
1331 SHA3Init(&cx, iSize);
1332 if( eType==SQLITE_BLOB ){
1333 SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1335 SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1337 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1340 /* Compute a string using sqlite3_vsnprintf() with a maximum length
1341 ** of 50 bytes and add it to the hash.
1343 static void hash_step_vformat(
1344 SHA3Context *p, /* Add content to this context */
1345 const char *zFormat,
1351 va_start(ap, zFormat);
1352 sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1354 n = (int)strlen(zBuf);
1355 SHA3Update(p, (unsigned char*)zBuf, n);
1359 ** Implementation of the sha3_query(SQL,SIZE) function.
1361 ** This function compiles and runs the SQL statement(s) given in the
1362 ** argument. The results are hashed using a SIZE-bit SHA3. The default
1365 ** The format of the byte stream that is hashed is summarized as follows:
1375 ** <sql> is the original SQL text for each statement run and <n> is
1376 ** the size of that text. The SQL text is UTF-8. A single R character
1377 ** occurs before the start of each row. N means a NULL value.
1378 ** I mean an 8-byte little-endian integer <int>. F is a floating point
1379 ** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1380 ** B means blobs of <size> bytes. T means text rendered as <size>
1381 ** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1384 ** For each SQL statement in the X input, there is one S segment. Each
1385 ** S segment is followed by zero or more R segments, one for each row in the
1386 ** result set. After each R, there are one or more N, I, F, B, or T segments,
1387 ** one for each column in the result set. Segments are concatentated directly
1388 ** with no delimiters of any kind.
1390 static void sha3QueryFunc(
1391 sqlite3_context *context,
1393 sqlite3_value **argv
1395 sqlite3 *db = sqlite3_context_db_handle(context);
1396 const char *zSql = (const char*)sqlite3_value_text(argv[0]);
1397 sqlite3_stmt *pStmt = 0;
1398 int nCol; /* Number of columns in the result set */
1399 int i; /* Loop counter */
1409 iSize = sqlite3_value_int(argv[1]);
1410 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1411 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1416 if( zSql==0 ) return;
1417 SHA3Init(&cx, iSize);
1419 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1421 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1422 zSql, sqlite3_errmsg(db));
1423 sqlite3_finalize(pStmt);
1424 sqlite3_result_error(context, zMsg, -1);
1428 if( !sqlite3_stmt_readonly(pStmt) ){
1429 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1430 sqlite3_finalize(pStmt);
1431 sqlite3_result_error(context, zMsg, -1);
1435 nCol = sqlite3_column_count(pStmt);
1436 z = sqlite3_sql(pStmt);
1438 hash_step_vformat(&cx,"S%d:",n);
1439 SHA3Update(&cx,(unsigned char*)z,n);
1441 /* Compute a hash over the result of the query */
1442 while( SQLITE_ROW==sqlite3_step(pStmt) ){
1443 SHA3Update(&cx,(const unsigned char*)"R",1);
1444 for(i=0; i<nCol; i++){
1445 switch( sqlite3_column_type(pStmt,i) ){
1447 SHA3Update(&cx, (const unsigned char*)"N",1);
1450 case SQLITE_INTEGER: {
1454 sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1456 for(j=8; j>=1; j--){
1461 SHA3Update(&cx, x, 9);
1464 case SQLITE_FLOAT: {
1468 double r = sqlite3_column_double(pStmt,i);
1470 for(j=8; j>=1; j--){
1475 SHA3Update(&cx,x,9);
1479 int n2 = sqlite3_column_bytes(pStmt, i);
1480 const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1481 hash_step_vformat(&cx,"T%d:",n2);
1482 SHA3Update(&cx, z2, n2);
1486 int n2 = sqlite3_column_bytes(pStmt, i);
1487 const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1488 hash_step_vformat(&cx,"B%d:",n2);
1489 SHA3Update(&cx, z2, n2);
1495 sqlite3_finalize(pStmt);
1497 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1504 int sqlite3_shathree_init(
1507 const sqlite3_api_routines *pApi
1510 SQLITE_EXTENSION_INIT2(pApi);
1511 (void)pzErrMsg; /* Unused parameter */
1512 rc = sqlite3_create_function(db, "sha3", 1, SQLITE_UTF8, 0,
1514 if( rc==SQLITE_OK ){
1515 rc = sqlite3_create_function(db, "sha3", 2, SQLITE_UTF8, 0,
1518 if( rc==SQLITE_OK ){
1519 rc = sqlite3_create_function(db, "sha3_query", 1, SQLITE_UTF8, 0,
1520 sha3QueryFunc, 0, 0);
1522 if( rc==SQLITE_OK ){
1523 rc = sqlite3_create_function(db, "sha3_query", 2, SQLITE_UTF8, 0,
1524 sha3QueryFunc, 0, 0);
1529 /************************* End ../ext/misc/shathree.c ********************/
1530 /************************* Begin ../ext/misc/fileio.c ******************/
1534 ** The author disclaims copyright to this source code. In place of
1535 ** a legal notice, here is a blessing:
1537 ** May you do good and not evil.
1538 ** May you find forgiveness for yourself and forgive others.
1539 ** May you share freely, never taking more than you give.
1541 ******************************************************************************
1543 ** This SQLite extension implements SQL functions readfile() and
1546 SQLITE_EXTENSION_INIT1
1550 ** Implementation of the "readfile(X)" SQL function. The entire content
1551 ** of the file named X is read and returned as a BLOB. NULL is returned
1552 ** if the file does not exist or is unreadable.
1554 static void readfileFunc(
1555 sqlite3_context *context,
1557 sqlite3_value **argv
1564 (void)(argc); /* Unused parameter */
1565 zName = (const char*)sqlite3_value_text(argv[0]);
1566 if( zName==0 ) return;
1567 in = fopen(zName, "rb");
1569 fseek(in, 0, SEEK_END);
1572 pBuf = sqlite3_malloc( nIn );
1573 if( pBuf && 1==fread(pBuf, nIn, 1, in) ){
1574 sqlite3_result_blob(context, pBuf, nIn, sqlite3_free);
1582 ** Implementation of the "writefile(X,Y)" SQL function. The argument Y
1583 ** is written into file X. The number of bytes written is returned. Or
1584 ** NULL is returned if something goes wrong, such as being unable to open
1585 ** file X for writing.
1587 static void writefileFunc(
1588 sqlite3_context *context,
1590 sqlite3_value **argv
1597 (void)(argc); /* Unused parameter */
1598 zFile = (const char*)sqlite3_value_text(argv[0]);
1599 if( zFile==0 ) return;
1600 out = fopen(zFile, "wb");
1601 if( out==0 ) return;
1602 z = (const char*)sqlite3_value_blob(argv[1]);
1606 rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
1609 sqlite3_result_int64(context, rc);
1616 int sqlite3_fileio_init(
1619 const sqlite3_api_routines *pApi
1622 SQLITE_EXTENSION_INIT2(pApi);
1623 (void)pzErrMsg; /* Unused parameter */
1624 rc = sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
1625 readfileFunc, 0, 0);
1626 if( rc==SQLITE_OK ){
1627 rc = sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
1628 writefileFunc, 0, 0);
1633 /************************* End ../ext/misc/fileio.c ********************/
1634 /************************* Begin ../ext/misc/completion.c ******************/
1638 ** The author disclaims copyright to this source code. In place of
1639 ** a legal notice, here is a blessing:
1641 ** May you do good and not evil.
1642 ** May you find forgiveness for yourself and forgive others.
1643 ** May you share freely, never taking more than you give.
1645 *************************************************************************
1647 ** This file implements an eponymous virtual table that returns suggested
1648 ** completions for a partial SQL input.
1652 ** SELECT DISTINCT candidate COLLATE nocase
1653 ** FROM completion($prefix,$wholeline)
1656 ** The two query parameters are optional. $prefix is the text of the
1657 ** current word being typed and that is to be completed. $wholeline is
1658 ** the complete input line, used for context.
1660 ** The raw completion() table might return the same candidate multiple
1661 ** times, for example if the same column name is used to two or more
1662 ** tables. And the candidates are returned in an arbitrary order. Hence,
1663 ** the DISTINCT and ORDER BY are recommended.
1665 ** This virtual table operates at the speed of human typing, and so there
1666 ** is no attempt to make it fast. Even a slow implementation will be much
1667 ** faster than any human can type.
1670 SQLITE_EXTENSION_INIT1
1675 #ifndef SQLITE_OMIT_VIRTUALTABLE
1677 /* completion_vtab is a subclass of sqlite3_vtab which will
1678 ** serve as the underlying representation of a completion virtual table
1680 typedef struct completion_vtab completion_vtab;
1681 struct completion_vtab {
1682 sqlite3_vtab base; /* Base class - must be first */
1683 sqlite3 *db; /* Database connection for this completion vtab */
1686 /* completion_cursor is a subclass of sqlite3_vtab_cursor which will
1687 ** serve as the underlying representation of a cursor that scans
1688 ** over rows of the result
1690 typedef struct completion_cursor completion_cursor;
1691 struct completion_cursor {
1692 sqlite3_vtab_cursor base; /* Base class - must be first */
1693 sqlite3 *db; /* Database connection for this cursor */
1694 int nPrefix, nLine; /* Number of bytes in zPrefix and zLine */
1695 char *zPrefix; /* The prefix for the word we want to complete */
1696 char *zLine; /* The whole that we want to complete */
1697 const char *zCurrentRow; /* Current output row */
1698 sqlite3_stmt *pStmt; /* Current statement */
1699 sqlite3_int64 iRowid; /* The rowid */
1700 int ePhase; /* Current phase */
1701 int j; /* inter-phase counter */
1704 /* Values for ePhase:
1706 #define COMPLETION_FIRST_PHASE 1
1707 #define COMPLETION_KEYWORDS 1
1708 #define COMPLETION_PRAGMAS 2
1709 #define COMPLETION_FUNCTIONS 3
1710 #define COMPLETION_COLLATIONS 4
1711 #define COMPLETION_INDEXES 5
1712 #define COMPLETION_TRIGGERS 6
1713 #define COMPLETION_DATABASES 7
1714 #define COMPLETION_TABLES 8
1715 #define COMPLETION_COLUMNS 9
1716 #define COMPLETION_MODULES 10
1717 #define COMPLETION_EOF 11
1720 ** The completionConnect() method is invoked to create a new
1721 ** completion_vtab that describes the completion virtual table.
1723 ** Think of this routine as the constructor for completion_vtab objects.
1725 ** All this routine needs to do is:
1727 ** (1) Allocate the completion_vtab object and initialize all fields.
1729 ** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
1730 ** result set of queries against completion will look like.
1732 static int completionConnect(
1735 int argc, const char *const*argv,
1736 sqlite3_vtab **ppVtab,
1739 completion_vtab *pNew;
1742 (void)(pAux); /* Unused parameter */
1743 (void)(argc); /* Unused parameter */
1744 (void)(argv); /* Unused parameter */
1745 (void)(pzErr); /* Unused parameter */
1747 /* Column numbers */
1748 #define COMPLETION_COLUMN_CANDIDATE 0 /* Suggested completion of the input */
1749 #define COMPLETION_COLUMN_PREFIX 1 /* Prefix of the word to be completed */
1750 #define COMPLETION_COLUMN_WHOLELINE 2 /* Entire line seen so far */
1751 #define COMPLETION_COLUMN_PHASE 3 /* ePhase - used for debugging only */
1753 rc = sqlite3_declare_vtab(db,
1756 " prefix TEXT HIDDEN,"
1757 " wholeline TEXT HIDDEN,"
1758 " phase INT HIDDEN" /* Used for debugging only */
1760 if( rc==SQLITE_OK ){
1761 pNew = sqlite3_malloc( sizeof(*pNew) );
1762 *ppVtab = (sqlite3_vtab*)pNew;
1763 if( pNew==0 ) return SQLITE_NOMEM;
1764 memset(pNew, 0, sizeof(*pNew));
1771 ** This method is the destructor for completion_cursor objects.
1773 static int completionDisconnect(sqlite3_vtab *pVtab){
1774 sqlite3_free(pVtab);
1779 ** Constructor for a new completion_cursor object.
1781 static int completionOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
1782 completion_cursor *pCur;
1783 pCur = sqlite3_malloc( sizeof(*pCur) );
1784 if( pCur==0 ) return SQLITE_NOMEM;
1785 memset(pCur, 0, sizeof(*pCur));
1786 pCur->db = ((completion_vtab*)p)->db;
1787 *ppCursor = &pCur->base;
1792 ** Reset the completion_cursor.
1794 static void completionCursorReset(completion_cursor *pCur){
1795 sqlite3_free(pCur->zPrefix); pCur->zPrefix = 0; pCur->nPrefix = 0;
1796 sqlite3_free(pCur->zLine); pCur->zLine = 0; pCur->nLine = 0;
1797 sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0;
1802 ** Destructor for a completion_cursor.
1804 static int completionClose(sqlite3_vtab_cursor *cur){
1805 completionCursorReset((completion_cursor*)cur);
1811 ** All SQL keywords understood by SQLite
1813 static const char *completionKwrds[] = {
1814 "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
1815 "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
1816 "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
1817 "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
1818 "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
1819 "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
1820 "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
1821 "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
1822 "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
1823 "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
1824 "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
1825 "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
1826 "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
1827 "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
1828 "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
1829 "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
1830 "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
1833 #define completionKwCount \
1834 (int)(sizeof(completionKwrds)/sizeof(completionKwrds[0]))
1837 ** Advance a completion_cursor to its next row of output.
1839 ** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object
1840 ** record the current state of the scan. This routine sets ->zCurrentRow
1841 ** to the current row of output and then returns. If no more rows remain,
1842 ** then ->ePhase is set to COMPLETION_EOF which will signal the virtual
1843 ** table that has reached the end of its scan.
1845 ** The current implementation just lists potential identifiers and
1846 ** keywords and filters them by zPrefix. Future enhancements should
1847 ** take zLine into account to try to restrict the set of identifiers and
1848 ** keywords based on what would be legal at the current point of input.
1850 static int completionNext(sqlite3_vtab_cursor *cur){
1851 completion_cursor *pCur = (completion_cursor*)cur;
1852 int eNextPhase = 0; /* Next phase to try if current phase reaches end */
1853 int iCol = -1; /* If >=0, step pCur->pStmt and use the i-th column */
1855 while( pCur->ePhase!=COMPLETION_EOF ){
1856 switch( pCur->ePhase ){
1857 case COMPLETION_KEYWORDS: {
1858 if( pCur->j >= completionKwCount ){
1859 pCur->zCurrentRow = 0;
1860 pCur->ePhase = COMPLETION_DATABASES;
1862 pCur->zCurrentRow = completionKwrds[pCur->j++];
1867 case COMPLETION_DATABASES: {
1868 if( pCur->pStmt==0 ){
1869 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1,
1873 eNextPhase = COMPLETION_TABLES;
1876 case COMPLETION_TABLES: {
1877 if( pCur->pStmt==0 ){
1880 const char *zSep = "";
1881 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
1882 while( sqlite3_step(pS2)==SQLITE_ROW ){
1883 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
1884 zSql = sqlite3_mprintf(
1886 "SELECT name FROM \"%w\".sqlite_master"
1887 " WHERE type='table'",
1890 if( zSql==0 ) return SQLITE_NOMEM;
1893 sqlite3_finalize(pS2);
1894 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
1898 eNextPhase = COMPLETION_COLUMNS;
1901 case COMPLETION_COLUMNS: {
1902 if( pCur->pStmt==0 ){
1905 const char *zSep = "";
1906 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
1907 while( sqlite3_step(pS2)==SQLITE_ROW ){
1908 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
1909 zSql = sqlite3_mprintf(
1911 "SELECT pti.name FROM \"%w\".sqlite_master AS sm"
1912 " JOIN pragma_table_info(sm.name,%Q) AS pti"
1913 " WHERE sm.type='table'",
1914 zSql, zSep, zDb, zDb
1916 if( zSql==0 ) return SQLITE_NOMEM;
1919 sqlite3_finalize(pS2);
1920 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
1924 eNextPhase = COMPLETION_EOF;
1929 /* This case is when the phase presets zCurrentRow */
1930 if( pCur->zCurrentRow==0 ) continue;
1932 if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){
1933 /* Extract the next row of content */
1934 pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol);
1936 /* When all rows are finished, advance to the next phase */
1937 sqlite3_finalize(pCur->pStmt);
1939 pCur->ePhase = eNextPhase;
1943 if( pCur->nPrefix==0 ) break;
1944 if( sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0 ){
1953 ** Return values of columns for the row at which the completion_cursor
1954 ** is currently pointing.
1956 static int completionColumn(
1957 sqlite3_vtab_cursor *cur, /* The cursor */
1958 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
1959 int i /* Which column to return */
1961 completion_cursor *pCur = (completion_cursor*)cur;
1963 case COMPLETION_COLUMN_CANDIDATE: {
1964 sqlite3_result_text(ctx, pCur->zCurrentRow, -1, SQLITE_TRANSIENT);
1967 case COMPLETION_COLUMN_PREFIX: {
1968 sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT);
1971 case COMPLETION_COLUMN_WHOLELINE: {
1972 sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT);
1975 case COMPLETION_COLUMN_PHASE: {
1976 sqlite3_result_int(ctx, pCur->ePhase);
1984 ** Return the rowid for the current row. In this implementation, the
1985 ** rowid is the same as the output value.
1987 static int completionRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
1988 completion_cursor *pCur = (completion_cursor*)cur;
1989 *pRowid = pCur->iRowid;
1994 ** Return TRUE if the cursor has been moved off of the last
1997 static int completionEof(sqlite3_vtab_cursor *cur){
1998 completion_cursor *pCur = (completion_cursor*)cur;
1999 return pCur->ePhase >= COMPLETION_EOF;
2003 ** This method is called to "rewind" the completion_cursor object back
2004 ** to the first row of output. This method is always called at least
2005 ** once prior to any call to completionColumn() or completionRowid() or
2008 static int completionFilter(
2009 sqlite3_vtab_cursor *pVtabCursor,
2010 int idxNum, const char *idxStr,
2011 int argc, sqlite3_value **argv
2013 completion_cursor *pCur = (completion_cursor *)pVtabCursor;
2015 (void)(idxStr); /* Unused parameter */
2016 (void)(argc); /* Unused parameter */
2017 completionCursorReset(pCur);
2019 pCur->nPrefix = sqlite3_value_bytes(argv[iArg]);
2020 if( pCur->nPrefix>0 ){
2021 pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
2022 if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
2027 pCur->nLine = sqlite3_value_bytes(argv[iArg]);
2028 if( pCur->nLine>0 ){
2029 pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
2030 if( pCur->zLine==0 ) return SQLITE_NOMEM;
2034 if( pCur->zLine!=0 && pCur->zPrefix==0 ){
2035 int i = pCur->nLine;
2036 while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){
2039 pCur->nPrefix = pCur->nLine - i;
2040 if( pCur->nPrefix>0 ){
2041 pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i);
2042 if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
2046 pCur->ePhase = COMPLETION_FIRST_PHASE;
2047 return completionNext(pVtabCursor);
2051 ** SQLite will invoke this method one or more times while planning a query
2052 ** that uses the completion virtual table. This routine needs to create
2053 ** a query plan for each invocation and compute an estimated cost for that
2056 ** There are two hidden parameters that act as arguments to the table-valued
2057 ** function: "prefix" and "wholeline". Bit 0 of idxNum is set if "prefix"
2058 ** is available and bit 1 is set if "wholeline" is available.
2060 static int completionBestIndex(
2062 sqlite3_index_info *pIdxInfo
2064 int i; /* Loop over constraints */
2065 int idxNum = 0; /* The query plan bitmask */
2066 int prefixIdx = -1; /* Index of the start= constraint, or -1 if none */
2067 int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */
2068 int nArg = 0; /* Number of arguments that completeFilter() expects */
2069 const struct sqlite3_index_constraint *pConstraint;
2071 (void)(tab); /* Unused parameter */
2072 pConstraint = pIdxInfo->aConstraint;
2073 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
2074 if( pConstraint->usable==0 ) continue;
2075 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
2076 switch( pConstraint->iColumn ){
2077 case COMPLETION_COLUMN_PREFIX:
2081 case COMPLETION_COLUMN_WHOLELINE:
2088 pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg;
2089 pIdxInfo->aConstraintUsage[prefixIdx].omit = 1;
2091 if( wholelineIdx>=0 ){
2092 pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg;
2093 pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1;
2095 pIdxInfo->idxNum = idxNum;
2096 pIdxInfo->estimatedCost = (double)5000 - 1000*nArg;
2097 pIdxInfo->estimatedRows = 500 - 100*nArg;
2102 ** This following structure defines all the methods for the
2103 ** completion virtual table.
2105 static sqlite3_module completionModule = {
2108 completionConnect, /* xConnect */
2109 completionBestIndex, /* xBestIndex */
2110 completionDisconnect, /* xDisconnect */
2112 completionOpen, /* xOpen - open a cursor */
2113 completionClose, /* xClose - close a cursor */
2114 completionFilter, /* xFilter - configure scan constraints */
2115 completionNext, /* xNext - advance a cursor */
2116 completionEof, /* xEof - check for end of scan */
2117 completionColumn, /* xColumn - read data */
2118 completionRowid, /* xRowid - read data */
2124 0, /* xFindMethod */
2131 #endif /* SQLITE_OMIT_VIRTUALTABLE */
2133 int sqlite3CompletionVtabInit(sqlite3 *db){
2135 #ifndef SQLITE_OMIT_VIRTUALTABLE
2136 rc = sqlite3_create_module(db, "completion", &completionModule, 0);
2144 int sqlite3_completion_init(
2147 const sqlite3_api_routines *pApi
2150 SQLITE_EXTENSION_INIT2(pApi);
2151 (void)(pzErrMsg); /* Unused parameter */
2152 #ifndef SQLITE_OMIT_VIRTUALTABLE
2153 rc = sqlite3CompletionVtabInit(db);
2158 /************************* End ../ext/misc/completion.c ********************/
2160 #if defined(SQLITE_ENABLE_SESSION)
2162 ** State information for a single open session
2164 typedef struct OpenSession OpenSession;
2165 struct OpenSession {
2166 char *zName; /* Symbolic name for this session */
2167 int nFilter; /* Number of xFilter rejection GLOB patterns */
2168 char **azFilter; /* Array of xFilter rejection GLOB patterns */
2169 sqlite3_session *p; /* The open session */
2174 ** Shell output mode information from before ".explain on",
2175 ** saved so that it can be restored by ".explain off"
2177 typedef struct SavedModeInfo SavedModeInfo;
2178 struct SavedModeInfo {
2179 int valid; /* Is there legit data in here? */
2180 int mode; /* Mode prior to ".explain on" */
2181 int showHeader; /* The ".header" setting prior to ".explain on" */
2182 int colWidth[100]; /* Column widths prior to ".explain on" */
2186 ** State information about the database connection is contained in an
2187 ** instance of the following structure.
2189 typedef struct ShellState ShellState;
2191 sqlite3 *db; /* The database */
2192 int autoExplain; /* Automatically turn on .explain mode */
2193 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
2194 int statsOn; /* True to display memory stats before each finalize */
2195 int scanstatsOn; /* True to display scan stats before each finalize */
2196 int outCount; /* Revert to stdout when reaching zero */
2197 int cnt; /* Number of records displayed so far */
2198 FILE *out; /* Write results here */
2199 FILE *traceOut; /* Output for sqlite3_trace() */
2200 int nErr; /* Number of errors seen */
2201 int mode; /* An output mode setting */
2202 int cMode; /* temporary output mode for the current query */
2203 int normalMode; /* Output mode before ".explain on" */
2204 int writableSchema; /* True if PRAGMA writable_schema=ON */
2205 int showHeader; /* True to show column names in List or Column mode */
2206 int nCheck; /* Number of ".check" commands run */
2207 unsigned shellFlgs; /* Various flags */
2208 char *zDestTable; /* Name of destination table when MODE_Insert */
2209 char zTestcase[30]; /* Name of current test case */
2210 char colSeparator[20]; /* Column separator character for several modes */
2211 char rowSeparator[20]; /* Row separator character for MODE_Ascii */
2212 int colWidth[100]; /* Requested width of each column when in column mode*/
2213 int actualWidth[100]; /* Actual width of each column */
2214 char nullValue[20]; /* The text to print when a NULL comes back from
2216 char outfile[FILENAME_MAX]; /* Filename for *out */
2217 const char *zDbFilename; /* name of the database file */
2218 char *zFreeOnClose; /* Filename to free when closing */
2219 const char *zVfs; /* Name of VFS to use */
2220 sqlite3_stmt *pStmt; /* Current statement if any. */
2221 FILE *pLog; /* Write log output here */
2222 int *aiIndent; /* Array of indents used in MODE_Explain */
2223 int nIndent; /* Size of array aiIndent[] */
2224 int iIndent; /* Index of current op in aiIndent[] */
2225 #if defined(SQLITE_ENABLE_SESSION)
2226 int nSession; /* Number of active sessions */
2227 OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */
2232 ** These are the allowed shellFlgs values
2234 #define SHFLG_Pagecache 0x00000001 /* The --pagecache option is used */
2235 #define SHFLG_Lookaside 0x00000002 /* Lookaside memory is used */
2236 #define SHFLG_Backslash 0x00000004 /* The --backslash option is used */
2237 #define SHFLG_PreserveRowid 0x00000008 /* .dump preserves rowid values */
2238 #define SHFLG_Newlines 0x00000010 /* .dump --newline flag */
2239 #define SHFLG_CountChanges 0x00000020 /* .changes setting */
2240 #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
2243 ** Macros for testing and setting shellFlgs
2245 #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
2246 #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
2247 #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
2250 ** These are the allowed modes.
2252 #define MODE_Line 0 /* One column per line. Blank line between records */
2253 #define MODE_Column 1 /* One record per line in neat columns */
2254 #define MODE_List 2 /* One record per line with a separator */
2255 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
2256 #define MODE_Html 4 /* Generate an XHTML table */
2257 #define MODE_Insert 5 /* Generate SQL "insert" statements */
2258 #define MODE_Quote 6 /* Quote values as for SQL */
2259 #define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */
2260 #define MODE_Csv 8 /* Quote strings, numbers are plain */
2261 #define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */
2262 #define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */
2263 #define MODE_Pretty 11 /* Pretty-print schemas */
2265 static const char *modeDescr[] = {
2281 ** These are the column/row/line separators used by the various
2282 ** import/export modes.
2284 #define SEP_Column "|"
2285 #define SEP_Row "\n"
2286 #define SEP_Tab "\t"
2287 #define SEP_Space " "
2288 #define SEP_Comma ","
2289 #define SEP_CrLf "\r\n"
2290 #define SEP_Unit "\x1F"
2291 #define SEP_Record "\x1E"
2294 ** Number of elements in an array
2296 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
2299 ** A callback for the sqlite3_log() interface.
2301 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
2302 ShellState *p = (ShellState*)pArg;
2303 if( p->pLog==0 ) return;
2304 utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
2309 ** Output the given string as a hex-encoded blob (eg. X'1234' )
2311 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
2313 char *zBlob = (char *)pBlob;
2314 raw_printf(out,"X'");
2315 for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); }
2316 raw_printf(out,"'");
2320 ** Find a string that is not found anywhere in z[]. Return a pointer
2323 ** Try to use zA and zB first. If both of those are already found in z[]
2324 ** then make up some string and store it in the buffer zBuf.
2326 static const char *unused_string(
2327 const char *z, /* Result must not appear anywhere in z */
2328 const char *zA, const char *zB, /* Try these first */
2329 char *zBuf /* Space to store a generated string */
2332 if( strstr(z, zA)==0 ) return zA;
2333 if( strstr(z, zB)==0 ) return zB;
2335 sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++);
2336 }while( strstr(z,zBuf)!=0 );
2341 ** Output the given string as a quoted string using SQL quoting conventions.
2343 ** See also: output_quoted_escaped_string()
2345 static void output_quoted_string(FILE *out, const char *z){
2348 setBinaryMode(out, 1);
2349 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
2351 utf8_printf(out,"'%s'",z);
2353 raw_printf(out, "'");
2355 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
2358 utf8_printf(out, "%.*s", i, z);
2362 raw_printf(out, "'");
2370 raw_printf(out, "'");
2372 setTextMode(out, 1);
2376 ** Output the given string as a quoted string using SQL quoting conventions.
2377 ** Additionallly , escape the "\n" and "\r" characters so that they do not
2378 ** get corrupted by end-of-line translation facilities in some operating
2381 ** This is like output_quoted_string() but with the addition of the \r\n
2382 ** escape mechanism.
2384 static void output_quoted_escaped_string(FILE *out, const char *z){
2387 setBinaryMode(out, 1);
2388 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
2390 utf8_printf(out,"'%s'",z);
2392 const char *zNL = 0;
2393 const char *zCR = 0;
2396 char zBuf1[20], zBuf2[20];
2397 for(i=0; z[i]; i++){
2398 if( z[i]=='\n' ) nNL++;
2399 if( z[i]=='\r' ) nCR++;
2402 raw_printf(out, "replace(");
2403 zNL = unused_string(z, "\\n", "\\012", zBuf1);
2406 raw_printf(out, "replace(");
2407 zCR = unused_string(z, "\\r", "\\015", zBuf2);
2409 raw_printf(out, "'");
2411 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
2414 utf8_printf(out, "%.*s", i, z);
2418 raw_printf(out, "'");
2426 raw_printf(out, "%s", zNL);
2429 raw_printf(out, "%s", zCR);
2431 raw_printf(out, "'");
2433 raw_printf(out, ",'%s',char(13))", zCR);
2436 raw_printf(out, ",'%s',char(10))", zNL);
2439 setTextMode(out, 1);
2443 ** Output the given string as a quoted according to C or TCL quoting rules.
2445 static void output_c_string(FILE *out, const char *z){
2448 while( (c = *(z++))!=0 ){
2455 }else if( c=='\t' ){
2458 }else if( c=='\n' ){
2461 }else if( c=='\r' ){
2464 }else if( !isprint(c&0xff) ){
2465 raw_printf(out, "\\%03o", c&0xff);
2474 ** Output the given string with characters that are special to
2477 static void output_html_string(FILE *out, const char *z){
2489 utf8_printf(out,"%.*s",i,z);
2492 raw_printf(out,"<");
2493 }else if( z[i]=='&' ){
2494 raw_printf(out,"&");
2495 }else if( z[i]=='>' ){
2496 raw_printf(out,">");
2497 }else if( z[i]=='\"' ){
2498 raw_printf(out,""");
2499 }else if( z[i]=='\'' ){
2500 raw_printf(out,"'");
2509 ** If a field contains any character identified by a 1 in the following
2510 ** array, then the string must be quoted for CSV.
2512 static const char needCsvQuote[] = {
2513 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2514 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2515 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
2516 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2517 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2518 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2519 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2520 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
2521 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2522 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2523 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2524 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2525 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2526 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2527 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2528 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2532 ** Output a single term of CSV. Actually, p->colSeparator is used for
2533 ** the separator, which may or may not be a comma. p->nullValue is
2534 ** the null value. Strings are quoted if necessary. The separator
2535 ** is only issued if bSep is true.
2537 static void output_csv(ShellState *p, const char *z, int bSep){
2540 utf8_printf(out,"%s",p->nullValue);
2543 int nSep = strlen30(p->colSeparator);
2544 for(i=0; z[i]; i++){
2545 if( needCsvQuote[((unsigned char*)z)[i]]
2546 || (z[i]==p->colSeparator[0] &&
2547 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
2554 for(i=0; z[i]; i++){
2555 if( z[i]=='"' ) putc('"', out);
2560 utf8_printf(out, "%s", z);
2564 utf8_printf(p->out, "%s", p->colSeparator);
2570 ** This routine runs when the user presses Ctrl-C
2572 static void interrupt_handler(int NotUsed){
2573 UNUSED_PARAMETER(NotUsed);
2575 if( seenInterrupt>2 ) exit(1);
2576 if( globalDb ) sqlite3_interrupt(globalDb);
2580 #ifndef SQLITE_OMIT_AUTHORIZATION
2582 ** When the ".auth ON" is set, the following authorizer callback is
2583 ** invoked. It always returns SQLITE_OK.
2585 static int shellAuth(
2593 ShellState *p = (ShellState*)pClientData;
2594 static const char *azAction[] = { 0,
2595 "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX",
2596 "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW",
2597 "CREATE_TRIGGER", "CREATE_VIEW", "DELETE",
2598 "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX",
2599 "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW",
2600 "DROP_TRIGGER", "DROP_VIEW", "INSERT",
2601 "PRAGMA", "READ", "SELECT",
2602 "TRANSACTION", "UPDATE", "ATTACH",
2603 "DETACH", "ALTER_TABLE", "REINDEX",
2604 "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE",
2605 "FUNCTION", "SAVEPOINT", "RECURSIVE"
2613 utf8_printf(p->out, "authorizer: %s", azAction[op]);
2615 raw_printf(p->out, " ");
2617 output_c_string(p->out, az[i]);
2619 raw_printf(p->out, "NULL");
2622 raw_printf(p->out, "\n");
2628 ** Print a schema statement. Part of MODE_Semi and MODE_Pretty output.
2630 ** This routine converts some CREATE TABLE statements for shadow tables
2631 ** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements.
2633 static void printSchemaLine(FILE *out, const char *z, const char *zTail){
2634 if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
2635 utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
2637 utf8_printf(out, "%s%s", z, zTail);
2640 static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){
2643 printSchemaLine(out, z, zTail);
2648 ** This is the callback routine that the shell
2649 ** invokes for each row of a query result.
2651 static int shell_callback(
2653 int nArg, /* Number of result columns */
2654 char **azArg, /* Text of each result column */
2655 char **azCol, /* Column names */
2656 int *aiType /* Column types */
2659 ShellState *p = (ShellState*)pArg;
2661 if( azArg==0 ) return 0;
2665 if( azArg==0 ) break;
2666 for(i=0; i<nArg; i++){
2667 int len = strlen30(azCol[i] ? azCol[i] : "");
2668 if( len>w ) w = len;
2670 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
2671 for(i=0; i<nArg; i++){
2672 utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
2673 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
2679 static const int aExplainWidths[] = {4, 13, 4, 4, 4, 13, 2, 13};
2680 const int *colWidth;
2683 if( p->cMode==MODE_Column ){
2684 colWidth = p->colWidth;
2685 showHdr = p->showHeader;
2686 rowSep = p->rowSeparator;
2688 colWidth = aExplainWidths;
2693 for(i=0; i<nArg; i++){
2695 if( i<ArraySize(p->colWidth) ){
2701 w = strlenChar(azCol[i] ? azCol[i] : "");
2703 n = strlenChar(azArg && azArg[i] ? azArg[i] : p->nullValue);
2706 if( i<ArraySize(p->actualWidth) ){
2707 p->actualWidth[i] = w;
2710 utf8_width_print(p->out, w, azCol[i]);
2711 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
2715 for(i=0; i<nArg; i++){
2717 if( i<ArraySize(p->actualWidth) ){
2718 w = p->actualWidth[i];
2723 utf8_printf(p->out,"%-*.*s%s",w,w,
2724 "----------------------------------------------------------"
2725 "----------------------------------------------------------",
2726 i==nArg-1 ? rowSep : " ");
2730 if( azArg==0 ) break;
2731 for(i=0; i<nArg; i++){
2733 if( i<ArraySize(p->actualWidth) ){
2734 w = p->actualWidth[i];
2738 if( p->cMode==MODE_Explain && azArg[i] && strlenChar(azArg[i])>w ){
2739 w = strlenChar(azArg[i]);
2741 if( i==1 && p->aiIndent && p->pStmt ){
2742 if( p->iIndent<p->nIndent ){
2743 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
2747 utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue);
2748 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " ");
2752 case MODE_Semi: { /* .schema and .fullschema output */
2753 printSchemaLine(p->out, azArg[0], ";\n");
2756 case MODE_Pretty: { /* .schema and .fullschema with --indent */
2764 if( azArg[0]==0 ) break;
2765 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
2766 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
2768 utf8_printf(p->out, "%s;\n", azArg[0]);
2771 z = sqlite3_mprintf("%s", azArg[0]);
2773 for(i=0; IsSpace(z[i]); i++){}
2774 for(; (c = z[i])!=0; i++){
2776 if( z[j-1]=='\r' ) z[j-1] = '\n';
2777 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue;
2778 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){
2783 while( j>0 && IsSpace(z[j-1]) ){ j--; }
2785 if( strlen30(z)>=79 ){
2786 for(i=j=0; (c = z[i])!=0; i++){
2789 }else if( c=='"' || c=='\'' || c=='`' ){
2797 if( nLine>0 && nParen==0 && j>0 ){
2798 printSchemaLineN(p->out, z, j, "\n");
2803 if( nParen==1 && (c=='(' || c==',' || c=='\n') ){
2805 printSchemaLineN(p->out, z, j, "\n ");
2808 while( IsSpace(z[i+1]) ){ i++; }
2813 printSchemaLine(p->out, z, ";\n");
2818 if( p->cnt++==0 && p->showHeader ){
2819 for(i=0; i<nArg; i++){
2820 utf8_printf(p->out,"%s%s",azCol[i],
2821 i==nArg-1 ? p->rowSeparator : p->colSeparator);
2824 if( azArg==0 ) break;
2825 for(i=0; i<nArg; i++){
2827 if( z==0 ) z = p->nullValue;
2828 utf8_printf(p->out, "%s", z);
2830 utf8_printf(p->out, "%s", p->colSeparator);
2832 utf8_printf(p->out, "%s", p->rowSeparator);
2838 if( p->cnt++==0 && p->showHeader ){
2839 raw_printf(p->out,"<TR>");
2840 for(i=0; i<nArg; i++){
2841 raw_printf(p->out,"<TH>");
2842 output_html_string(p->out, azCol[i]);
2843 raw_printf(p->out,"</TH>\n");
2845 raw_printf(p->out,"</TR>\n");
2847 if( azArg==0 ) break;
2848 raw_printf(p->out,"<TR>");
2849 for(i=0; i<nArg; i++){
2850 raw_printf(p->out,"<TD>");
2851 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
2852 raw_printf(p->out,"</TD>\n");
2854 raw_printf(p->out,"</TR>\n");
2858 if( p->cnt++==0 && p->showHeader ){
2859 for(i=0; i<nArg; i++){
2860 output_c_string(p->out,azCol[i] ? azCol[i] : "");
2861 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
2863 utf8_printf(p->out, "%s", p->rowSeparator);
2865 if( azArg==0 ) break;
2866 for(i=0; i<nArg; i++){
2867 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
2868 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
2870 utf8_printf(p->out, "%s", p->rowSeparator);
2874 setBinaryMode(p->out, 1);
2875 if( p->cnt++==0 && p->showHeader ){
2876 for(i=0; i<nArg; i++){
2877 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
2879 utf8_printf(p->out, "%s", p->rowSeparator);
2882 for(i=0; i<nArg; i++){
2883 output_csv(p, azArg[i], i<nArg-1);
2885 utf8_printf(p->out, "%s", p->rowSeparator);
2887 setTextMode(p->out, 1);
2891 if( azArg==0 ) break;
2892 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
2893 if( p->showHeader ){
2894 raw_printf(p->out,"(");
2895 for(i=0; i<nArg; i++){
2896 if( i>0 ) raw_printf(p->out, ",");
2897 if( quoteChar(azCol[i]) ){
2898 char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
2899 utf8_printf(p->out, "%s", z);
2902 raw_printf(p->out, "%s", azCol[i]);
2905 raw_printf(p->out,")");
2908 for(i=0; i<nArg; i++){
2909 raw_printf(p->out, i>0 ? "," : " VALUES(");
2910 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
2911 utf8_printf(p->out,"NULL");
2912 }else if( aiType && aiType[i]==SQLITE_TEXT ){
2913 if( ShellHasFlag(p, SHFLG_Newlines) ){
2914 output_quoted_string(p->out, azArg[i]);
2916 output_quoted_escaped_string(p->out, azArg[i]);
2918 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
2919 utf8_printf(p->out,"%s", azArg[i]);
2920 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2922 double r = sqlite3_column_double(p->pStmt, i);
2923 sqlite3_snprintf(50,z,"%!.20g", r);
2924 raw_printf(p->out, "%s", z);
2925 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
2926 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
2927 int nBlob = sqlite3_column_bytes(p->pStmt, i);
2928 output_hex_blob(p->out, pBlob, nBlob);
2929 }else if( isNumber(azArg[i], 0) ){
2930 utf8_printf(p->out,"%s", azArg[i]);
2931 }else if( ShellHasFlag(p, SHFLG_Newlines) ){
2932 output_quoted_string(p->out, azArg[i]);
2934 output_quoted_escaped_string(p->out, azArg[i]);
2937 raw_printf(p->out,");\n");
2941 if( azArg==0 ) break;
2942 if( p->cnt==0 && p->showHeader ){
2943 for(i=0; i<nArg; i++){
2944 if( i>0 ) raw_printf(p->out, ",");
2945 output_quoted_string(p->out, azCol[i]);
2947 raw_printf(p->out,"\n");
2950 for(i=0; i<nArg; i++){
2951 if( i>0 ) raw_printf(p->out, ",");
2952 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
2953 utf8_printf(p->out,"NULL");
2954 }else if( aiType && aiType[i]==SQLITE_TEXT ){
2955 output_quoted_string(p->out, azArg[i]);
2956 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
2957 utf8_printf(p->out,"%s", azArg[i]);
2958 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2960 double r = sqlite3_column_double(p->pStmt, i);
2961 sqlite3_snprintf(50,z,"%!.20g", r);
2962 raw_printf(p->out, "%s", z);
2963 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
2964 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
2965 int nBlob = sqlite3_column_bytes(p->pStmt, i);
2966 output_hex_blob(p->out, pBlob, nBlob);
2967 }else if( isNumber(azArg[i], 0) ){
2968 utf8_printf(p->out,"%s", azArg[i]);
2970 output_quoted_string(p->out, azArg[i]);
2973 raw_printf(p->out,"\n");
2977 if( p->cnt++==0 && p->showHeader ){
2978 for(i=0; i<nArg; i++){
2979 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
2980 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
2982 utf8_printf(p->out, "%s", p->rowSeparator);
2984 if( azArg==0 ) break;
2985 for(i=0; i<nArg; i++){
2986 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
2987 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
2989 utf8_printf(p->out, "%s", p->rowSeparator);
2997 ** This is the callback routine that the SQLite library
2998 ** invokes for each row of a query result.
3000 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
3001 /* since we don't have type info, call the shell_callback with a NULL value */
3002 return shell_callback(pArg, nArg, azArg, azCol, NULL);
3006 ** This is the callback routine from sqlite3_exec() that appends all
3007 ** output onto the end of a ShellText object.
3009 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
3010 ShellText *p = (ShellText*)pArg;
3012 UNUSED_PARAMETER(az);
3013 if( azArg==0 ) return 0;
3014 if( p->n ) appendText(p, "|", 0);
3015 for(i=0; i<nArg; i++){
3016 if( i ) appendText(p, ",", 0);
3017 if( azArg[i] ) appendText(p, azArg[i], 0);
3023 ** Generate an appropriate SELFTEST table in the main database.
3025 static void createSelftestTable(ShellState *p){
3028 "SAVEPOINT selftest_init;\n"
3029 "CREATE TABLE IF NOT EXISTS selftest(\n"
3030 " tno INTEGER PRIMARY KEY,\n" /* Test number */
3031 " op TEXT,\n" /* Operator: memo run */
3032 " cmd TEXT,\n" /* Command text */
3033 " ans TEXT\n" /* Desired answer */
3035 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
3036 "INSERT INTO [_shell$self](rowid,op,cmd)\n"
3037 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
3038 " 'memo','Tests generated by --init');\n"
3039 "INSERT INTO [_shell$self]\n"
3041 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
3042 "FROM sqlite_master ORDER BY 2'',224))',\n"
3043 " hex(sha3_query('SELECT type,name,tbl_name,sql "
3044 "FROM sqlite_master ORDER BY 2',224));\n"
3045 "INSERT INTO [_shell$self]\n"
3047 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
3048 " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
3049 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
3051 " SELECT name FROM sqlite_master\n"
3052 " WHERE type='table'\n"
3053 " AND name<>'selftest'\n"
3054 " AND coalesce(rootpage,0)>0\n"
3057 "INSERT INTO [_shell$self]\n"
3058 " VALUES('run','PRAGMA integrity_check','ok');\n"
3059 "INSERT INTO selftest(tno,op,cmd,ans)"
3060 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
3061 "DROP TABLE [_shell$self];"
3064 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
3065 sqlite3_free(zErrMsg);
3067 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
3072 ** Set the destination table field of the ShellState structure to
3073 ** the name of the table given. Escape any quote characters in the
3076 static void set_table_name(ShellState *p, const char *zName){
3081 if( p->zDestTable ){
3082 free(p->zDestTable);
3085 if( zName==0 ) return;
3086 cQuote = quoteChar(zName);
3087 n = strlen30(zName);
3088 if( cQuote ) n += n+2;
3089 z = p->zDestTable = malloc( n+1 );
3091 raw_printf(stderr,"Error: out of memory\n");
3095 if( cQuote ) z[n++] = cQuote;
3096 for(i=0; zName[i]; i++){
3098 if( zName[i]==cQuote ) z[n++] = cQuote;
3100 if( cQuote ) z[n++] = cQuote;
3106 ** Execute a query statement that will generate SQL output. Print
3107 ** the result columns, comma-separated, on a line and then add a
3108 ** semicolon terminator to the end of that line.
3110 ** If the number of columns is 1 and that column contains text "--"
3111 ** then write the semicolon on a separate line. That way, if a
3112 ** "--" comment occurs at the end of the statement, the comment
3113 ** won't consume the semicolon terminator.
3115 static int run_table_dump_query(
3116 ShellState *p, /* Query context */
3117 const char *zSelect, /* SELECT statement to extract content */
3118 const char *zFirstRow /* Print before first row, if not NULL */
3120 sqlite3_stmt *pSelect;
3125 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
3126 if( rc!=SQLITE_OK || !pSelect ){
3127 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
3128 sqlite3_errmsg(p->db));
3129 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
3132 rc = sqlite3_step(pSelect);
3133 nResult = sqlite3_column_count(pSelect);
3134 while( rc==SQLITE_ROW ){
3136 utf8_printf(p->out, "%s", zFirstRow);
3139 z = (const char*)sqlite3_column_text(pSelect, 0);
3140 utf8_printf(p->out, "%s", z);
3141 for(i=1; i<nResult; i++){
3142 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
3145 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
3147 raw_printf(p->out, "\n;\n");
3149 raw_printf(p->out, ";\n");
3151 rc = sqlite3_step(pSelect);
3153 rc = sqlite3_finalize(pSelect);
3154 if( rc!=SQLITE_OK ){
3155 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
3156 sqlite3_errmsg(p->db));
3157 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
3163 ** Allocate space and save off current error string.
3165 static char *save_err_msg(
3166 sqlite3 *db /* Database to query */
3168 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
3169 char *zErrMsg = sqlite3_malloc64(nErrMsg);
3171 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
3178 ** Attempt to display I/O stats on Linux using /proc/PID/io
3180 static void displayLinuxIoStats(FILE *out){
3183 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
3184 in = fopen(z, "rb");
3186 while( fgets(z, sizeof(z), in)!=0 ){
3187 static const struct {
3188 const char *zPattern;
3191 { "rchar: ", "Bytes received by read():" },
3192 { "wchar: ", "Bytes sent to write():" },
3193 { "syscr: ", "Read() system calls:" },
3194 { "syscw: ", "Write() system calls:" },
3195 { "read_bytes: ", "Bytes read from storage:" },
3196 { "write_bytes: ", "Bytes written to storage:" },
3197 { "cancelled_write_bytes: ", "Cancelled write bytes:" },
3200 for(i=0; i<ArraySize(aTrans); i++){
3201 int n = (int)strlen(aTrans[i].zPattern);
3202 if( strncmp(aTrans[i].zPattern, z, n)==0 ){
3203 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
3213 ** Display a single line of status using 64-bit values.
3215 static void displayStatLine(
3216 ShellState *p, /* The shell context */
3217 char *zLabel, /* Label for this one line */
3218 char *zFormat, /* Format for the result */
3219 int iStatusCtrl, /* Which status to display */
3220 int bReset /* True to reset the stats */
3222 sqlite3_int64 iCur = -1;
3223 sqlite3_int64 iHiwtr = -1;
3226 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
3227 for(i=0, nPercent=0; zFormat[i]; i++){
3228 if( zFormat[i]=='%' ) nPercent++;
3231 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
3233 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
3235 raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
3239 ** Display memory stats.
3241 static int display_stats(
3242 sqlite3 *db, /* Database to query */
3243 ShellState *pArg, /* Pointer to ShellState */
3244 int bReset /* True to reset the stats */
3249 if( pArg && pArg->out ){
3250 displayStatLine(pArg, "Memory Used:",
3251 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
3252 displayStatLine(pArg, "Number of Outstanding Allocations:",
3253 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
3254 if( pArg->shellFlgs & SHFLG_Pagecache ){
3255 displayStatLine(pArg, "Number of Pcache Pages Used:",
3256 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
3258 displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
3259 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
3260 displayStatLine(pArg, "Largest Allocation:",
3261 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
3262 displayStatLine(pArg, "Largest Pcache Allocation:",
3263 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
3264 #ifdef YYTRACKMAXSTACKDEPTH
3265 displayStatLine(pArg, "Deepest Parser Stack:",
3266 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
3270 if( pArg && pArg->out && db ){
3271 if( pArg->shellFlgs & SHFLG_Lookaside ){
3273 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
3274 &iCur, &iHiwtr, bReset);
3275 raw_printf(pArg->out,
3276 "Lookaside Slots Used: %d (max %d)\n",
3278 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
3279 &iCur, &iHiwtr, bReset);
3280 raw_printf(pArg->out, "Successful lookaside attempts: %d\n",
3282 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
3283 &iCur, &iHiwtr, bReset);
3284 raw_printf(pArg->out, "Lookaside failures due to size: %d\n",
3286 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
3287 &iCur, &iHiwtr, bReset);
3288 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n",
3292 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
3293 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n",
3296 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
3297 raw_printf(pArg->out, "Page cache hits: %d\n", iCur);
3299 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
3300 raw_printf(pArg->out, "Page cache misses: %d\n", iCur);
3302 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
3303 raw_printf(pArg->out, "Page cache writes: %d\n", iCur);
3305 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
3306 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n",
3309 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
3310 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",
3314 if( pArg && pArg->out && db && pArg->pStmt ){
3315 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
3317 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur);
3318 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
3319 raw_printf(pArg->out, "Sort Operations: %d\n", iCur);
3320 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
3321 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur);
3322 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
3323 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
3327 displayLinuxIoStats(pArg->out);
3330 /* Do not remove this machine readable comment: extra-stats-output-here */
3336 ** Display scan stats.
3338 static void display_scanstats(
3339 sqlite3 *db, /* Database to query */
3340 ShellState *pArg /* Pointer to ShellState */
3342 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
3343 UNUSED_PARAMETER(db);
3344 UNUSED_PARAMETER(pArg);
3347 raw_printf(pArg->out, "-------- scanstats --------\n");
3349 for(k=0; k<=mx; k++){
3350 double rEstLoop = 1.0;
3352 sqlite3_stmt *p = pArg->pStmt;
3353 sqlite3_int64 nLoop, nVisit;
3356 const char *zExplain;
3357 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
3360 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
3361 if( iSid>mx ) mx = iSid;
3362 if( iSid!=k ) continue;
3364 rEstLoop = (double)nLoop;
3365 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k);
3368 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
3369 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
3370 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
3371 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain);
3373 raw_printf(pArg->out,
3374 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
3375 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
3379 raw_printf(pArg->out, "---------------------------\n");
3384 ** Parameter azArray points to a zero-terminated array of strings. zStr
3385 ** points to a single nul-terminated string. Return non-zero if zStr
3386 ** is equal, according to strcmp(), to any of the strings in the array.
3387 ** Otherwise, return zero.
3389 static int str_in_array(const char *zStr, const char **azArray){
3391 for(i=0; azArray[i]; i++){
3392 if( 0==strcmp(zStr, azArray[i]) ) return 1;
3398 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
3399 ** and populate the ShellState.aiIndent[] array with the number of
3400 ** spaces each opcode should be indented before it is output.
3402 ** The indenting rules are:
3404 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
3405 ** all opcodes that occur between the p2 jump destination and the opcode
3406 ** itself by 2 spaces.
3408 ** * For each "Goto", if the jump destination is earlier in the program
3409 ** and ends on one of:
3410 ** Yield SeekGt SeekLt RowSetRead Rewind
3411 ** or if the P1 parameter is one instead of zero,
3412 ** then indent all opcodes between the earlier instruction
3413 ** and "Goto" by 2 spaces.
3415 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
3416 const char *zSql; /* The text of the SQL statement */
3417 const char *z; /* Used to check if this is an EXPLAIN */
3418 int *abYield = 0; /* True if op is an OP_Yield */
3419 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
3420 int iOp; /* Index of operation in p->aiIndent[] */
3422 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
3423 "NextIfOpen", "PrevIfOpen", 0 };
3424 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
3426 const char *azGoto[] = { "Goto", 0 };
3428 /* Try to figure out if this is really an EXPLAIN statement. If this
3429 ** cannot be verified, return early. */
3430 if( sqlite3_column_count(pSql)!=8 ){
3434 zSql = sqlite3_sql(pSql);
3435 if( zSql==0 ) return;
3436 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
3437 if( sqlite3_strnicmp(z, "explain", 7) ){
3442 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
3444 int iAddr = sqlite3_column_int(pSql, 0);
3445 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
3447 /* Set p2 to the P2 field of the current opcode. Then, assuming that
3448 ** p2 is an instruction address, set variable p2op to the index of that
3449 ** instruction in the aiIndent[] array. p2 and p2op may be different if
3450 ** the current instruction is part of a sub-program generated by an
3451 ** SQL trigger or foreign key. */
3452 int p2 = sqlite3_column_int(pSql, 3);
3453 int p2op = (p2 + (iOp-iAddr));
3455 /* Grow the p->aiIndent array as required */
3458 /* Do further verfication that this is explain output. Abort if
3460 static const char *explainCols[] = {
3461 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" };
3463 for(jj=0; jj<ArraySize(explainCols); jj++){
3464 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){
3466 sqlite3_reset(pSql);
3472 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
3473 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
3475 abYield[iOp] = str_in_array(zOp, azYield);
3476 p->aiIndent[iOp] = 0;
3479 if( str_in_array(zOp, azNext) ){
3480 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
3482 if( str_in_array(zOp, azGoto) && p2op<p->nIndent
3483 && (abYield[p2op] || sqlite3_column_int(pSql, 2))
3485 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
3490 sqlite3_free(abYield);
3491 sqlite3_reset(pSql);
3495 ** Free the array allocated by explain_data_prepare().
3497 static void explain_data_delete(ShellState *p){
3498 sqlite3_free(p->aiIndent);
3505 ** Disable and restore .wheretrace and .selecttrace settings.
3507 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3508 extern int sqlite3SelectTrace;
3509 static int savedSelectTrace;
3511 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
3512 extern int sqlite3WhereTrace;
3513 static int savedWhereTrace;
3515 static void disable_debug_trace_modes(void){
3516 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3517 savedSelectTrace = sqlite3SelectTrace;
3518 sqlite3SelectTrace = 0;
3520 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
3521 savedWhereTrace = sqlite3WhereTrace;
3522 sqlite3WhereTrace = 0;
3525 static void restore_debug_trace_modes(void){
3526 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3527 sqlite3SelectTrace = savedSelectTrace;
3529 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
3530 sqlite3WhereTrace = savedWhereTrace;
3535 ** Run a prepared statement
3537 static void exec_prepared_stmt(
3538 ShellState *pArg, /* Pointer to ShellState */
3539 sqlite3_stmt *pStmt, /* Statment to run */
3540 int (*xCallback)(void*,int,char**,char**,int*) /* Callback function */
3544 /* perform the first step. this will tell us if we
3545 ** have a result set or not and how wide it is.
3547 rc = sqlite3_step(pStmt);
3548 /* if we have a result set... */
3549 if( SQLITE_ROW == rc ){
3550 /* if we have a callback... */
3552 /* allocate space for col name ptr, value ptr, and type */
3553 int nCol = sqlite3_column_count(pStmt);
3554 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
3558 char **azCols = (char **)pData; /* Names of result columns */
3559 char **azVals = &azCols[nCol]; /* Results */
3560 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
3562 assert(sizeof(int) <= sizeof(char *));
3563 /* save off ptrs to column names */
3564 for(i=0; i<nCol; i++){
3565 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
3568 /* extract the data and data types */
3569 for(i=0; i<nCol; i++){
3570 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
3571 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){
3574 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
3576 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
3578 break; /* from for */
3582 /* if data and types extracted successfully... */
3583 if( SQLITE_ROW == rc ){
3584 /* call the supplied callback with the result row data */
3585 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
3588 rc = sqlite3_step(pStmt);
3591 } while( SQLITE_ROW == rc );
3592 sqlite3_free(pData);
3596 rc = sqlite3_step(pStmt);
3597 } while( rc == SQLITE_ROW );
3603 ** Execute a statement or set of statements. Print
3604 ** any result rows/columns depending on the current mode
3605 ** set via the supplied callback.
3607 ** This is very similar to SQLite's built-in sqlite3_exec()
3608 ** function except it takes a slightly different callback
3609 ** and callback data argument.
3611 static int shell_exec(
3612 sqlite3 *db, /* An open database */
3613 const char *zSql, /* SQL to be evaluated */
3614 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
3615 /* (not the same as sqlite3_exec) */
3616 ShellState *pArg, /* Pointer to ShellState */
3617 char **pzErrMsg /* Error msg written here */
3619 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
3620 int rc = SQLITE_OK; /* Return Code */
3622 const char *zLeftover; /* Tail of unprocessed SQL */
3628 while( zSql[0] && (SQLITE_OK == rc) ){
3629 static const char *zStmtSql;
3630 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
3631 if( SQLITE_OK != rc ){
3633 *pzErrMsg = save_err_msg(db);
3637 /* this happens for a comment or white-space */
3639 while( IsSpace(zSql[0]) ) zSql++;
3642 zStmtSql = sqlite3_sql(pStmt);
3643 if( zStmtSql==0 ) zStmtSql = "";
3644 while( IsSpace(zStmtSql[0]) ) zStmtSql++;
3646 /* save off the prepared statment handle and reset row count */
3648 pArg->pStmt = pStmt;
3652 /* echo the sql statement if echo on */
3653 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
3654 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
3657 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
3658 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
3659 sqlite3_stmt *pExplain;
3661 disable_debug_trace_modes();
3662 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql);
3663 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
3664 if( rc==SQLITE_OK ){
3665 while( sqlite3_step(pExplain)==SQLITE_ROW ){
3666 raw_printf(pArg->out,"--EQP-- %d,",sqlite3_column_int(pExplain, 0));
3667 raw_printf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
3668 raw_printf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
3669 utf8_printf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
3672 sqlite3_finalize(pExplain);
3674 if( pArg->autoEQP>=2 ){
3675 /* Also do an EXPLAIN for ".eqp full" mode */
3676 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql);
3677 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
3678 if( rc==SQLITE_OK ){
3679 pArg->cMode = MODE_Explain;
3680 explain_data_prepare(pArg, pExplain);
3681 exec_prepared_stmt(pArg, pExplain, xCallback);
3682 explain_data_delete(pArg);
3684 sqlite3_finalize(pExplain);
3687 restore_debug_trace_modes();
3691 pArg->cMode = pArg->mode;
3692 if( pArg->autoExplain
3693 && sqlite3_column_count(pStmt)==8
3694 && sqlite3_strlike("EXPLAIN%", zStmtSql,0)==0
3696 pArg->cMode = MODE_Explain;
3699 /* If the shell is currently in ".explain" mode, gather the extra
3700 ** data required to add indents to the output.*/
3701 if( pArg->cMode==MODE_Explain ){
3702 explain_data_prepare(pArg, pStmt);
3706 exec_prepared_stmt(pArg, pStmt, xCallback);
3707 explain_data_delete(pArg);
3709 /* print usage stats if stats on */
3710 if( pArg && pArg->statsOn ){
3711 display_stats(db, pArg, 0);
3714 /* print loop-counters if required */
3715 if( pArg && pArg->scanstatsOn ){
3716 display_scanstats(db, pArg);
3719 /* Finalize the statement just executed. If this fails, save a
3720 ** copy of the error message. Otherwise, set zSql to point to the
3721 ** next statement to execute. */
3722 rc2 = sqlite3_finalize(pStmt);
3723 if( rc!=SQLITE_NOMEM ) rc = rc2;
3724 if( rc==SQLITE_OK ){
3726 while( IsSpace(zSql[0]) ) zSql++;
3727 }else if( pzErrMsg ){
3728 *pzErrMsg = save_err_msg(db);
3731 /* clear saved stmt handle */
3742 ** Release memory previously allocated by tableColumnList().
3744 static void freeColumnList(char **azCol){
3746 for(i=1; azCol[i]; i++){
3747 sqlite3_free(azCol[i]);
3749 /* azCol[0] is a static string */
3750 sqlite3_free(azCol);
3754 ** Return a list of pointers to strings which are the names of all
3755 ** columns in table zTab. The memory to hold the names is dynamically
3756 ** allocated and must be released by the caller using a subsequent call
3757 ** to freeColumnList().
3759 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
3760 ** value that needs to be preserved, then azCol[0] is filled in with the
3761 ** name of the rowid column.
3763 ** The first regular column in the table is azCol[1]. The list is terminated
3764 ** by an entry with azCol[i]==0.
3766 static char **tableColumnList(ShellState *p, const char *zTab){
3768 sqlite3_stmt *pStmt;
3772 int nPK = 0; /* Number of PRIMARY KEY columns seen */
3773 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
3774 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
3777 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
3778 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3781 while( sqlite3_step(pStmt)==SQLITE_ROW ){
3782 if( nCol>=nAlloc-2 ){
3783 nAlloc = nAlloc*2 + nCol + 10;
3784 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
3786 raw_printf(stderr, "Error: out of memory\n");
3790 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
3791 if( sqlite3_column_int(pStmt, 5) ){
3794 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
3803 sqlite3_finalize(pStmt);
3804 if( azCol==0 ) return 0;
3808 /* The decision of whether or not a rowid really needs to be preserved
3809 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
3810 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
3811 ** rowids on tables where the rowid is inaccessible because there are other
3812 ** columns in the table named "rowid", "_rowid_", and "oid".
3814 if( preserveRowid && isIPK ){
3815 /* If a single PRIMARY KEY column with type INTEGER was seen, then it
3816 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
3817 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
3818 ** ROWID aliases. To distinguish these cases, check to see if
3819 ** there is a "pk" entry in "PRAGMA index_list". There will be
3820 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
3822 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
3823 " WHERE origin='pk'", zTab);
3824 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3827 freeColumnList(azCol);
3830 rc = sqlite3_step(pStmt);
3831 sqlite3_finalize(pStmt);
3832 preserveRowid = rc==SQLITE_ROW;
3834 if( preserveRowid ){
3835 /* Only preserve the rowid if we can find a name to use for the
3837 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
3840 for(i=1; i<=nCol; i++){
3841 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
3844 /* At this point, we know that azRowid[j] is not the name of any
3845 ** ordinary column in the table. Verify that azRowid[j] is a valid
3846 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
3847 ** tables will fail this last check */
3848 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
3849 if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
3858 ** Toggle the reverse_unordered_selects setting.
3860 static void toggleSelectOrder(sqlite3 *db){
3861 sqlite3_stmt *pStmt = 0;
3864 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
3865 if( sqlite3_step(pStmt)==SQLITE_ROW ){
3866 iSetting = sqlite3_column_int(pStmt, 0);
3868 sqlite3_finalize(pStmt);
3869 sqlite3_snprintf(sizeof(zStmt), zStmt,
3870 "PRAGMA reverse_unordered_selects(%d)", !iSetting);
3871 sqlite3_exec(db, zStmt, 0, 0, 0);
3875 ** This is a different callback routine used for dumping the database.
3876 ** Each row received by this callback consists of a table name,
3877 ** the table type ("index" or "table") and SQL to create the table.
3878 ** This routine should print text sufficient to recreate the table.
3880 static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
3885 ShellState *p = (ShellState *)pArg;
3887 UNUSED_PARAMETER(azNotUsed);
3888 if( nArg!=3 || azArg==0 ) return 0;
3893 if( strcmp(zTable, "sqlite_sequence")==0 ){
3894 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
3895 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
3896 raw_printf(p->out, "ANALYZE sqlite_master;\n");
3897 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
3899 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
3901 if( !p->writableSchema ){
3902 raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
3903 p->writableSchema = 1;
3905 zIns = sqlite3_mprintf(
3906 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
3907 "VALUES('table','%q','%q',0,'%q');",
3908 zTable, zTable, zSql);
3909 utf8_printf(p->out, "%s\n", zIns);
3913 printSchemaLine(p->out, zSql, ";\n");
3916 if( strcmp(zType, "table")==0 ){
3921 char *savedDestTable;
3924 azCol = tableColumnList(p, zTable);
3930 /* Always quote the table name, even if it appears to be pure ascii,
3931 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
3933 appendText(&sTable, zTable, quoteChar(zTable));
3934 /* If preserving the rowid, add a column list after the table name.
3935 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
3936 ** instead of the usual "INSERT INTO tab VALUES(...)".
3939 appendText(&sTable, "(", 0);
3940 appendText(&sTable, azCol[0], 0);
3941 for(i=1; azCol[i]; i++){
3942 appendText(&sTable, ",", 0);
3943 appendText(&sTable, azCol[i], quoteChar(azCol[i]));
3945 appendText(&sTable, ")", 0);
3948 /* Build an appropriate SELECT statement */
3950 appendText(&sSelect, "SELECT ", 0);
3952 appendText(&sSelect, azCol[0], 0);
3953 appendText(&sSelect, ",", 0);
3955 for(i=1; azCol[i]; i++){
3956 appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
3958 appendText(&sSelect, ",", 0);
3961 freeColumnList(azCol);
3962 appendText(&sSelect, " FROM ", 0);
3963 appendText(&sSelect, zTable, quoteChar(zTable));
3965 savedDestTable = p->zDestTable;
3966 savedMode = p->mode;
3967 p->zDestTable = sTable.z;
3968 p->mode = p->cMode = MODE_Insert;
3969 rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3970 if( (rc&0xff)==SQLITE_CORRUPT ){
3971 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
3972 toggleSelectOrder(p->db);
3973 shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3974 toggleSelectOrder(p->db);
3976 p->zDestTable = savedDestTable;
3977 p->mode = savedMode;
3986 ** Run zQuery. Use dump_callback() as the callback routine so that
3987 ** the contents of the query are output as SQL statements.
3989 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
3990 ** "ORDER BY rowid DESC" to the end.
3992 static int run_schema_dump_query(
3998 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
3999 if( rc==SQLITE_CORRUPT ){
4001 int len = strlen30(zQuery);
4002 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
4004 utf8_printf(p->out, "/****** %s ******/\n", zErr);
4008 zQ2 = malloc( len+100 );
4009 if( zQ2==0 ) return rc;
4010 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
4011 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
4013 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr);
4015 rc = SQLITE_CORRUPT;
4024 ** Text of a help message
4026 static char zHelp[] =
4027 #ifndef SQLITE_OMIT_AUTHORIZATION
4028 ".auth ON|OFF Show authorizer callbacks\n"
4030 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
4031 ".bail on|off Stop after hitting an error. Default OFF\n"
4032 ".binary on|off Turn binary output on or off. Default OFF\n"
4033 ".cd DIRECTORY Change the working directory to DIRECTORY\n"
4034 ".changes on|off Show number of rows changed by SQL\n"
4035 ".check GLOB Fail if output since .testcase does not match\n"
4036 ".clone NEWDB Clone data into NEWDB from the existing database\n"
4037 ".databases List names and files of attached databases\n"
4038 ".dbinfo ?DB? Show status information about the database\n"
4039 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
4040 " If TABLE specified, only dump tables matching\n"
4041 " LIKE pattern TABLE.\n"
4042 ".echo on|off Turn command echo on or off\n"
4043 ".eqp on|off|full Enable or disable automatic EXPLAIN QUERY PLAN\n"
4044 ".exit Exit this program\n"
4045 /* Because explain mode comes on automatically now, the ".explain" mode
4046 ** is removed from the help screen. It is still supported for legacy, however */
4047 /*".explain ?on|off|auto? Turn EXPLAIN output mode on or off or to automatic\n"*/
4048 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables\n"
4049 ".headers on|off Turn display of headers on or off\n"
4050 ".help Show this message\n"
4051 ".import FILE TABLE Import data from FILE into TABLE\n"
4052 #ifndef SQLITE_OMIT_TEST_CONTROL
4053 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX\n"
4055 ".indexes ?TABLE? Show names of all indexes\n"
4056 " If TABLE specified, only show indexes for tables\n"
4057 " matching LIKE pattern TABLE.\n"
4058 #ifdef SQLITE_ENABLE_IOTRACE
4059 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
4061 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT\n"
4062 ".lint OPTIONS Report potential schema issues. Options:\n"
4063 " fkey-indexes Find missing foreign key indexes\n"
4064 #ifndef SQLITE_OMIT_LOAD_EXTENSION
4065 ".load FILE ?ENTRY? Load an extension library\n"
4067 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
4068 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
4069 " ascii Columns/rows delimited by 0x1F and 0x1E\n"
4070 " csv Comma-separated values\n"
4071 " column Left-aligned columns. (See .width)\n"
4072 " html HTML <table> code\n"
4073 " insert SQL insert statements for TABLE\n"
4074 " line One value per line\n"
4075 " list Values delimited by \"|\"\n"
4076 " quote Escape answers as for SQL\n"
4077 " tabs Tab-separated values\n"
4078 " tcl TCL list elements\n"
4079 ".nullvalue STRING Use STRING in place of NULL values\n"
4080 ".once FILENAME Output for the next SQL command only to FILENAME\n"
4081 ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE\n"
4082 " The --new option starts with an empty file\n"
4083 ".output ?FILENAME? Send output to FILENAME or stdout\n"
4084 ".print STRING... Print literal STRING\n"
4085 ".prompt MAIN CONTINUE Replace the standard prompts\n"
4086 ".quit Exit this program\n"
4087 ".read FILENAME Execute SQL in FILENAME\n"
4088 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
4089 ".save FILE Write in-memory database into FILE\n"
4090 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
4091 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
4092 " Add --indent for pretty-printing\n"
4093 ".selftest ?--init? Run tests defined in the SELFTEST table\n"
4094 ".separator COL ?ROW? Change the column separator and optionally the row\n"
4095 " separator for both the output mode and .import\n"
4096 #if defined(SQLITE_ENABLE_SESSION)
4097 ".session CMD ... Create or control sessions\n"
4099 ".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
4100 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
4101 ".show Show the current values for various settings\n"
4102 ".stats ?on|off? Show stats or turn stats on or off\n"
4103 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
4104 ".tables ?TABLE? List names of tables\n"
4105 " If TABLE specified, only list tables matching\n"
4106 " LIKE pattern TABLE.\n"
4107 ".testcase NAME Begin redirecting output to 'testcase-out.txt'\n"
4108 ".timeout MS Try opening locked tables for MS milliseconds\n"
4109 ".timer on|off Turn SQL timer on or off\n"
4110 ".trace FILE|off Output each SQL statement as it is run\n"
4111 ".vfsinfo ?AUX? Information about the top-level VFS\n"
4112 ".vfslist List all available VFSes\n"
4113 ".vfsname ?AUX? Print the name of the VFS stack\n"
4114 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
4115 " Negative values right-justify\n"
4118 #if defined(SQLITE_ENABLE_SESSION)
4120 ** Print help information for the ".sessions" command
4122 void session_help(ShellState *p){
4124 ".session ?NAME? SUBCOMMAND ?ARGS...?\n"
4125 "If ?NAME? is omitted, the first defined session is used.\n"
4127 " attach TABLE Attach TABLE\n"
4128 " changeset FILE Write a changeset into FILE\n"
4129 " close Close one session\n"
4130 " enable ?BOOLEAN? Set or query the enable bit\n"
4131 " filter GLOB... Reject tables matching GLOBs\n"
4132 " indirect ?BOOLEAN? Mark or query the indirect status\n"
4133 " isempty Query whether the session is empty\n"
4134 " list List currently open session names\n"
4135 " open DB NAME Open a new session on DB\n"
4136 " patchset FILE Write a patchset into FILE\n"
4142 /* Forward reference */
4143 static int process_input(ShellState *p, FILE *in);
4146 ** Read the content of file zName into memory obtained from sqlite3_malloc64()
4147 ** and return a pointer to the buffer. The caller is responsible for freeing
4150 ** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes
4153 ** For convenience, a nul-terminator byte is always appended to the data read
4154 ** from the file before the buffer is returned. This byte is not included in
4155 ** the final value of (*pnByte), if applicable.
4157 ** NULL is returned if any error is encountered. The final value of *pnByte
4158 ** is undefined in this case.
4160 static char *readFile(const char *zName, int *pnByte){
4161 FILE *in = fopen(zName, "rb");
4165 if( in==0 ) return 0;
4166 fseek(in, 0, SEEK_END);
4169 pBuf = sqlite3_malloc64( nIn+1 );
4170 if( pBuf==0 ) return 0;
4171 nRead = fread(pBuf, nIn, 1, in);
4178 if( pnByte ) *pnByte = nIn;
4182 #if defined(SQLITE_ENABLE_SESSION)
4184 ** Close a single OpenSession object and release all of its associated
4187 static void session_close(OpenSession *pSession){
4189 sqlite3session_delete(pSession->p);
4190 sqlite3_free(pSession->zName);
4191 for(i=0; i<pSession->nFilter; i++){
4192 sqlite3_free(pSession->azFilter[i]);
4194 sqlite3_free(pSession->azFilter);
4195 memset(pSession, 0, sizeof(OpenSession));
4200 ** Close all OpenSession objects and release all associated resources.
4202 #if defined(SQLITE_ENABLE_SESSION)
4203 static void session_close_all(ShellState *p){
4205 for(i=0; i<p->nSession; i++){
4206 session_close(&p->aSession[i]);
4211 # define session_close_all(X)
4215 ** Implementation of the xFilter function for an open session. Omit
4216 ** any tables named by ".session filter" but let all other table through.
4218 #if defined(SQLITE_ENABLE_SESSION)
4219 static int session_filter(void *pCtx, const char *zTab){
4220 OpenSession *pSession = (OpenSession*)pCtx;
4222 for(i=0; i<pSession->nFilter; i++){
4223 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0;
4230 ** Make sure the database is open. If it is not, then open it. If
4231 ** the database fails to open, print an error message and exit.
4233 static void open_db(ShellState *p, int keepAlive){
4235 sqlite3_initialize();
4236 sqlite3_open(p->zDbFilename, &p->db);
4238 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
4239 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
4240 p->zDbFilename, sqlite3_errmsg(p->db));
4241 if( keepAlive ) return;
4244 #ifndef SQLITE_OMIT_LOAD_EXTENSION
4245 sqlite3_enable_load_extension(p->db, 1);
4247 sqlite3_fileio_init(p->db, 0, 0);
4248 sqlite3_shathree_init(p->db, 0, 0);
4249 sqlite3_completion_init(p->db, 0, 0);
4250 sqlite3_create_function(p->db, "shell_add_schema", 2, SQLITE_UTF8, 0,
4251 shellAddSchemaName, 0, 0);
4255 #if HAVE_READLINE || HAVE_EDITLINE
4257 ** Readline completion callbacks
4259 static char *readline_completion_generator(const char *text, int state){
4260 static sqlite3_stmt *pStmt = 0;
4264 sqlite3_finalize(pStmt);
4265 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
4266 " FROM completion(%Q) ORDER BY 1", text);
4267 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
4270 if( sqlite3_step(pStmt)==SQLITE_ROW ){
4271 zRet = strdup((const char*)sqlite3_column_text(pStmt, 0));
4273 sqlite3_finalize(pStmt);
4279 static char **readline_completion(const char *zText, int iStart, int iEnd){
4280 rl_attempted_completion_over = 1;
4281 return rl_completion_matches(zText, readline_completion_generator);
4284 #elif HAVE_LINENOISE
4286 ** Linenoise completion callback
4288 static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){
4289 int nLine = (int)strlen(zLine);
4291 sqlite3_stmt *pStmt = 0;
4295 if( nLine>sizeof(zBuf)-30 ) return;
4296 if( zLine[0]=='.' ) return;
4297 for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){}
4298 if( i==nLine-1 ) return;
4300 memcpy(zBuf, zLine, iStart);
4301 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
4302 " FROM completion(%Q,%Q) ORDER BY 1",
4303 &zLine[iStart], zLine);
4304 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
4306 sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */
4307 while( sqlite3_step(pStmt)==SQLITE_ROW ){
4308 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0);
4309 int nCompletion = sqlite3_column_bytes(pStmt, 0);
4310 if( iStart+nCompletion < sizeof(zBuf)-1 ){
4311 memcpy(zBuf+iStart, zCompletion, nCompletion+1);
4312 linenoiseAddCompletion(lc, zBuf);
4315 sqlite3_finalize(pStmt);
4320 ** Do C-language style dequoting.
4326 ** \v -> vertical tab
4328 ** \r -> carriage return
4333 ** \NNN -> ascii character NNN in octal
4335 static void resolve_backslashes(char *z){
4338 while( *z && *z!='\\' ) z++;
4339 for(i=j=0; (c = z[i])!=0; i++, j++){
4340 if( c=='\\' && z[i+1]!=0 ){
4358 }else if( c=='\'' ){
4360 }else if( c=='\\' ){
4362 }else if( c>='0' && c<='7' ){
4364 if( z[i+1]>='0' && z[i+1]<='7' ){
4366 c = (c<<3) + z[i] - '0';
4367 if( z[i+1]>='0' && z[i+1]<='7' ){
4369 c = (c<<3) + z[i] - '0';
4380 ** Return the value of a hexadecimal digit. Return -1 if the input
4381 ** is not a hex digit.
4383 static int hexDigitValue(char c){
4384 if( c>='0' && c<='9' ) return c - '0';
4385 if( c>='a' && c<='f' ) return c - 'a' + 10;
4386 if( c>='A' && c<='F' ) return c - 'A' + 10;
4391 ** Interpret zArg as an integer value, possibly with suffixes.
4393 static sqlite3_int64 integerValue(const char *zArg){
4394 sqlite3_int64 v = 0;
4395 static const struct { char *zSuffix; int iMult; } aMult[] = {
4397 { "MiB", 1024*1024 },
4398 { "GiB", 1024*1024*1024 },
4401 { "GB", 1000000000 },
4404 { "G", 1000000000 },
4411 }else if( zArg[0]=='+' ){
4414 if( zArg[0]=='0' && zArg[1]=='x' ){
4417 while( (x = hexDigitValue(zArg[0]))>=0 ){
4422 while( IsDigit(zArg[0]) ){
4423 v = v*10 + zArg[0] - '0';
4427 for(i=0; i<ArraySize(aMult); i++){
4428 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
4429 v *= aMult[i].iMult;
4433 return isNeg? -v : v;
4437 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
4438 ** for TRUE and FALSE. Return the integer value if appropriate.
4440 static int booleanValue(const char *zArg){
4442 if( zArg[0]=='0' && zArg[1]=='x' ){
4443 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
4445 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
4447 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
4448 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
4451 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
4454 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
4460 ** Set or clear a shell flag according to a boolean value.
4462 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
4463 if( booleanValue(zArg) ){
4464 ShellSetFlag(p, mFlag);
4466 ShellClearFlag(p, mFlag);
4471 ** Close an output file, assuming it is not stderr or stdout
4473 static void output_file_close(FILE *f){
4474 if( f && f!=stdout && f!=stderr ) fclose(f);
4478 ** Try to open an output file. The names "stdout" and "stderr" are
4479 ** recognized and do the right thing. NULL is returned if the output
4480 ** filename is "off".
4482 static FILE *output_file_open(const char *zFile){
4484 if( strcmp(zFile,"stdout")==0 ){
4486 }else if( strcmp(zFile, "stderr")==0 ){
4488 }else if( strcmp(zFile, "off")==0 ){
4491 f = fopen(zFile, "wb");
4493 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
4499 #if !defined(SQLITE_UNTESTABLE)
4500 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
4502 ** A routine for handling output from sqlite3_trace().
4504 static int sql_trace_callback(
4510 FILE *f = (FILE*)pArg;
4511 UNUSED_PARAMETER(mType);
4512 UNUSED_PARAMETER(pP);
4514 const char *z = (const char*)pX;
4515 int i = (int)strlen(z);
4516 while( i>0 && z[i-1]==';' ){ i--; }
4517 utf8_printf(f, "%.*s;\n", i, z);
4525 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
4526 ** a useful spot to set a debugger breakpoint.
4528 static void test_breakpoint(void){
4529 static int nCall = 0;
4534 ** An object used to read a CSV and other files for import.
4536 typedef struct ImportCtx ImportCtx;
4538 const char *zFile; /* Name of the input file */
4539 FILE *in; /* Read the CSV text from this input stream */
4540 char *z; /* Accumulated text for a field */
4541 int n; /* Number of bytes in z */
4542 int nAlloc; /* Space allocated for z[] */
4543 int nLine; /* Current line number */
4544 int bNotFirst; /* True if one or more bytes already read */
4545 int cTerm; /* Character that terminated the most recent field */
4546 int cColSep; /* The column separator character. (Usually ",") */
4547 int cRowSep; /* The row separator character. (Usually "\n") */
4550 /* Append a single byte to z[] */
4551 static void import_append_char(ImportCtx *p, int c){
4552 if( p->n+1>=p->nAlloc ){
4553 p->nAlloc += p->nAlloc + 100;
4554 p->z = sqlite3_realloc64(p->z, p->nAlloc);
4556 raw_printf(stderr, "out of memory\n");
4560 p->z[p->n++] = (char)c;
4563 /* Read a single field of CSV text. Compatible with rfc4180 and extended
4564 ** with the option of having a separator other than ",".
4566 ** + Input comes from p->in.
4567 ** + Store results in p->z of length p->n. Space to hold p->z comes
4568 ** from sqlite3_malloc64().
4569 ** + Use p->cSep as the column separator. The default is ",".
4570 ** + Use p->rSep as the row separator. The default is "\n".
4571 ** + Keep track of the line number in p->nLine.
4572 ** + Store the character that terminates the field in p->cTerm. Store
4573 ** EOF on end-of-file.
4574 ** + Report syntax errors on stderr
4576 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
4578 int cSep = p->cColSep;
4579 int rSep = p->cRowSep;
4582 if( c==EOF || seenInterrupt ){
4588 int startLine = p->nLine;
4593 if( c==rSep ) p->nLine++;
4600 if( (c==cSep && pc==cQuote)
4601 || (c==rSep && pc==cQuote)
4602 || (c==rSep && pc=='\r' && ppc==cQuote)
4603 || (c==EOF && pc==cQuote)
4605 do{ p->n--; }while( p->z[p->n]!=cQuote );
4609 if( pc==cQuote && c!='\r' ){
4610 utf8_printf(stderr, "%s:%d: unescaped %c character\n",
4611 p->zFile, p->nLine, cQuote);
4614 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
4615 p->zFile, startLine, cQuote);
4619 import_append_char(p, c);
4624 /* If this is the first field being parsed and it begins with the
4625 ** UTF-8 BOM (0xEF BB BF) then skip the BOM */
4626 if( (c&0xff)==0xef && p->bNotFirst==0 ){
4627 import_append_char(p, c);
4629 if( (c&0xff)==0xbb ){
4630 import_append_char(p, c);
4632 if( (c&0xff)==0xbf ){
4635 return csv_read_one_field(p);
4639 while( c!=EOF && c!=cSep && c!=rSep ){
4640 import_append_char(p, c);
4645 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
4649 if( p->z ) p->z[p->n] = 0;
4654 /* Read a single field of ASCII delimited text.
4656 ** + Input comes from p->in.
4657 ** + Store results in p->z of length p->n. Space to hold p->z comes
4658 ** from sqlite3_malloc64().
4659 ** + Use p->cSep as the column separator. The default is "\x1F".
4660 ** + Use p->rSep as the row separator. The default is "\x1E".
4661 ** + Keep track of the row number in p->nLine.
4662 ** + Store the character that terminates the field in p->cTerm. Store
4663 ** EOF on end-of-file.
4664 ** + Report syntax errors on stderr
4666 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
4668 int cSep = p->cColSep;
4669 int rSep = p->cRowSep;
4672 if( c==EOF || seenInterrupt ){
4676 while( c!=EOF && c!=cSep && c!=rSep ){
4677 import_append_char(p, c);
4684 if( p->z ) p->z[p->n] = 0;
4689 ** Try to transfer data for table zTable. If an error is seen while
4690 ** moving forward, try to go backwards. The backwards movement won't
4691 ** work for WITHOUT ROWID tables.
4693 static void tryToCloneData(
4698 sqlite3_stmt *pQuery = 0;
4699 sqlite3_stmt *pInsert = 0;
4704 int nTable = (int)strlen(zTable);
4707 const int spinRate = 10000;
4709 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
4710 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
4712 utf8_printf(stderr, "Error %d: %s on [%s]\n",
4713 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
4717 n = sqlite3_column_count(pQuery);
4718 zInsert = sqlite3_malloc64(200 + nTable + n*3);
4720 raw_printf(stderr, "out of memory\n");
4723 sqlite3_snprintf(200+nTable,zInsert,
4724 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
4725 i = (int)strlen(zInsert);
4727 memcpy(zInsert+i, ",?", 2);
4730 memcpy(zInsert+i, ");", 3);
4731 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
4733 utf8_printf(stderr, "Error %d: %s on [%s]\n",
4734 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
4739 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
4741 switch( sqlite3_column_type(pQuery, i) ){
4743 sqlite3_bind_null(pInsert, i+1);
4746 case SQLITE_INTEGER: {
4747 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
4750 case SQLITE_FLOAT: {
4751 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
4755 sqlite3_bind_text(pInsert, i+1,
4756 (const char*)sqlite3_column_text(pQuery,i),
4761 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
4762 sqlite3_column_bytes(pQuery,i),
4768 rc = sqlite3_step(pInsert);
4769 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
4770 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
4771 sqlite3_errmsg(newDb));
4773 sqlite3_reset(pInsert);
4775 if( (cnt%spinRate)==0 ){
4776 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
4780 if( rc==SQLITE_DONE ) break;
4781 sqlite3_finalize(pQuery);
4782 sqlite3_free(zQuery);
4783 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
4785 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
4787 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
4790 } /* End for(k=0...) */
4793 sqlite3_finalize(pQuery);
4794 sqlite3_finalize(pInsert);
4795 sqlite3_free(zQuery);
4796 sqlite3_free(zInsert);
4801 ** Try to transfer all rows of the schema that match zWhere. For
4802 ** each row, invoke xForEach() on the object defined by that row.
4803 ** If an error is encountered while moving forward through the
4804 ** sqlite_master table, try again moving backwards.
4806 static void tryToCloneSchema(
4810 void (*xForEach)(ShellState*,sqlite3*,const char*)
4812 sqlite3_stmt *pQuery = 0;
4815 const unsigned char *zName;
4816 const unsigned char *zSql;
4819 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
4820 " WHERE %s", zWhere);
4821 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
4823 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
4824 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
4826 goto end_schema_xfer;
4828 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
4829 zName = sqlite3_column_text(pQuery, 0);
4830 zSql = sqlite3_column_text(pQuery, 1);
4831 printf("%s... ", zName); fflush(stdout);
4832 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
4834 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
4835 sqlite3_free(zErrMsg);
4839 xForEach(p, newDb, (const char*)zName);
4843 if( rc!=SQLITE_DONE ){
4844 sqlite3_finalize(pQuery);
4845 sqlite3_free(zQuery);
4846 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
4847 " WHERE %s ORDER BY rowid DESC", zWhere);
4848 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
4850 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
4851 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
4853 goto end_schema_xfer;
4855 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
4856 zName = sqlite3_column_text(pQuery, 0);
4857 zSql = sqlite3_column_text(pQuery, 1);
4858 printf("%s... ", zName); fflush(stdout);
4859 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
4861 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
4862 sqlite3_free(zErrMsg);
4866 xForEach(p, newDb, (const char*)zName);
4872 sqlite3_finalize(pQuery);
4873 sqlite3_free(zQuery);
4877 ** Open a new database file named "zNewDb". Try to recover as much information
4878 ** as possible out of the main database (which might be corrupt) and write it
4881 static void tryToClone(ShellState *p, const char *zNewDb){
4884 if( access(zNewDb,0)==0 ){
4885 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
4888 rc = sqlite3_open(zNewDb, &newDb);
4890 utf8_printf(stderr, "Cannot create output database: %s\n",
4891 sqlite3_errmsg(newDb));
4893 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
4894 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
4895 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
4896 tryToCloneSchema(p, newDb, "type!='table'", 0);
4897 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
4898 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
4900 sqlite3_close(newDb);
4904 ** Change the output file back to stdout
4906 static void output_reset(ShellState *p){
4907 if( p->outfile[0]=='|' ){
4908 #ifndef SQLITE_OMIT_POPEN
4912 output_file_close(p->out);
4919 ** Run an SQL command and return the single integer result.
4921 static int db_int(ShellState *p, const char *zSql){
4922 sqlite3_stmt *pStmt;
4924 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
4925 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
4926 res = sqlite3_column_int(pStmt,0);
4928 sqlite3_finalize(pStmt);
4933 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
4935 static unsigned int get2byteInt(unsigned char *a){
4936 return (a[0]<<8) + a[1];
4938 static unsigned int get4byteInt(unsigned char *a){
4939 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
4943 ** Implementation of the ".info" command.
4945 ** Return 1 on error, 2 to exit, and 0 otherwise.
4947 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
4948 static const struct { const char *zName; int ofst; } aField[] = {
4949 { "file change counter:", 24 },
4950 { "database page count:", 28 },
4951 { "freelist page count:", 36 },
4952 { "schema cookie:", 40 },
4953 { "schema format:", 44 },
4954 { "default cache size:", 48 },
4955 { "autovacuum top root:", 52 },
4956 { "incremental vacuum:", 64 },
4957 { "text encoding:", 56 },
4958 { "user version:", 60 },
4959 { "application id:", 68 },
4960 { "software version:", 96 },
4962 static const struct { const char *zName; const char *zSql; } aQuery[] = {
4963 { "number of tables:",
4964 "SELECT count(*) FROM %s WHERE type='table'" },
4965 { "number of indexes:",
4966 "SELECT count(*) FROM %s WHERE type='index'" },
4967 { "number of triggers:",
4968 "SELECT count(*) FROM %s WHERE type='trigger'" },
4969 { "number of views:",
4970 "SELECT count(*) FROM %s WHERE type='view'" },
4972 "SELECT total(length(sql)) FROM %s" },
4976 char *zDb = nArg>=2 ? azArg[1] : "main";
4977 sqlite3_stmt *pStmt = 0;
4978 unsigned char aHdr[100];
4980 if( p->db==0 ) return 1;
4981 sqlite3_prepare_v2(p->db,"SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
4983 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
4984 if( sqlite3_step(pStmt)==SQLITE_ROW
4985 && sqlite3_column_bytes(pStmt,0)>100
4987 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100);
4988 sqlite3_finalize(pStmt);
4990 raw_printf(stderr, "unable to read database header\n");
4991 sqlite3_finalize(pStmt);
4994 i = get2byteInt(aHdr+16);
4995 if( i==1 ) i = 65536;
4996 utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
4997 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
4998 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
4999 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
5000 for(i=0; i<ArraySize(aField); i++){
5001 int ofst = aField[i].ofst;
5002 unsigned int val = get4byteInt(aHdr + ofst);
5003 utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
5006 if( val==1 ) raw_printf(p->out, " (utf8)");
5007 if( val==2 ) raw_printf(p->out, " (utf16le)");
5008 if( val==3 ) raw_printf(p->out, " (utf16be)");
5011 raw_printf(p->out, "\n");
5014 zSchemaTab = sqlite3_mprintf("main.sqlite_master");
5015 }else if( strcmp(zDb,"temp")==0 ){
5016 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
5018 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
5020 for(i=0; i<ArraySize(aQuery); i++){
5021 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
5022 int val = db_int(p, zSql);
5024 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
5026 sqlite3_free(zSchemaTab);
5031 ** Print the current sqlite3_errmsg() value to stderr and return 1.
5033 static int shellDatabaseError(sqlite3 *db){
5034 const char *zErr = sqlite3_errmsg(db);
5035 utf8_printf(stderr, "Error: %s\n", zErr);
5040 ** Print an out-of-memory message to stderr and return 1.
5042 static int shellNomemError(void){
5043 raw_printf(stderr, "Error: out of memory\n");
5048 ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
5049 ** if they match and FALSE (0) if they do not match.
5053 ** '*' Matches any sequence of zero or more characters.
5055 ** '?' Matches exactly one character.
5057 ** [...] Matches one character from the enclosed list of
5060 ** [^...] Matches one character not in the enclosed list.
5062 ** '#' Matches any sequence of one or more digits with an
5063 ** optional + or - sign in front
5065 ** ' ' Any span of whitespace matches any other span of
5068 ** Extra whitespace at the end of z[] is ignored.
5070 static int testcase_glob(const char *zGlob, const char *z){
5075 while( (c = (*(zGlob++)))!=0 ){
5077 if( !IsSpace(*z) ) return 0;
5078 while( IsSpace(*zGlob) ) zGlob++;
5079 while( IsSpace(*z) ) z++;
5081 while( (c=(*(zGlob++))) == '*' || c=='?' ){
5082 if( c=='?' && (*(z++))==0 ) return 0;
5087 while( *z && testcase_glob(zGlob-1,z)==0 ){
5092 while( (c2 = (*(z++)))!=0 ){
5095 if( c2==0 ) return 0;
5097 if( testcase_glob(zGlob,z) ) return 1;
5101 if( (*(z++))==0 ) return 0;
5107 if( c==0 ) return 0;
5114 if( c==']' ) seen = 1;
5117 while( c2 && c2!=']' ){
5118 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
5120 if( c>=prior_c && c<=c2 ) seen = 1;
5130 if( c2==0 || (seen ^ invert)==0 ) return 0;
5132 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++;
5133 if( !IsDigit(z[0]) ) return 0;
5135 while( IsDigit(z[0]) ){ z++; }
5137 if( c!=(*(z++)) ) return 0;
5140 while( IsSpace(*z) ){ z++; }
5146 ** Compare the string as a command-line option with either one or two
5147 ** initial "-" characters.
5149 static int optionMatch(const char *zStr, const char *zOpt){
5150 if( zStr[0]!='-' ) return 0;
5152 if( zStr[0]=='-' ) zStr++;
5153 return strcmp(zStr, zOpt)==0;
5159 int shellDeleteFile(const char *zFilename){
5162 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename);
5166 rc = unlink(zFilename);
5173 ** The implementation of SQL scalar function fkey_collate_clause(), used
5174 ** by the ".lint fkey-indexes" command. This scalar function is always
5175 ** called with four arguments - the parent table name, the parent column name,
5176 ** the child table name and the child column name.
5178 ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col')
5180 ** If either of the named tables or columns do not exist, this function
5181 ** returns an empty string. An empty string is also returned if both tables
5182 ** and columns exist but have the same default collation sequence. Or,
5183 ** if both exist but the default collation sequences are different, this
5184 ** function returns the string " COLLATE <parent-collation>", where
5185 ** <parent-collation> is the default collation sequence of the parent column.
5187 static void shellFkeyCollateClause(
5188 sqlite3_context *pCtx,
5190 sqlite3_value **apVal
5192 sqlite3 *db = sqlite3_context_db_handle(pCtx);
5193 const char *zParent;
5194 const char *zParentCol;
5195 const char *zParentSeq;
5197 const char *zChildCol;
5198 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */
5202 zParent = (const char*)sqlite3_value_text(apVal[0]);
5203 zParentCol = (const char*)sqlite3_value_text(apVal[1]);
5204 zChild = (const char*)sqlite3_value_text(apVal[2]);
5205 zChildCol = (const char*)sqlite3_value_text(apVal[3]);
5207 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
5208 rc = sqlite3_table_column_metadata(
5209 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0
5211 if( rc==SQLITE_OK ){
5212 rc = sqlite3_table_column_metadata(
5213 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0
5217 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){
5218 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
5219 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
5226 ** The implementation of dot-command ".lint fkey-indexes".
5228 static int lintFkeyIndexes(
5229 ShellState *pState, /* Current shell tool state */
5230 char **azArg, /* Array of arguments passed to dot command */
5231 int nArg /* Number of entries in azArg[] */
5233 sqlite3 *db = pState->db; /* Database handle to query "main" db of */
5234 FILE *out = pState->out; /* Stream to write non-error output to */
5235 int bVerbose = 0; /* If -verbose is present */
5236 int bGroupByParent = 0; /* If -groupbyparent is present */
5237 int i; /* To iterate through azArg[] */
5238 const char *zIndent = ""; /* How much to indent CREATE INDEX by */
5239 int rc; /* Return code */
5240 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */
5243 ** This SELECT statement returns one row for each foreign key constraint
5244 ** in the schema of the main database. The column values are:
5246 ** 0. The text of an SQL statement similar to:
5248 ** "EXPLAIN QUERY PLAN SELECT rowid FROM child_table WHERE child_key=?"
5250 ** This is the same SELECT that the foreign keys implementation needs
5251 ** to run internally on child tables. If there is an index that can
5252 ** be used to optimize this query, then it can also be used by the FK
5253 ** implementation to optimize DELETE or UPDATE statements on the parent
5256 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
5257 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema
5258 ** contains an index that can be used to optimize the query.
5260 ** 2. Human readable text that describes the child table and columns. e.g.
5262 ** "child_table(child_key1, child_key2)"
5264 ** 3. Human readable text that describes the parent table and columns. e.g.
5266 ** "parent_table(parent_key1, parent_key2)"
5268 ** 4. A full CREATE INDEX statement for an index that could be used to
5269 ** optimize DELETE or UPDATE statements on the parent table. e.g.
5271 ** "CREATE INDEX child_table_child_key ON child_table(child_key)"
5273 ** 5. The name of the parent table.
5275 ** These six values are used by the C logic below to generate the report.
5279 " 'EXPLAIN QUERY PLAN SELECT rowid FROM ' || quote(s.name) || ' WHERE '"
5280 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
5281 " || fkey_collate_clause("
5282 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
5284 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('"
5285 " || group_concat('*=?', ' AND ') || ')'"
5287 " s.name || '(' || group_concat(f.[from], ', ') || ')'"
5289 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
5291 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
5292 " || ' ON ' || quote(s.name) || '('"
5293 " || group_concat(quote(f.[from]) ||"
5294 " fkey_collate_clause("
5295 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
5299 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f "
5300 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
5301 "GROUP BY s.name, f.id "
5302 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
5304 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)";
5306 for(i=2; i<nArg; i++){
5307 int n = (int)strlen(azArg[i]);
5308 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){
5311 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
5316 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
5319 return SQLITE_ERROR;
5323 /* Register the fkey_collate_clause() SQL function */
5324 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8,
5325 0, shellFkeyCollateClause, 0, 0
5329 if( rc==SQLITE_OK ){
5330 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
5332 if( rc==SQLITE_OK ){
5333 sqlite3_bind_int(pSql, 1, bGroupByParent);
5336 if( rc==SQLITE_OK ){
5339 while( SQLITE_ROW==sqlite3_step(pSql) ){
5341 sqlite3_stmt *pExplain = 0;
5342 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
5343 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
5344 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
5345 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
5346 const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
5347 const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
5349 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
5350 if( rc!=SQLITE_OK ) break;
5351 if( SQLITE_ROW==sqlite3_step(pExplain) ){
5352 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
5354 0==sqlite3_strglob(zGlob, zPlan)
5355 || 0==sqlite3_strglob(zGlobIPK, zPlan)
5358 rc = sqlite3_finalize(pExplain);
5359 if( rc!=SQLITE_OK ) break;
5362 raw_printf(stderr, "Error: internal error");
5366 && (bVerbose || res==0)
5367 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev))
5369 raw_printf(out, "-- Parent table %s\n", zParent);
5370 sqlite3_free(zPrev);
5371 zPrev = sqlite3_mprintf("%s", zParent);
5375 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
5376 }else if( bVerbose ){
5377 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n",
5378 zIndent, zFrom, zTarget
5383 sqlite3_free(zPrev);
5385 if( rc!=SQLITE_OK ){
5386 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
5389 rc2 = sqlite3_finalize(pSql);
5390 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
5392 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
5395 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
5402 ** Implementation of ".lint" dot command.
5404 static int lintDotCommand(
5405 ShellState *pState, /* Current shell tool state */
5406 char **azArg, /* Array of arguments passed to dot command */
5407 int nArg /* Number of entries in azArg[] */
5410 n = (nArg>=2 ? (int)strlen(azArg[1]) : 0);
5411 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
5412 return lintFkeyIndexes(pState, azArg, nArg);
5415 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]);
5416 raw_printf(stderr, "Where sub-commands are:\n");
5417 raw_printf(stderr, " fkey-indexes\n");
5418 return SQLITE_ERROR;
5423 ** If an input line begins with "." then invoke this routine to
5424 ** process that line.
5426 ** Return 1 on error, 2 to exit, and 0 otherwise.
5428 static int do_meta_command(char *zLine, ShellState *p){
5435 /* Parse the input line into tokens.
5437 while( zLine[h] && nArg<ArraySize(azArg) ){
5438 while( IsSpace(zLine[h]) ){ h++; }
5439 if( zLine[h]==0 ) break;
5440 if( zLine[h]=='\'' || zLine[h]=='"' ){
5441 int delim = zLine[h++];
5442 azArg[nArg++] = &zLine[h];
5443 while( zLine[h] && zLine[h]!=delim ){
5444 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
5447 if( zLine[h]==delim ){
5450 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
5452 azArg[nArg++] = &zLine[h];
5453 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
5454 if( zLine[h] ) zLine[h++] = 0;
5455 resolve_backslashes(azArg[nArg-1]);
5459 /* Process the input line.
5461 if( nArg==0 ) return 0; /* no tokens, no error */
5462 n = strlen30(azArg[0]);
5465 #ifndef SQLITE_OMIT_AUTHORIZATION
5466 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){
5468 raw_printf(stderr, "Usage: .auth ON|OFF\n");
5470 goto meta_command_exit;
5473 if( booleanValue(azArg[1]) ){
5474 sqlite3_set_authorizer(p->db, shellAuth, p);
5476 sqlite3_set_authorizer(p->db, 0, 0);
5481 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
5482 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
5484 const char *zDestFile = 0;
5485 const char *zDb = 0;
5487 sqlite3_backup *pBackup;
5489 for(j=1; j<nArg; j++){
5490 const char *z = azArg[j];
5492 while( z[0]=='-' ) z++;
5493 /* No options to process at this time */
5495 utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
5498 }else if( zDestFile==0 ){
5499 zDestFile = azArg[j];
5502 zDestFile = azArg[j];
5504 raw_printf(stderr, "too many arguments to .backup\n");
5509 raw_printf(stderr, "missing FILENAME argument on .backup\n");
5512 if( zDb==0 ) zDb = "main";
5513 rc = sqlite3_open(zDestFile, &pDest);
5514 if( rc!=SQLITE_OK ){
5515 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
5516 sqlite3_close(pDest);
5520 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
5522 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
5523 sqlite3_close(pDest);
5526 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
5527 sqlite3_backup_finish(pBackup);
5528 if( rc==SQLITE_DONE ){
5531 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
5534 sqlite3_close(pDest);
5537 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
5539 bail_on_error = booleanValue(azArg[1]);
5541 raw_printf(stderr, "Usage: .bail on|off\n");
5546 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
5548 if( booleanValue(azArg[1]) ){
5549 setBinaryMode(p->out, 1);
5551 setTextMode(p->out, 1);
5554 raw_printf(stderr, "Usage: .binary on|off\n");
5559 if( c=='c' && strcmp(azArg[0],"cd")==0 ){
5561 #if defined(_WIN32) || defined(WIN32)
5562 wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]);
5563 rc = !SetCurrentDirectoryW(z);
5566 rc = chdir(azArg[1]);
5569 utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]);
5573 raw_printf(stderr, "Usage: .cd DIRECTORY\n");
5578 /* The undocumented ".breakpoint" command causes a call to the no-op
5579 ** routine named test_breakpoint().
5581 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
5585 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
5587 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
5589 raw_printf(stderr, "Usage: .changes on|off\n");
5594 /* Cancel output redirection, if it is currently set (by .testcase)
5595 ** Then read the content of the testcase-out.txt file and compare against
5596 ** azArg[1]. If there are differences, report an error and exit.
5598 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){
5602 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n");
5604 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
5605 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n");
5607 }else if( testcase_glob(azArg[1],zRes)==0 ){
5609 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
5610 p->zTestcase, azArg[1], zRes);
5613 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase);
5619 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
5621 tryToClone(p, azArg[1]);
5623 raw_printf(stderr, "Usage: .clone FILENAME\n");
5628 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
5632 memcpy(&data, p, sizeof(data));
5633 data.showHeader = 0;
5634 data.cMode = data.mode = MODE_List;
5635 sqlite3_snprintf(sizeof(data.colSeparator),data.colSeparator,": ");
5637 sqlite3_exec(p->db, "SELECT name, file FROM pragma_database_list",
5638 callback, &data, &zErrMsg);
5640 utf8_printf(stderr,"Error: %s\n", zErrMsg);
5641 sqlite3_free(zErrMsg);
5646 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
5647 rc = shell_dbinfo_command(p, nArg, azArg);
5650 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
5651 const char *zLike = 0;
5653 int savedShowHeader = p->showHeader;
5654 ShellClearFlag(p, SHFLG_PreserveRowid|SHFLG_Newlines);
5655 for(i=1; i<nArg; i++){
5656 if( azArg[i][0]=='-' ){
5657 const char *z = azArg[i]+1;
5658 if( z[0]=='-' ) z++;
5659 if( strcmp(z,"preserve-rowids")==0 ){
5660 #ifdef SQLITE_OMIT_VIRTUALTABLE
5661 raw_printf(stderr, "The --preserve-rowids option is not compatible"
5662 " with SQLITE_OMIT_VIRTUALTABLE\n");
5664 goto meta_command_exit;
5666 ShellSetFlag(p, SHFLG_PreserveRowid);
5669 if( strcmp(z,"newlines")==0 ){
5670 ShellSetFlag(p, SHFLG_Newlines);
5673 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
5675 goto meta_command_exit;
5678 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? "
5679 "?--newlines? ?LIKE-PATTERN?\n");
5681 goto meta_command_exit;
5687 /* When playing back a "dump", the content might appear in an order
5688 ** which causes immediate foreign key constraints to be violated.
5689 ** So disable foreign-key constraint enforcement to prevent problems. */
5690 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
5691 raw_printf(p->out, "BEGIN TRANSACTION;\n");
5692 p->writableSchema = 0;
5694 /* Set writable_schema=ON since doing so forces SQLite to initialize
5695 ** as much of the schema as it can even if the sqlite_master table is
5697 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
5700 run_schema_dump_query(p,
5701 "SELECT name, type, sql FROM sqlite_master "
5702 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
5704 run_schema_dump_query(p,
5705 "SELECT name, type, sql FROM sqlite_master "
5706 "WHERE name=='sqlite_sequence'"
5708 run_table_dump_query(p,
5709 "SELECT sql FROM sqlite_master "
5710 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
5714 zSql = sqlite3_mprintf(
5715 "SELECT name, type, sql FROM sqlite_master "
5716 "WHERE tbl_name LIKE %Q AND type=='table'"
5717 " AND sql NOT NULL", zLike);
5718 run_schema_dump_query(p,zSql);
5720 zSql = sqlite3_mprintf(
5721 "SELECT sql FROM sqlite_master "
5722 "WHERE sql NOT NULL"
5723 " AND type IN ('index','trigger','view')"
5724 " AND tbl_name LIKE %Q", zLike);
5725 run_table_dump_query(p, zSql, 0);
5728 if( p->writableSchema ){
5729 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
5730 p->writableSchema = 0;
5732 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
5733 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
5734 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
5735 p->showHeader = savedShowHeader;
5738 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
5740 setOrClearFlag(p, SHFLG_Echo, azArg[1]);
5742 raw_printf(stderr, "Usage: .echo on|off\n");
5747 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
5749 if( strcmp(azArg[1],"full")==0 ){
5752 p->autoEQP = booleanValue(azArg[1]);
5755 raw_printf(stderr, "Usage: .eqp on|off|full\n");
5760 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
5761 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
5765 /* The ".explain" command is automatic now. It is largely pointless. It
5766 ** retained purely for backwards compatibility */
5767 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
5770 if( strcmp(azArg[1],"auto")==0 ){
5773 val = booleanValue(azArg[1]);
5776 if( val==1 && p->mode!=MODE_Explain ){
5777 p->normalMode = p->mode;
5778 p->mode = MODE_Explain;
5781 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
5783 }else if( val==99 ){
5784 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
5789 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
5793 memcpy(&data, p, sizeof(data));
5794 data.showHeader = 0;
5795 data.cMode = data.mode = MODE_Semi;
5796 if( nArg==2 && optionMatch(azArg[1], "indent") ){
5797 data.cMode = data.mode = MODE_Pretty;
5801 raw_printf(stderr, "Usage: .fullschema ?--indent?\n");
5803 goto meta_command_exit;
5806 rc = sqlite3_exec(p->db,
5808 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
5809 " FROM sqlite_master UNION ALL"
5810 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
5811 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
5813 callback, &data, &zErrMsg
5815 if( rc==SQLITE_OK ){
5816 sqlite3_stmt *pStmt;
5817 rc = sqlite3_prepare_v2(p->db,
5818 "SELECT rowid FROM sqlite_master"
5819 " WHERE name GLOB 'sqlite_stat[134]'",
5821 doStats = sqlite3_step(pStmt)==SQLITE_ROW;
5822 sqlite3_finalize(pStmt);
5825 raw_printf(p->out, "/* No STAT tables available */\n");
5827 raw_printf(p->out, "ANALYZE sqlite_master;\n");
5828 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
5829 callback, &data, &zErrMsg);
5830 data.cMode = data.mode = MODE_Insert;
5831 data.zDestTable = "sqlite_stat1";
5832 shell_exec(p->db, "SELECT * FROM sqlite_stat1",
5833 shell_callback, &data,&zErrMsg);
5834 data.zDestTable = "sqlite_stat3";
5835 shell_exec(p->db, "SELECT * FROM sqlite_stat3",
5836 shell_callback, &data,&zErrMsg);
5837 data.zDestTable = "sqlite_stat4";
5838 shell_exec(p->db, "SELECT * FROM sqlite_stat4",
5839 shell_callback, &data, &zErrMsg);
5840 raw_printf(p->out, "ANALYZE sqlite_master;\n");
5844 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
5846 p->showHeader = booleanValue(azArg[1]);
5848 raw_printf(stderr, "Usage: .headers on|off\n");
5853 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
5854 utf8_printf(p->out, "%s", zHelp);
5857 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
5858 char *zTable; /* Insert data into this table */
5859 char *zFile; /* Name of file to extra content from */
5860 sqlite3_stmt *pStmt = NULL; /* A statement */
5861 int nCol; /* Number of columns in the table */
5862 int nByte; /* Number of bytes in an SQL string */
5863 int i, j; /* Loop counters */
5864 int needCommit; /* True to COMMIT or ROLLBACK at end */
5865 int nSep; /* Number of bytes in p->colSeparator[] */
5866 char *zSql; /* An SQL statement */
5867 ImportCtx sCtx; /* Reader context */
5868 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
5869 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
5872 raw_printf(stderr, "Usage: .import FILE TABLE\n");
5873 goto meta_command_exit;
5878 memset(&sCtx, 0, sizeof(sCtx));
5880 nSep = strlen30(p->colSeparator);
5883 "Error: non-null column separator required for import\n");
5887 raw_printf(stderr, "Error: multi-character column separators not allowed"
5891 nSep = strlen30(p->rowSeparator);
5893 raw_printf(stderr, "Error: non-null row separator required for import\n");
5896 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
5897 /* When importing CSV (only), if the row separator is set to the
5898 ** default output row separator, change it to the default input
5899 ** row separator. This avoids having to maintain different input
5900 ** and output row separators. */
5901 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
5902 nSep = strlen30(p->rowSeparator);
5905 raw_printf(stderr, "Error: multi-character row separators not allowed"
5911 if( sCtx.zFile[0]=='|' ){
5912 #ifdef SQLITE_OMIT_POPEN
5913 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
5916 sCtx.in = popen(sCtx.zFile+1, "r");
5917 sCtx.zFile = "<pipe>";
5921 sCtx.in = fopen(sCtx.zFile, "rb");
5924 if( p->mode==MODE_Ascii ){
5925 xRead = ascii_read_one_field;
5927 xRead = csv_read_one_field;
5930 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
5933 sCtx.cColSep = p->colSeparator[0];
5934 sCtx.cRowSep = p->rowSeparator[0];
5935 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
5937 raw_printf(stderr, "Error: out of memory\n");
5941 nByte = strlen30(zSql);
5942 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
5943 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
5944 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
5945 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
5947 while( xRead(&sCtx) ){
5948 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z);
5950 if( sCtx.cTerm!=sCtx.cColSep ) break;
5953 sqlite3_free(zCreate);
5954 sqlite3_free(sCtx.z);
5956 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
5959 zCreate = sqlite3_mprintf("%z\n)", zCreate);
5960 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
5961 sqlite3_free(zCreate);
5963 utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
5964 sqlite3_errmsg(p->db));
5965 sqlite3_free(sCtx.z);
5969 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
5973 if (pStmt) sqlite3_finalize(pStmt);
5974 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
5978 nCol = sqlite3_column_count(pStmt);
5979 sqlite3_finalize(pStmt);
5981 if( nCol==0 ) return 0; /* no columns, no error */
5982 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
5984 raw_printf(stderr, "Error: out of memory\n");
5988 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
5990 for(i=1; i<nCol; i++){
5996 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
5999 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
6000 if (pStmt) sqlite3_finalize(pStmt);
6004 needCommit = sqlite3_get_autocommit(p->db);
6005 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
6007 int startLine = sCtx.nLine;
6008 for(i=0; i<nCol; i++){
6009 char *z = xRead(&sCtx);
6011 ** Did we reach end-of-file before finding any columns?
6012 ** If so, stop instead of NULL filling the remaining columns.
6014 if( z==0 && i==0 ) break;
6016 ** Did we reach end-of-file OR end-of-line before finding any
6017 ** columns in ASCII mode? If so, stop instead of NULL filling
6018 ** the remaining columns.
6020 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
6021 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
6022 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
6023 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
6024 "filling the rest with NULL\n",
6025 sCtx.zFile, startLine, nCol, i+1);
6027 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
6030 if( sCtx.cTerm==sCtx.cColSep ){
6034 }while( sCtx.cTerm==sCtx.cColSep );
6035 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
6037 sCtx.zFile, startLine, nCol, i);
6040 sqlite3_step(pStmt);
6041 rc = sqlite3_reset(pStmt);
6042 if( rc!=SQLITE_OK ){
6043 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
6044 startLine, sqlite3_errmsg(p->db));
6047 }while( sCtx.cTerm!=EOF );
6050 sqlite3_free(sCtx.z);
6051 sqlite3_finalize(pStmt);
6052 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
6055 #ifndef SQLITE_UNTESTABLE
6056 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){
6059 sqlite3_stmt *pStmt;
6063 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n");
6065 goto meta_command_exit;
6068 zSql = sqlite3_mprintf("SELECT rootpage FROM sqlite_master"
6069 " WHERE name='%q' AND type='index'", azArg[1]);
6070 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6072 if( sqlite3_step(pStmt)==SQLITE_ROW ){
6073 tnum = sqlite3_column_int(pStmt, 0);
6075 sqlite3_finalize(pStmt);
6077 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]);
6079 goto meta_command_exit;
6081 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]);
6082 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6085 while( sqlite3_step(pStmt)==SQLITE_ROW ){
6087 const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
6090 if( sqlite3_column_int(pStmt,1)==-1 ){
6093 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i);
6098 zCollist = sqlite3_mprintf("\"%w\"", zCol);
6100 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
6103 sqlite3_finalize(pStmt);
6104 zSql = sqlite3_mprintf(
6105 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%s))WITHOUT ROWID",
6106 azArg[2], zCollist, zCollist);
6107 sqlite3_free(zCollist);
6108 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
6109 if( rc==SQLITE_OK ){
6110 rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
6111 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
6113 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
6115 utf8_printf(stdout, "%s;\n", zSql);
6117 "WARNING: writing to an imposter table will corrupt the index!\n"
6121 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
6126 #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
6128 #ifdef SQLITE_ENABLE_IOTRACE
6129 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
6130 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
6131 if( iotrace && iotrace!=stdout ) fclose(iotrace);
6135 }else if( strcmp(azArg[1], "-")==0 ){
6136 sqlite3IoTrace = iotracePrintf;
6139 iotrace = fopen(azArg[1], "w");
6141 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
6145 sqlite3IoTrace = iotracePrintf;
6151 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
6152 static const struct {
6153 const char *zLimitName; /* Name of a limit */
6154 int limitCode; /* Integer code for that limit */
6156 { "length", SQLITE_LIMIT_LENGTH },
6157 { "sql_length", SQLITE_LIMIT_SQL_LENGTH },
6158 { "column", SQLITE_LIMIT_COLUMN },
6159 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH },
6160 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT },
6161 { "vdbe_op", SQLITE_LIMIT_VDBE_OP },
6162 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG },
6163 { "attached", SQLITE_LIMIT_ATTACHED },
6164 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
6165 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER },
6166 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH },
6167 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS },
6172 for(i=0; i<ArraySize(aLimit); i++){
6173 printf("%20s %d\n", aLimit[i].zLimitName,
6174 sqlite3_limit(p->db, aLimit[i].limitCode, -1));
6177 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
6179 goto meta_command_exit;
6182 n2 = strlen30(azArg[1]);
6183 for(i=0; i<ArraySize(aLimit); i++){
6184 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
6188 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
6190 goto meta_command_exit;
6195 utf8_printf(stderr, "unknown limit: \"%s\"\n"
6196 "enter \".limits\" with no arguments for a list.\n",
6199 goto meta_command_exit;
6202 sqlite3_limit(p->db, aLimit[iLimit].limitCode,
6203 (int)integerValue(azArg[2]));
6205 printf("%20s %d\n", aLimit[iLimit].zLimitName,
6206 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
6210 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){
6212 lintDotCommand(p, azArg, nArg);
6215 #ifndef SQLITE_OMIT_LOAD_EXTENSION
6216 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
6217 const char *zFile, *zProc;
6220 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
6222 goto meta_command_exit;
6225 zProc = nArg>=3 ? azArg[2] : 0;
6227 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
6228 if( rc!=SQLITE_OK ){
6229 utf8_printf(stderr, "Error: %s\n", zErrMsg);
6230 sqlite3_free(zErrMsg);
6236 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
6238 raw_printf(stderr, "Usage: .log FILENAME\n");
6241 const char *zFile = azArg[1];
6242 output_file_close(p->pLog);
6243 p->pLog = output_file_open(zFile);
6247 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
6248 const char *zMode = nArg>=2 ? azArg[1] : "";
6249 int n2 = (int)strlen(zMode);
6251 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
6252 p->mode = MODE_Line;
6253 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
6254 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
6255 p->mode = MODE_Column;
6256 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
6257 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
6258 p->mode = MODE_List;
6259 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column);
6260 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
6261 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
6262 p->mode = MODE_Html;
6263 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
6265 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
6266 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
6267 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
6269 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
6270 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
6271 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
6272 p->mode = MODE_List;
6273 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
6274 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
6275 p->mode = MODE_Insert;
6276 set_table_name(p, nArg>=3 ? azArg[2] : "table");
6277 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){
6278 p->mode = MODE_Quote;
6279 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
6280 p->mode = MODE_Ascii;
6281 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
6282 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
6283 }else if( nArg==1 ){
6284 raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]);
6286 raw_printf(stderr, "Error: mode should be one of: "
6287 "ascii column csv html insert line list quote tabs tcl\n");
6293 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
6295 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
6296 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
6298 raw_printf(stderr, "Usage: .nullvalue STRING\n");
6303 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
6304 char *zNewFilename; /* Name of the database file to open */
6305 int iName = 1; /* Index in azArg[] of the filename */
6306 int newFlag = 0; /* True to delete file before opening */
6307 /* Close the existing database */
6308 session_close_all(p);
6309 sqlite3_close(p->db);
6312 sqlite3_free(p->zFreeOnClose);
6313 p->zFreeOnClose = 0;
6314 /* Check for command-line arguments */
6315 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){
6316 const char *z = azArg[iName];
6317 if( optionMatch(z,"new") ){
6319 }else if( z[0]=='-' ){
6320 utf8_printf(stderr, "unknown option: %s\n", z);
6322 goto meta_command_exit;
6325 /* If a filename is specified, try to open it first */
6326 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0;
6328 if( newFlag ) shellDeleteFile(zNewFilename);
6329 p->zDbFilename = zNewFilename;
6332 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
6333 sqlite3_free(zNewFilename);
6335 p->zFreeOnClose = zNewFilename;
6339 /* As a fall-back open a TEMP database */
6346 && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
6348 const char *zFile = nArg>=2 ? azArg[1] : "stdout";
6350 utf8_printf(stderr, "Usage: .%s FILE\n", azArg[0]);
6352 goto meta_command_exit;
6354 if( n>1 && strncmp(azArg[0], "once", n)==0 ){
6356 raw_printf(stderr, "Usage: .once FILE\n");
6358 goto meta_command_exit;
6365 if( zFile[0]=='|' ){
6366 #ifdef SQLITE_OMIT_POPEN
6367 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
6371 p->out = popen(zFile + 1, "w");
6373 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
6377 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
6381 p->out = output_file_open(zFile);
6383 if( strcmp(zFile,"off")!=0 ){
6384 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
6389 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
6394 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
6396 for(i=1; i<nArg; i++){
6397 if( i>1 ) raw_printf(p->out, " ");
6398 utf8_printf(p->out, "%s", azArg[i]);
6400 raw_printf(p->out, "\n");
6403 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
6405 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
6408 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
6412 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
6416 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
6419 raw_printf(stderr, "Usage: .read FILE\n");
6421 goto meta_command_exit;
6423 alt = fopen(azArg[1], "rb");
6425 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
6428 rc = process_input(p, alt);
6433 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
6434 const char *zSrcFile;
6437 sqlite3_backup *pBackup;
6441 zSrcFile = azArg[1];
6443 }else if( nArg==3 ){
6444 zSrcFile = azArg[2];
6447 raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
6449 goto meta_command_exit;
6451 rc = sqlite3_open(zSrcFile, &pSrc);
6452 if( rc!=SQLITE_OK ){
6453 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
6454 sqlite3_close(pSrc);
6458 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
6460 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
6461 sqlite3_close(pSrc);
6464 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
6465 || rc==SQLITE_BUSY ){
6466 if( rc==SQLITE_BUSY ){
6467 if( nTimeout++ >= 3 ) break;
6471 sqlite3_backup_finish(pBackup);
6472 if( rc==SQLITE_DONE ){
6474 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
6475 raw_printf(stderr, "Error: source database is busy\n");
6478 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
6481 sqlite3_close(pSrc);
6485 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
6487 p->scanstatsOn = booleanValue(azArg[1]);
6488 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
6489 raw_printf(stderr, "Warning: .scanstats not available in this build.\n");
6492 raw_printf(stderr, "Usage: .scanstats on|off\n");
6497 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
6501 const char *zDiv = 0;
6505 memcpy(&data, p, sizeof(data));
6506 data.showHeader = 0;
6507 data.cMode = data.mode = MODE_Semi;
6509 if( nArg>=2 && optionMatch(azArg[1], "indent") ){
6510 data.cMode = data.mode = MODE_Pretty;
6512 if( nArg==2 ) azArg[1] = azArg[2];
6514 if( nArg==2 && azArg[1][0]!='-' ){
6516 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
6517 if( strcmp(azArg[1],"sqlite_master")==0 ){
6518 char *new_argv[2], *new_colv[2];
6519 new_argv[0] = "CREATE TABLE sqlite_master (\n"
6523 " rootpage integer,\n"
6527 new_colv[0] = "sql";
6529 callback(&data, 1, new_argv, new_colv);
6531 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
6532 char *new_argv[2], *new_colv[2];
6533 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
6537 " rootpage integer,\n"
6541 new_colv[0] = "sql";
6543 callback(&data, 1, new_argv, new_colv);
6548 }else if( nArg==1 ){
6551 raw_printf(stderr, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n");
6553 goto meta_command_exit;
6556 sqlite3_stmt *pStmt = 0;
6557 rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
6560 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
6561 sqlite3_finalize(pStmt);
6563 goto meta_command_exit;
6565 appendText(&sSelect, "SELECT sql FROM", 0);
6567 while( sqlite3_step(pStmt)==SQLITE_ROW ){
6568 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0);
6570 sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema);
6571 appendText(&sSelect, zDiv, 0);
6572 zDiv = " UNION ALL ";
6573 if( strcmp(zDb, "main")!=0 ){
6574 appendText(&sSelect, "SELECT shell_add_schema(sql,", 0);
6575 appendText(&sSelect, zDb, '"');
6576 appendText(&sSelect, ") AS sql, type, tbl_name, name, rowid,", 0);
6577 appendText(&sSelect, zScNum, 0);
6578 appendText(&sSelect, " AS snum, ", 0);
6579 appendText(&sSelect, zDb, '\'');
6580 appendText(&sSelect, " AS sname FROM ", 0);
6581 appendText(&sSelect, zDb, '"');
6582 appendText(&sSelect, ".sqlite_master", 0);
6584 appendText(&sSelect, "SELECT sql, type, tbl_name, name, rowid, ", 0);
6585 appendText(&sSelect, zScNum, 0);
6586 appendText(&sSelect, " AS snum, 'main' AS sname FROM sqlite_master",0);
6589 sqlite3_finalize(pStmt);
6590 appendText(&sSelect, ") WHERE ", 0);
6592 char *zQarg = sqlite3_mprintf("%Q", azArg[1]);
6593 if( strchr(azArg[1], '.') ){
6594 appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0);
6596 appendText(&sSelect, "lower(tbl_name)", 0);
6598 appendText(&sSelect, strchr(azArg[1], '*') ? " GLOB " : " LIKE ", 0);
6599 appendText(&sSelect, zQarg, 0);
6600 appendText(&sSelect, " AND ", 0);
6601 sqlite3_free(zQarg);
6603 appendText(&sSelect, "type!='meta' AND sql IS NOT NULL"
6604 " ORDER BY snum, rowid", 0);
6605 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
6609 utf8_printf(stderr,"Error: %s\n", zErrMsg);
6610 sqlite3_free(zErrMsg);
6612 }else if( rc != SQLITE_OK ){
6613 raw_printf(stderr,"Error: querying schema information\n");
6620 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
6621 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
6622 sqlite3SelectTrace = (int)integerValue(azArg[1]);
6626 #if defined(SQLITE_ENABLE_SESSION)
6627 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){
6628 OpenSession *pSession = &p->aSession[0];
6629 char **azCmd = &azArg[1];
6631 int nCmd = nArg - 1;
6633 if( nArg<=1 ) goto session_syntax_error;
6636 for(iSes=0; iSes<p->nSession; iSes++){
6637 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break;
6639 if( iSes<p->nSession ){
6640 pSession = &p->aSession[iSes];
6644 pSession = &p->aSession[0];
6649 /* .session attach TABLE
6650 ** Invoke the sqlite3session_attach() interface to attach a particular
6651 ** table so that it is never filtered.
6653 if( strcmp(azCmd[0],"attach")==0 ){
6654 if( nCmd!=2 ) goto session_syntax_error;
6655 if( pSession->p==0 ){
6657 raw_printf(stderr, "ERROR: No sessions are open\n");
6659 rc = sqlite3session_attach(pSession->p, azCmd[1]);
6661 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc);
6667 /* .session changeset FILE
6668 ** .session patchset FILE
6669 ** Write a changeset or patchset into a file. The file is overwritten.
6671 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){
6673 if( nCmd!=2 ) goto session_syntax_error;
6674 if( pSession->p==0 ) goto session_not_open;
6675 out = fopen(azCmd[1], "wb");
6677 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n", azCmd[1]);
6681 if( azCmd[0][0]=='c' ){
6682 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
6684 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
6687 printf("Error: error code %d\n", rc);
6691 && fwrite(pChng, szChng, 1, out)!=1 ){
6692 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n",
6695 sqlite3_free(pChng);
6701 ** Close the identified session
6703 if( strcmp(azCmd[0], "close")==0 ){
6704 if( nCmd!=1 ) goto session_syntax_error;
6706 session_close(pSession);
6707 p->aSession[iSes] = p->aSession[--p->nSession];
6711 /* .session enable ?BOOLEAN?
6712 ** Query or set the enable flag
6714 if( strcmp(azCmd[0], "enable")==0 ){
6716 if( nCmd>2 ) goto session_syntax_error;
6717 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
6719 ii = sqlite3session_enable(pSession->p, ii);
6720 utf8_printf(p->out, "session %s enable flag = %d\n",
6721 pSession->zName, ii);
6725 /* .session filter GLOB ....
6726 ** Set a list of GLOB patterns of table names to be excluded.
6728 if( strcmp(azCmd[0], "filter")==0 ){
6730 if( nCmd<2 ) goto session_syntax_error;
6732 for(ii=0; ii<pSession->nFilter; ii++){
6733 sqlite3_free(pSession->azFilter[ii]);
6735 sqlite3_free(pSession->azFilter);
6736 nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
6737 pSession->azFilter = sqlite3_malloc( nByte );
6738 if( pSession->azFilter==0 ){
6739 raw_printf(stderr, "Error: out or memory\n");
6742 for(ii=1; ii<nCmd; ii++){
6743 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
6745 pSession->nFilter = ii-1;
6749 /* .session indirect ?BOOLEAN?
6750 ** Query or set the indirect flag
6752 if( strcmp(azCmd[0], "indirect")==0 ){
6754 if( nCmd>2 ) goto session_syntax_error;
6755 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
6757 ii = sqlite3session_indirect(pSession->p, ii);
6758 utf8_printf(p->out, "session %s indirect flag = %d\n",
6759 pSession->zName, ii);
6764 ** Determine if the session is empty
6766 if( strcmp(azCmd[0], "isempty")==0 ){
6768 if( nCmd!=1 ) goto session_syntax_error;
6770 ii = sqlite3session_isempty(pSession->p);
6771 utf8_printf(p->out, "session %s isempty flag = %d\n",
6772 pSession->zName, ii);
6777 ** List all currently open sessions
6779 if( strcmp(azCmd[0],"list")==0 ){
6780 for(i=0; i<p->nSession; i++){
6781 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName);
6785 /* .session open DB NAME
6786 ** Open a new session called NAME on the attached database DB.
6787 ** DB is normally "main".
6789 if( strcmp(azCmd[0],"open")==0 ){
6791 if( nCmd!=3 ) goto session_syntax_error;
6793 if( zName[0]==0 ) goto session_syntax_error;
6794 for(i=0; i<p->nSession; i++){
6795 if( strcmp(p->aSession[i].zName,zName)==0 ){
6796 utf8_printf(stderr, "Session \"%s\" already exists\n", zName);
6797 goto meta_command_exit;
6800 if( p->nSession>=ArraySize(p->aSession) ){
6801 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession));
6802 goto meta_command_exit;
6804 pSession = &p->aSession[p->nSession];
6805 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
6807 raw_printf(stderr, "Cannot open session: error code=%d\n", rc);
6809 goto meta_command_exit;
6811 pSession->nFilter = 0;
6812 sqlite3session_table_filter(pSession->p, session_filter, pSession);
6814 pSession->zName = sqlite3_mprintf("%s", zName);
6816 /* If no command name matches, show a syntax error */
6817 session_syntax_error:
6823 /* Undocumented commands for internal testing. Subject to change
6824 ** without notice. */
6825 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
6826 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
6828 for(i=1; i<nArg; i++){
6829 v = booleanValue(azArg[i]);
6830 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
6833 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
6834 int i; sqlite3_int64 v;
6835 for(i=1; i<nArg; i++){
6837 v = integerValue(azArg[i]);
6838 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
6839 utf8_printf(p->out, "%s", zBuf);
6845 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
6846 int bIsInit = 0; /* True to initialize the SELFTEST table */
6847 int bVerbose = 0; /* Verbose output */
6848 int bSelftestExists; /* True if SELFTEST already exists */
6849 int i, k; /* Loop counters */
6850 int nTest = 0; /* Number of tests runs */
6851 int nErr = 0; /* Number of errors seen */
6852 ShellText str; /* Answer for a query */
6853 sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */
6856 for(i=1; i<nArg; i++){
6857 const char *z = azArg[i];
6858 if( z[0]=='-' && z[1]=='-' ) z++;
6859 if( strcmp(z,"-init")==0 ){
6862 if( strcmp(z,"-v")==0 ){
6866 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
6867 azArg[i], azArg[0]);
6868 raw_printf(stderr, "Should be one of: --init -v\n");
6870 goto meta_command_exit;
6873 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
6875 bSelftestExists = 0;
6877 bSelftestExists = 1;
6880 createSelftestTable(p);
6881 bSelftestExists = 1;
6884 appendText(&str, "x", 0);
6885 for(k=bSelftestExists; k>=0; k--){
6887 rc = sqlite3_prepare_v2(p->db,
6888 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
6891 rc = sqlite3_prepare_v2(p->db,
6892 "VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
6893 " (1,'run','PRAGMA integrity_check','ok')",
6897 raw_printf(stderr, "Error querying the selftest table\n");
6899 sqlite3_finalize(pStmt);
6900 goto meta_command_exit;
6902 for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
6903 int tno = sqlite3_column_int(pStmt, 0);
6904 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1);
6905 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2);
6906 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3);
6910 char *zQuote = sqlite3_mprintf("%q", zSql);
6911 printf("%d: %s %s\n", tno, zOp, zSql);
6912 sqlite3_free(zQuote);
6914 if( strcmp(zOp,"memo")==0 ){
6915 utf8_printf(p->out, "%s\n", zSql);
6917 if( strcmp(zOp,"run")==0 ){
6921 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
6924 utf8_printf(p->out, "Result: %s\n", str.z);
6926 if( rc || zErrMsg ){
6929 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
6930 sqlite3_free(zErrMsg);
6931 }else if( strcmp(zAns,str.z)!=0 ){
6934 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
6935 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
6940 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
6944 } /* End loop over rows of content from SELFTEST */
6945 sqlite3_finalize(pStmt);
6946 } /* End loop over k */
6948 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
6951 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
6952 if( nArg<2 || nArg>3 ){
6953 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
6957 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
6958 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
6961 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
6962 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
6966 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
6967 const char *zLike = 0; /* Which table to checksum. 0 means everything */
6968 int i; /* Loop counter */
6969 int bSchema = 0; /* Also hash the schema */
6970 int bSeparate = 0; /* Hash each table separately */
6971 int iSize = 224; /* Hash algorithm to use */
6972 int bDebug = 0; /* Only show the query that would have run */
6973 sqlite3_stmt *pStmt; /* For querying tables names */
6974 char *zSql; /* SQL to be run */
6975 char *zSep; /* Separator */
6976 ShellText sSql; /* Complete SQL for the query to run the hash */
6977 ShellText sQuery; /* Set of queries used to read all content */
6979 for(i=1; i<nArg; i++){
6980 const char *z = azArg[i];
6983 if( z[0]=='-' ) z++;
6984 if( strcmp(z,"schema")==0 ){
6987 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
6988 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
6990 iSize = atoi(&z[5]);
6992 if( strcmp(z,"debug")==0 ){
6996 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
6997 azArg[i], azArg[0]);
6998 raw_printf(stderr, "Should be one of: --schema"
6999 " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
7001 goto meta_command_exit;
7004 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
7006 goto meta_command_exit;
7010 if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
7014 zSql = "SELECT lower(name) FROM sqlite_master"
7015 " WHERE type='table' AND coalesce(rootpage,0)>1"
7016 " UNION ALL SELECT 'sqlite_master'"
7017 " ORDER BY 1 collate nocase";
7019 zSql = "SELECT lower(name) FROM sqlite_master"
7020 " WHERE type='table' AND coalesce(rootpage,0)>1"
7021 " AND name NOT LIKE 'sqlite_%'"
7022 " ORDER BY 1 collate nocase";
7024 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
7027 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
7029 while( SQLITE_ROW==sqlite3_step(pStmt) ){
7030 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
7031 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
7032 if( strncmp(zTab, "sqlite_",7)!=0 ){
7033 appendText(&sQuery,"SELECT * FROM ", 0);
7034 appendText(&sQuery,zTab,'"');
7035 appendText(&sQuery," NOT INDEXED;", 0);
7036 }else if( strcmp(zTab, "sqlite_master")==0 ){
7037 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
7038 " ORDER BY name;", 0);
7039 }else if( strcmp(zTab, "sqlite_sequence")==0 ){
7040 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
7041 " ORDER BY name;", 0);
7042 }else if( strcmp(zTab, "sqlite_stat1")==0 ){
7043 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
7044 " ORDER BY tbl,idx;", 0);
7045 }else if( strcmp(zTab, "sqlite_stat3")==0
7046 || strcmp(zTab, "sqlite_stat4")==0 ){
7047 appendText(&sQuery, "SELECT * FROM ", 0);
7048 appendText(&sQuery, zTab, 0);
7049 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
7051 appendText(&sSql, zSep, 0);
7052 appendText(&sSql, sQuery.z, '\'');
7054 appendText(&sSql, ",", 0);
7055 appendText(&sSql, zTab, '\'');
7058 sqlite3_finalize(pStmt);
7060 zSql = sqlite3_mprintf(
7062 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
7063 " FROM [sha3sum$query]",
7066 zSql = sqlite3_mprintf(
7068 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
7069 " FROM [sha3sum$query]",
7075 utf8_printf(p->out, "%s\n", zSql);
7077 shell_exec(p->db, zSql, shell_callback, p, 0);
7083 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
7088 raw_printf(stderr, "Usage: .system COMMAND\n");
7090 goto meta_command_exit;
7092 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
7093 for(i=2; i<nArg; i++){
7094 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
7099 if( x ) raw_printf(stderr, "System command returns %d\n", x);
7102 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
7103 static const char *azBool[] = { "off", "on", "full", "unk" };
7106 raw_printf(stderr, "Usage: .show\n");
7108 goto meta_command_exit;
7110 utf8_printf(p->out, "%12.12s: %s\n","echo",
7111 azBool[ShellHasFlag(p, SHFLG_Echo)]);
7112 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
7113 utf8_printf(p->out, "%12.12s: %s\n","explain",
7114 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
7115 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
7116 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
7117 utf8_printf(p->out, "%12.12s: ", "nullvalue");
7118 output_c_string(p->out, p->nullValue);
7119 raw_printf(p->out, "\n");
7120 utf8_printf(p->out,"%12.12s: %s\n","output",
7121 strlen30(p->outfile) ? p->outfile : "stdout");
7122 utf8_printf(p->out,"%12.12s: ", "colseparator");
7123 output_c_string(p->out, p->colSeparator);
7124 raw_printf(p->out, "\n");
7125 utf8_printf(p->out,"%12.12s: ", "rowseparator");
7126 output_c_string(p->out, p->rowSeparator);
7127 raw_printf(p->out, "\n");
7128 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]);
7129 utf8_printf(p->out, "%12.12s: ", "width");
7130 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
7131 raw_printf(p->out, "%d ", p->colWidth[i]);
7133 raw_printf(p->out, "\n");
7134 utf8_printf(p->out, "%12.12s: %s\n", "filename",
7135 p->zDbFilename ? p->zDbFilename : "");
7138 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
7140 p->statsOn = booleanValue(azArg[1]);
7141 }else if( nArg==1 ){
7142 display_stats(p->db, p, 0);
7144 raw_printf(stderr, "Usage: .stats ?on|off?\n");
7149 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0)
7150 || (c=='i' && (strncmp(azArg[0], "indices", n)==0
7151 || strncmp(azArg[0], "indexes", n)==0) )
7153 sqlite3_stmt *pStmt;
7160 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
7161 if( rc ) return shellDatabaseError(p->db);
7163 if( nArg>2 && c=='i' ){
7164 /* It is an historical accident that the .indexes command shows an error
7165 ** when called with the wrong number of arguments whereas the .tables
7166 ** command does not. */
7167 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
7169 goto meta_command_exit;
7171 for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
7172 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
7173 if( zDbName==0 ) continue;
7174 if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0);
7175 if( sqlite3_stricmp(zDbName, "main")==0 ){
7176 appendText(&s, "SELECT name FROM ", 0);
7178 appendText(&s, "SELECT ", 0);
7179 appendText(&s, zDbName, '\'');
7180 appendText(&s, "||'.'||name FROM ", 0);
7182 appendText(&s, zDbName, '"');
7183 appendText(&s, ".sqlite_master ", 0);
7185 appendText(&s," WHERE type IN ('table','view')"
7186 " AND name NOT LIKE 'sqlite_%'"
7187 " AND name LIKE ?1", 0);
7189 appendText(&s," WHERE type='index'"
7190 " AND tbl_name LIKE ?1", 0);
7193 rc = sqlite3_finalize(pStmt);
7194 appendText(&s, " ORDER BY 1", 0);
7195 rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0);
7197 if( rc ) return shellDatabaseError(p->db);
7199 /* Run the SQL statement prepared by the above block. Store the results
7200 ** as an array of nul-terminated strings in azResult[]. */
7204 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
7206 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
7208 while( sqlite3_step(pStmt)==SQLITE_ROW ){
7211 int n2 = nAlloc*2 + 10;
7212 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
7214 rc = shellNomemError();
7220 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
7221 if( 0==azResult[nRow] ){
7222 rc = shellNomemError();
7227 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
7228 rc = shellDatabaseError(p->db);
7231 /* Pretty-print the contents of array azResult[] to the output */
7232 if( rc==0 && nRow>0 ){
7233 int len, maxlen = 0;
7235 int nPrintCol, nPrintRow;
7236 for(i=0; i<nRow; i++){
7237 len = strlen30(azResult[i]);
7238 if( len>maxlen ) maxlen = len;
7240 nPrintCol = 80/(maxlen+2);
7241 if( nPrintCol<1 ) nPrintCol = 1;
7242 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
7243 for(i=0; i<nPrintRow; i++){
7244 for(j=i; j<nRow; j+=nPrintRow){
7245 char *zSp = j<nPrintRow ? "" : " ";
7246 utf8_printf(p->out, "%s%-*s", zSp, maxlen,
7247 azResult[j] ? azResult[j]:"");
7249 raw_printf(p->out, "\n");
7253 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
7254 sqlite3_free(azResult);
7257 /* Begin redirecting output to the file "testcase-out.txt" */
7258 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){
7260 p->out = output_file_open("testcase-out.txt");
7262 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n");
7265 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
7267 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
7271 #ifndef SQLITE_UNTESTABLE
7272 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
7273 static const struct {
7274 const char *zCtrlName; /* Name of a test-control option */
7275 int ctrlCode; /* Integer code for that option */
7277 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
7278 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
7279 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
7280 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
7281 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
7282 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
7283 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
7284 { "assert", SQLITE_TESTCTRL_ASSERT },
7285 { "always", SQLITE_TESTCTRL_ALWAYS },
7286 { "reserve", SQLITE_TESTCTRL_RESERVE },
7287 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
7288 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
7289 { "byteorder", SQLITE_TESTCTRL_BYTEORDER },
7290 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT },
7291 { "imposter", SQLITE_TESTCTRL_IMPOSTER },
7298 /* convert testctrl text option to value. allow any unique prefix
7299 ** of the option name, or a numerical value. */
7300 n2 = strlen30(azArg[1]);
7301 for(i=0; i<ArraySize(aCtrl); i++){
7302 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n2)==0 ){
7304 testctrl = aCtrl[i].ctrlCode;
7306 utf8_printf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
7312 if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
7313 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
7314 utf8_printf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
7318 /* sqlite3_test_control(int, db, int) */
7319 case SQLITE_TESTCTRL_OPTIMIZATIONS:
7320 case SQLITE_TESTCTRL_RESERVE:
7322 int opt = (int)strtol(azArg[2], 0, 0);
7323 rc2 = sqlite3_test_control(testctrl, p->db, opt);
7324 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
7326 utf8_printf(stderr,"Error: testctrl %s takes a single int option\n",
7331 /* sqlite3_test_control(int) */
7332 case SQLITE_TESTCTRL_PRNG_SAVE:
7333 case SQLITE_TESTCTRL_PRNG_RESTORE:
7334 case SQLITE_TESTCTRL_PRNG_RESET:
7335 case SQLITE_TESTCTRL_BYTEORDER:
7337 rc2 = sqlite3_test_control(testctrl);
7338 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
7340 utf8_printf(stderr,"Error: testctrl %s takes no options\n",
7345 /* sqlite3_test_control(int, uint) */
7346 case SQLITE_TESTCTRL_PENDING_BYTE:
7348 unsigned int opt = (unsigned int)integerValue(azArg[2]);
7349 rc2 = sqlite3_test_control(testctrl, opt);
7350 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
7352 utf8_printf(stderr,"Error: testctrl %s takes a single unsigned"
7353 " int option\n", azArg[1]);
7357 /* sqlite3_test_control(int, int) */
7358 case SQLITE_TESTCTRL_ASSERT:
7359 case SQLITE_TESTCTRL_ALWAYS:
7360 case SQLITE_TESTCTRL_NEVER_CORRUPT:
7362 int opt = booleanValue(azArg[2]);
7363 rc2 = sqlite3_test_control(testctrl, opt);
7364 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
7366 utf8_printf(stderr,"Error: testctrl %s takes a single int option\n",
7371 /* sqlite3_test_control(int, char *) */
7372 #ifdef SQLITE_N_KEYWORD
7373 case SQLITE_TESTCTRL_ISKEYWORD:
7375 const char *opt = azArg[2];
7376 rc2 = sqlite3_test_control(testctrl, opt);
7377 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
7380 "Error: testctrl %s takes a single char * option\n",
7386 case SQLITE_TESTCTRL_IMPOSTER:
7388 rc2 = sqlite3_test_control(testctrl, p->db,
7390 integerValue(azArg[3]),
7391 integerValue(azArg[4]));
7392 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
7394 raw_printf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
7398 case SQLITE_TESTCTRL_BITVEC_TEST:
7399 case SQLITE_TESTCTRL_FAULT_INSTALL:
7400 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
7403 "Error: CLI support for testctrl %s not implemented\n",
7409 #endif /* !defined(SQLITE_UNTESTABLE) */
7411 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
7413 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
7416 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
7418 enableTimer = booleanValue(azArg[1]);
7419 if( enableTimer && !HAS_TIMER ){
7420 raw_printf(stderr, "Error: timer not available on this system.\n");
7424 raw_printf(stderr, "Usage: .timer on|off\n");
7429 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
7432 raw_printf(stderr, "Usage: .trace FILE|off\n");
7434 goto meta_command_exit;
7436 output_file_close(p->traceOut);
7437 p->traceOut = output_file_open(azArg[1]);
7438 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
7439 if( p->traceOut==0 ){
7440 sqlite3_trace_v2(p->db, 0, 0, 0);
7442 sqlite3_trace_v2(p->db, SQLITE_TRACE_STMT, sql_trace_callback,p->traceOut);
7447 #if SQLITE_USER_AUTHENTICATION
7448 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
7450 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
7452 goto meta_command_exit;
7455 if( strcmp(azArg[1],"login")==0 ){
7457 raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
7459 goto meta_command_exit;
7461 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
7462 (int)strlen(azArg[3]));
7464 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
7467 }else if( strcmp(azArg[1],"add")==0 ){
7469 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
7471 goto meta_command_exit;
7473 rc = sqlite3_user_add(p->db, azArg[2],
7474 azArg[3], (int)strlen(azArg[3]),
7475 booleanValue(azArg[4]));
7477 raw_printf(stderr, "User-Add failed: %d\n", rc);
7480 }else if( strcmp(azArg[1],"edit")==0 ){
7482 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
7484 goto meta_command_exit;
7486 rc = sqlite3_user_change(p->db, azArg[2],
7487 azArg[3], (int)strlen(azArg[3]),
7488 booleanValue(azArg[4]));
7490 raw_printf(stderr, "User-Edit failed: %d\n", rc);
7493 }else if( strcmp(azArg[1],"delete")==0 ){
7495 raw_printf(stderr, "Usage: .user delete USER\n");
7497 goto meta_command_exit;
7499 rc = sqlite3_user_delete(p->db, azArg[2]);
7501 raw_printf(stderr, "User-Delete failed: %d\n", rc);
7505 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n");
7507 goto meta_command_exit;
7510 #endif /* SQLITE_USER_AUTHENTICATION */
7512 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
7513 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
7514 sqlite3_libversion(), sqlite3_sourceid());
7517 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){
7518 const char *zDbName = nArg==2 ? azArg[1] : "main";
7519 sqlite3_vfs *pVfs = 0;
7521 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
7523 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName);
7524 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
7525 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
7526 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
7531 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){
7533 sqlite3_vfs *pCurrent = 0;
7535 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
7537 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
7538 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName,
7539 pVfs==pCurrent ? " <--- CURRENT" : "");
7540 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
7541 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
7542 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
7544 raw_printf(p->out, "-----------------------------------\n");
7549 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
7550 const char *zDbName = nArg==2 ? azArg[1] : "main";
7553 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
7555 utf8_printf(p->out, "%s\n", zVfsName);
7556 sqlite3_free(zVfsName);
7561 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
7562 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
7563 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
7567 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
7569 assert( nArg<=ArraySize(azArg) );
7570 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
7571 p->colWidth[j-1] = (int)integerValue(azArg[j]);
7576 utf8_printf(stderr, "Error: unknown command or invalid arguments: "
7577 " \"%s\". Enter \".help\" for help\n", azArg[0]);
7584 if( p->outCount==0 ) output_reset(p);
7590 ** Return TRUE if a semicolon occurs anywhere in the first N characters
7593 static int line_contains_semicolon(const char *z, int N){
7595 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
7600 ** Test to see if a line consists entirely of whitespace.
7602 static int _all_whitespace(const char *z){
7604 if( IsSpace(z[0]) ) continue;
7605 if( *z=='/' && z[1]=='*' ){
7607 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
7608 if( *z==0 ) return 0;
7612 if( *z=='-' && z[1]=='-' ){
7614 while( *z && *z!='\n' ){ z++; }
7615 if( *z==0 ) return 1;
7624 ** Return TRUE if the line typed in is an SQL command terminator other
7625 ** than a semi-colon. The SQL Server style "go" command is understood
7626 ** as is the Oracle "/".
7628 static int line_is_command_terminator(const char *zLine){
7629 while( IsSpace(zLine[0]) ){ zLine++; };
7630 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
7631 return 1; /* Oracle */
7633 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
7634 && _all_whitespace(&zLine[2]) ){
7635 return 1; /* SQL Server */
7641 ** Return true if zSql is a complete SQL statement. Return false if it
7642 ** ends in the middle of a string literal or C-style comment.
7644 static int line_is_complete(char *zSql, int nSql){
7646 if( zSql==0 ) return 1;
7649 rc = sqlite3_complete(zSql);
7655 ** Run a single line of SQL
7657 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
7662 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
7664 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
7666 if( rc || zErrMsg ){
7668 if( in!=0 || !stdin_is_interactive ){
7669 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
7670 "Error: near line %d:", startline);
7672 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
7675 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg);
7676 sqlite3_free(zErrMsg);
7679 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
7682 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
7683 raw_printf(p->out, "changes: %3d total_changes: %d\n",
7684 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
7691 ** Read input from *in and process it. If *in==0 then input
7692 ** is interactive - the user is typing it it. Otherwise, input
7693 ** is coming from a file or device. A prompt is issued and history
7694 ** is saved only if input is interactive. An interrupt signal will
7695 ** cause this routine to exit immediately, unless input is interactive.
7697 ** Return the number of errors.
7699 static int process_input(ShellState *p, FILE *in){
7700 char *zLine = 0; /* A single input line */
7701 char *zSql = 0; /* Accumulated SQL text */
7702 int nLine; /* Length of current line */
7703 int nSql = 0; /* Bytes of zSql[] used */
7704 int nAlloc = 0; /* Allocated zSql[] space */
7705 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
7706 int rc; /* Error code */
7707 int errCnt = 0; /* Number of errors seen */
7708 int lineno = 0; /* Current line number */
7709 int startline = 0; /* Line number for start of current input */
7711 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
7713 zLine = one_input_line(in, zLine, nSql>0);
7716 if( in==0 && stdin_is_interactive ) printf("\n");
7719 if( seenInterrupt ){
7724 if( nSql==0 && _all_whitespace(zLine) ){
7725 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
7728 if( zLine && zLine[0]=='.' && nSql==0 ){
7729 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
7730 rc = do_meta_command(zLine, p);
7731 if( rc==2 ){ /* exit requested */
7738 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
7739 memcpy(zLine,";",2);
7741 nLine = strlen30(zLine);
7742 if( nSql+nLine+2>=nAlloc ){
7743 nAlloc = nSql+nLine+100;
7744 zSql = realloc(zSql, nAlloc);
7746 raw_printf(stderr, "Error: out of memory\n");
7753 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
7754 assert( nAlloc>0 && zSql!=0 );
7755 memcpy(zSql, zLine+i, nLine+1-i);
7759 zSql[nSql++] = '\n';
7760 memcpy(zSql+nSql, zLine, nLine+1);
7763 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
7764 && sqlite3_complete(zSql) ){
7765 errCnt += runOneSqlLine(p, zSql, in, startline);
7771 }else if( nSql && _all_whitespace(zSql) ){
7772 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
7776 if( nSql && !_all_whitespace(zSql) ){
7777 runOneSqlLine(p, zSql, in, startline);
7785 ** Return a pathname which is the user's home directory. A
7786 ** 0 return indicates an error of some kind.
7788 static char *find_home_dir(int clearFlag){
7789 static char *home_dir = NULL;
7795 if( home_dir ) return home_dir;
7797 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
7798 && !defined(__RTP__) && !defined(_WRS_KERNEL)
7800 struct passwd *pwent;
7801 uid_t uid = getuid();
7802 if( (pwent=getpwuid(uid)) != NULL) {
7803 home_dir = pwent->pw_dir;
7808 #if defined(_WIN32_WCE)
7809 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
7814 #if defined(_WIN32) || defined(WIN32)
7816 home_dir = getenv("USERPROFILE");
7821 home_dir = getenv("HOME");
7824 #if defined(_WIN32) || defined(WIN32)
7826 char *zDrive, *zPath;
7828 zDrive = getenv("HOMEDRIVE");
7829 zPath = getenv("HOMEPATH");
7830 if( zDrive && zPath ){
7831 n = strlen30(zDrive) + strlen30(zPath) + 1;
7832 home_dir = malloc( n );
7833 if( home_dir==0 ) return 0;
7834 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
7841 #endif /* !_WIN32_WCE */
7844 int n = strlen30(home_dir) + 1;
7845 char *z = malloc( n );
7846 if( z ) memcpy(z, home_dir, n);
7854 ** Read input from the file given by sqliterc_override. Or if that
7855 ** parameter is NULL, take input from ~/.sqliterc
7857 ** Returns the number of errors.
7859 static void process_sqliterc(
7860 ShellState *p, /* Configuration data */
7861 const char *sqliterc_override /* Name of config file. NULL to use default */
7863 char *home_dir = NULL;
7864 const char *sqliterc = sqliterc_override;
7868 if (sqliterc == NULL) {
7869 home_dir = find_home_dir(0);
7871 raw_printf(stderr, "-- warning: cannot find home directory;"
7872 " cannot read ~/.sqliterc\n");
7875 sqlite3_initialize();
7876 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
7879 in = fopen(sqliterc,"rb");
7881 if( stdin_is_interactive ){
7882 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
7884 process_input(p,in);
7891 ** Show available command line options
7893 static const char zOptions[] =
7894 " -ascii set output mode to 'ascii'\n"
7895 " -bail stop after hitting an error\n"
7896 " -batch force batch I/O\n"
7897 " -column set output mode to 'column'\n"
7898 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
7899 " -csv set output mode to 'csv'\n"
7900 " -echo print commands before execution\n"
7901 " -init FILENAME read/process named file\n"
7902 " -[no]header turn headers on or off\n"
7903 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
7904 " -heap SIZE Size of heap for memsys3 or memsys5\n"
7906 " -help show this message\n"
7907 " -html set output mode to HTML\n"
7908 " -interactive force interactive I/O\n"
7909 " -line set output mode to 'line'\n"
7910 " -list set output mode to 'list'\n"
7911 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
7912 " -mmap N default mmap size set to N\n"
7913 #ifdef SQLITE_ENABLE_MULTIPLEX
7914 " -multiplex enable the multiplexor VFS\n"
7916 " -newline SEP set output row separator. Default: '\\n'\n"
7917 " -nullvalue TEXT set text string for NULL values. Default ''\n"
7918 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
7919 " -quote set output mode to 'quote'\n"
7920 " -separator SEP set output column separator. Default: '|'\n"
7921 " -stats print memory stats before each finalize\n"
7922 " -version show SQLite version\n"
7923 " -vfs NAME use NAME as the default VFS\n"
7924 #ifdef SQLITE_ENABLE_VFSTRACE
7925 " -vfstrace enable tracing of all VFS calls\n"
7928 static void usage(int showDetail){
7930 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
7931 "FILENAME is the name of an SQLite database. A new database is created\n"
7932 "if the file does not previously exist.\n", Argv0);
7934 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
7936 raw_printf(stderr, "Use the -help option for additional information\n");
7942 ** Initialize the state information in data
7944 static void main_init(ShellState *data) {
7945 memset(data, 0, sizeof(*data));
7946 data->normalMode = data->cMode = data->mode = MODE_List;
7947 data->autoExplain = 1;
7948 memcpy(data->colSeparator,SEP_Column, 2);
7949 memcpy(data->rowSeparator,SEP_Row, 2);
7950 data->showHeader = 0;
7951 data->shellFlgs = SHFLG_Lookaside;
7952 sqlite3_config(SQLITE_CONFIG_URI, 1);
7953 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
7954 sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
7955 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
7956 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
7960 ** Output text to the console in a font that attracts extra attention.
7963 static void printBold(const char *zText){
7964 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
7965 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
7966 GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
7967 SetConsoleTextAttribute(out,
7968 FOREGROUND_RED|FOREGROUND_INTENSITY
7970 printf("%s", zText);
7971 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
7974 static void printBold(const char *zText){
7975 printf("\033[1m%s\033[0m", zText);
7980 ** Get the argument to an --option. Throw an error and die if no argument
7983 static char *cmdline_option_value(int argc, char **argv, int i){
7985 utf8_printf(stderr, "%s: Error: missing argument to %s\n",
7986 argv[0], argv[argc-1]);
7992 #ifndef SQLITE_SHELL_IS_UTF8
7993 # if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
7994 # define SQLITE_SHELL_IS_UTF8 (0)
7996 # define SQLITE_SHELL_IS_UTF8 (1)
8000 #if SQLITE_SHELL_IS_UTF8
8001 int SQLITE_CDECL main(int argc, char **argv){
8003 int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
8008 const char *zInitFile = 0;
8011 int warnInmemoryDb = 0;
8016 setBinaryMode(stdin, 0);
8017 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
8018 stdin_is_interactive = isatty(0);
8019 stdout_is_console = isatty(1);
8021 #if USE_SYSTEM_SQLITE+0!=1
8022 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
8023 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
8024 sqlite3_sourceid(), SQLITE_SOURCE_ID);
8029 #if !SQLITE_SHELL_IS_UTF8
8030 sqlite3_initialize();
8031 argv = sqlite3_malloc64(sizeof(argv[0])*argc);
8033 raw_printf(stderr, "out of memory\n");
8036 for(i=0; i<argc; i++){
8037 argv[i] = sqlite3_win32_unicode_to_utf8(wargv[i]);
8039 raw_printf(stderr, "out of memory\n");
8044 assert( argc>=1 && argv && argv[0] );
8047 /* Make sure we have a valid signal handler early, before anything
8051 signal(SIGINT, interrupt_handler);
8054 #ifdef SQLITE_SHELL_DBNAME_PROC
8056 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
8057 ** of a C-function that will provide the name of the database file. Use
8058 ** this compile-time option to embed this shell program in larger
8060 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
8061 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
8066 /* Do an initial pass through the command-line argument to locate
8067 ** the name of the database file, the name of the initialization file,
8068 ** the size of the alternative malloc heap,
8069 ** and the first command to execute.
8071 for(i=1; i<argc; i++){
8075 if( data.zDbFilename==0 ){
8076 data.zDbFilename = z;
8078 /* Excesss arguments are interpreted as SQL (or dot-commands) and
8079 ** mean that nothing is read from stdin */
8082 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
8084 raw_printf(stderr, "out of memory\n");
8090 if( z[1]=='-' ) z++;
8091 if( strcmp(z,"-separator")==0
8092 || strcmp(z,"-nullvalue")==0
8093 || strcmp(z,"-newline")==0
8094 || strcmp(z,"-cmd")==0
8096 (void)cmdline_option_value(argc, argv, ++i);
8097 }else if( strcmp(z,"-init")==0 ){
8098 zInitFile = cmdline_option_value(argc, argv, ++i);
8099 }else if( strcmp(z,"-batch")==0 ){
8100 /* Need to check for batch mode here to so we can avoid printing
8101 ** informational messages (like from process_sqliterc) before
8102 ** we do the actual processing of arguments later in a second pass.
8104 stdin_is_interactive = 0;
8105 }else if( strcmp(z,"-heap")==0 ){
8106 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
8108 sqlite3_int64 szHeap;
8110 zSize = cmdline_option_value(argc, argv, ++i);
8111 szHeap = integerValue(zSize);
8112 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
8113 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
8115 (void)cmdline_option_value(argc, argv, ++i);
8117 }else if( strcmp(z,"-pagecache")==0 ){
8119 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
8120 if( sz>70000 ) sz = 70000;
8122 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
8123 sqlite3_config(SQLITE_CONFIG_PAGECACHE,
8124 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
8125 data.shellFlgs |= SHFLG_Pagecache;
8126 }else if( strcmp(z,"-lookaside")==0 ){
8128 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
8130 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
8132 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
8133 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
8134 #ifdef SQLITE_ENABLE_VFSTRACE
8135 }else if( strcmp(z,"-vfstrace")==0 ){
8136 extern int vfstrace_register(
8137 const char *zTraceName,
8138 const char *zOldVfsName,
8139 int (*xOut)(const char*,void*),
8143 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
8145 #ifdef SQLITE_ENABLE_MULTIPLEX
8146 }else if( strcmp(z,"-multiplex")==0 ){
8147 extern int sqlite3_multiple_initialize(const char*,int);
8148 sqlite3_multiplex_initialize(0, 1);
8150 }else if( strcmp(z,"-mmap")==0 ){
8151 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
8152 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
8153 }else if( strcmp(z,"-vfs")==0 ){
8154 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
8156 sqlite3_vfs_register(pVfs, 1);
8158 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]);
8163 if( data.zDbFilename==0 ){
8164 #ifndef SQLITE_OMIT_MEMORYDB
8165 data.zDbFilename = ":memory:";
8166 warnInmemoryDb = argc==1;
8168 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
8174 /* Go ahead and open the database file if it already exists. If the
8175 ** file does not exist, delay opening it. This prevents empty database
8176 ** files from being created if a user mistypes the database name argument
8177 ** to the sqlite command-line tool.
8179 if( access(data.zDbFilename, 0)==0 ){
8183 /* Process the initialization file if there is one. If no -init option
8184 ** is given on the command line, look for a file named ~/.sqliterc and
8185 ** try to process it.
8187 process_sqliterc(&data,zInitFile);
8189 /* Make a second pass through the command-line argument and set
8190 ** options. This second pass is delayed until after the initialization
8191 ** file is processed so that the command-line arguments will override
8192 ** settings in the initialization file.
8194 for(i=1; i<argc; i++){
8196 if( z[0]!='-' ) continue;
8197 if( z[1]=='-' ){ z++; }
8198 if( strcmp(z,"-init")==0 ){
8200 }else if( strcmp(z,"-html")==0 ){
8201 data.mode = MODE_Html;
8202 }else if( strcmp(z,"-list")==0 ){
8203 data.mode = MODE_List;
8204 }else if( strcmp(z,"-quote")==0 ){
8205 data.mode = MODE_Quote;
8206 }else if( strcmp(z,"-line")==0 ){
8207 data.mode = MODE_Line;
8208 }else if( strcmp(z,"-column")==0 ){
8209 data.mode = MODE_Column;
8210 }else if( strcmp(z,"-csv")==0 ){
8211 data.mode = MODE_Csv;
8212 memcpy(data.colSeparator,",",2);
8213 }else if( strcmp(z,"-ascii")==0 ){
8214 data.mode = MODE_Ascii;
8215 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
8217 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
8219 }else if( strcmp(z,"-separator")==0 ){
8220 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
8221 "%s",cmdline_option_value(argc,argv,++i));
8222 }else if( strcmp(z,"-newline")==0 ){
8223 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
8224 "%s",cmdline_option_value(argc,argv,++i));
8225 }else if( strcmp(z,"-nullvalue")==0 ){
8226 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
8227 "%s",cmdline_option_value(argc,argv,++i));
8228 }else if( strcmp(z,"-header")==0 ){
8229 data.showHeader = 1;
8230 }else if( strcmp(z,"-noheader")==0 ){
8231 data.showHeader = 0;
8232 }else if( strcmp(z,"-echo")==0 ){
8233 ShellSetFlag(&data, SHFLG_Echo);
8234 }else if( strcmp(z,"-eqp")==0 ){
8236 }else if( strcmp(z,"-eqpfull")==0 ){
8238 }else if( strcmp(z,"-stats")==0 ){
8240 }else if( strcmp(z,"-scanstats")==0 ){
8241 data.scanstatsOn = 1;
8242 }else if( strcmp(z,"-backslash")==0 ){
8243 /* Undocumented command-line option: -backslash
8244 ** Causes C-style backslash escapes to be evaluated in SQL statements
8245 ** prior to sending the SQL into SQLite. Useful for injecting
8246 ** crazy bytes in the middle of SQL statements for testing and debugging.
8248 ShellSetFlag(&data, SHFLG_Backslash);
8249 }else if( strcmp(z,"-bail")==0 ){
8251 }else if( strcmp(z,"-version")==0 ){
8252 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
8254 }else if( strcmp(z,"-interactive")==0 ){
8255 stdin_is_interactive = 1;
8256 }else if( strcmp(z,"-batch")==0 ){
8257 stdin_is_interactive = 0;
8258 }else if( strcmp(z,"-heap")==0 ){
8260 }else if( strcmp(z,"-pagecache")==0 ){
8262 }else if( strcmp(z,"-lookaside")==0 ){
8264 }else if( strcmp(z,"-mmap")==0 ){
8266 }else if( strcmp(z,"-vfs")==0 ){
8268 #ifdef SQLITE_ENABLE_VFSTRACE
8269 }else if( strcmp(z,"-vfstrace")==0 ){
8272 #ifdef SQLITE_ENABLE_MULTIPLEX
8273 }else if( strcmp(z,"-multiplex")==0 ){
8276 }else if( strcmp(z,"-help")==0 ){
8278 }else if( strcmp(z,"-cmd")==0 ){
8279 /* Run commands that follow -cmd first and separately from commands
8280 ** that simply appear on the command-line. This seems goofy. It would
8281 ** be better if all commands ran in the order that they appear. But
8282 ** we retain the goofy behavior for historical compatibility. */
8283 if( i==argc-1 ) break;
8284 z = cmdline_option_value(argc,argv,++i);
8286 rc = do_meta_command(z, &data);
8287 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
8290 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
8292 utf8_printf(stderr,"Error: %s\n", zErrMsg);
8293 if( bail_on_error ) return rc!=0 ? rc : 1;
8295 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
8296 if( bail_on_error ) return rc;
8300 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
8301 raw_printf(stderr,"Use -help for a list of options.\n");
8304 data.cMode = data.mode;
8308 /* Run all arguments that do not begin with '-' as if they were separate
8309 ** command-line inputs, except for the argToSkip argument which contains
8310 ** the database filename.
8312 for(i=0; i<nCmd; i++){
8313 if( azCmd[i][0]=='.' ){
8314 rc = do_meta_command(azCmd[i], &data);
8315 if( rc ) return rc==2 ? 0 : rc;
8318 rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
8320 utf8_printf(stderr,"Error: %s\n", zErrMsg);
8321 return rc!=0 ? rc : 1;
8323 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
8330 /* Run commands received from standard input
8332 if( stdin_is_interactive ){
8337 "SQLite version %s %.19s\n" /*extra-version-info*/
8338 "Enter \".help\" for usage hints.\n",
8339 sqlite3_libversion(), sqlite3_sourceid()
8341 if( warnInmemoryDb ){
8342 printf("Connected to a ");
8343 printBold("transient in-memory database");
8344 printf(".\nUse \".open FILENAME\" to reopen on a "
8345 "persistent database.\n");
8347 zHome = find_home_dir(0);
8349 nHistory = strlen30(zHome) + 20;
8350 if( (zHistory = malloc(nHistory))!=0 ){
8351 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
8354 if( zHistory ){ shell_read_history(zHistory); }
8355 #if HAVE_READLINE || HAVE_EDITLINE
8356 rl_attempted_completion_function = readline_completion;
8357 #elif HAVE_LINENOISE
8358 linenoiseSetCompletionCallback(linenoise_completion);
8360 rc = process_input(&data, 0);
8362 shell_stifle_history(2000);
8363 shell_write_history(zHistory);
8367 rc = process_input(&data, stdin);
8370 set_table_name(&data, 0);
8372 session_close_all(&data);
8373 sqlite3_close(data.db);
8375 sqlite3_free(data.zFreeOnClose);
8377 #if !SQLITE_SHELL_IS_UTF8
8378 for(i=0; i<argc; i++) sqlite3_free(argv[i]);