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" },
4974 sqlite3_file
*pFile
= 0;
4977 char *zDb
= nArg
>=2 ? azArg
[1] : "main";
4978 unsigned char aHdr
[100];
4980 if( p
->db
==0 ) return 1;
4981 sqlite3_file_control(p
->db
, zDb
, SQLITE_FCNTL_FILE_POINTER
, &pFile
);
4982 if( pFile
==0 || pFile
->pMethods
==0 || pFile
->pMethods
->xRead
==0 ){
4985 i
= pFile
->pMethods
->xRead(pFile
, aHdr
, 100, 0);
4987 raw_printf(stderr
, "unable to read database header\n");
4990 i
= get2byteInt(aHdr
+16);
4991 if( i
==1 ) i
= 65536;
4992 utf8_printf(p
->out
, "%-20s %d\n", "database page size:", i
);
4993 utf8_printf(p
->out
, "%-20s %d\n", "write format:", aHdr
[18]);
4994 utf8_printf(p
->out
, "%-20s %d\n", "read format:", aHdr
[19]);
4995 utf8_printf(p
->out
, "%-20s %d\n", "reserved bytes:", aHdr
[20]);
4996 for(i
=0; i
<ArraySize(aField
); i
++){
4997 int ofst
= aField
[i
].ofst
;
4998 unsigned int val
= get4byteInt(aHdr
+ ofst
);
4999 utf8_printf(p
->out
, "%-20s %u", aField
[i
].zName
, val
);
5002 if( val
==1 ) raw_printf(p
->out
, " (utf8)");
5003 if( val
==2 ) raw_printf(p
->out
, " (utf16le)");
5004 if( val
==3 ) raw_printf(p
->out
, " (utf16be)");
5007 raw_printf(p
->out
, "\n");
5010 zSchemaTab
= sqlite3_mprintf("main.sqlite_master");
5011 }else if( strcmp(zDb
,"temp")==0 ){
5012 zSchemaTab
= sqlite3_mprintf("%s", "sqlite_temp_master");
5014 zSchemaTab
= sqlite3_mprintf("\"%w\".sqlite_master", zDb
);
5016 for(i
=0; i
<ArraySize(aQuery
); i
++){
5017 char *zSql
= sqlite3_mprintf(aQuery
[i
].zSql
, zSchemaTab
);
5018 int val
= db_int(p
, zSql
);
5020 utf8_printf(p
->out
, "%-20s %d\n", aQuery
[i
].zName
, val
);
5022 sqlite3_free(zSchemaTab
);
5027 ** Print the current sqlite3_errmsg() value to stderr and return 1.
5029 static int shellDatabaseError(sqlite3
*db
){
5030 const char *zErr
= sqlite3_errmsg(db
);
5031 utf8_printf(stderr
, "Error: %s\n", zErr
);
5036 ** Print an out-of-memory message to stderr and return 1.
5038 static int shellNomemError(void){
5039 raw_printf(stderr
, "Error: out of memory\n");
5044 ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
5045 ** if they match and FALSE (0) if they do not match.
5049 ** '*' Matches any sequence of zero or more characters.
5051 ** '?' Matches exactly one character.
5053 ** [...] Matches one character from the enclosed list of
5056 ** [^...] Matches one character not in the enclosed list.
5058 ** '#' Matches any sequence of one or more digits with an
5059 ** optional + or - sign in front
5061 ** ' ' Any span of whitespace matches any other span of
5064 ** Extra whitespace at the end of z[] is ignored.
5066 static int testcase_glob(const char *zGlob
, const char *z
){
5071 while( (c
= (*(zGlob
++)))!=0 ){
5073 if( !IsSpace(*z
) ) return 0;
5074 while( IsSpace(*zGlob
) ) zGlob
++;
5075 while( IsSpace(*z
) ) z
++;
5077 while( (c
=(*(zGlob
++))) == '*' || c
=='?' ){
5078 if( c
=='?' && (*(z
++))==0 ) return 0;
5083 while( *z
&& testcase_glob(zGlob
-1,z
)==0 ){
5088 while( (c2
= (*(z
++)))!=0 ){
5091 if( c2
==0 ) return 0;
5093 if( testcase_glob(zGlob
,z
) ) return 1;
5097 if( (*(z
++))==0 ) return 0;
5103 if( c
==0 ) return 0;
5110 if( c
==']' ) seen
= 1;
5113 while( c2
&& c2
!=']' ){
5114 if( c2
=='-' && zGlob
[0]!=']' && zGlob
[0]!=0 && prior_c
>0 ){
5116 if( c
>=prior_c
&& c
<=c2
) seen
= 1;
5126 if( c2
==0 || (seen
^ invert
)==0 ) return 0;
5128 if( (z
[0]=='-' || z
[0]=='+') && IsDigit(z
[1]) ) z
++;
5129 if( !IsDigit(z
[0]) ) return 0;
5131 while( IsDigit(z
[0]) ){ z
++; }
5133 if( c
!=(*(z
++)) ) return 0;
5136 while( IsSpace(*z
) ){ z
++; }
5142 ** Compare the string as a command-line option with either one or two
5143 ** initial "-" characters.
5145 static int optionMatch(const char *zStr
, const char *zOpt
){
5146 if( zStr
[0]!='-' ) return 0;
5148 if( zStr
[0]=='-' ) zStr
++;
5149 return strcmp(zStr
, zOpt
)==0;
5155 int shellDeleteFile(const char *zFilename
){
5158 wchar_t *z
= sqlite3_win32_utf8_to_unicode(zFilename
);
5162 rc
= unlink(zFilename
);
5169 ** The implementation of SQL scalar function fkey_collate_clause(), used
5170 ** by the ".lint fkey-indexes" command. This scalar function is always
5171 ** called with four arguments - the parent table name, the parent column name,
5172 ** the child table name and the child column name.
5174 ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col')
5176 ** If either of the named tables or columns do not exist, this function
5177 ** returns an empty string. An empty string is also returned if both tables
5178 ** and columns exist but have the same default collation sequence. Or,
5179 ** if both exist but the default collation sequences are different, this
5180 ** function returns the string " COLLATE <parent-collation>", where
5181 ** <parent-collation> is the default collation sequence of the parent column.
5183 static void shellFkeyCollateClause(
5184 sqlite3_context
*pCtx
,
5186 sqlite3_value
**apVal
5188 sqlite3
*db
= sqlite3_context_db_handle(pCtx
);
5189 const char *zParent
;
5190 const char *zParentCol
;
5191 const char *zParentSeq
;
5193 const char *zChildCol
;
5194 const char *zChildSeq
= 0; /* Initialize to avoid false-positive warning */
5198 zParent
= (const char*)sqlite3_value_text(apVal
[0]);
5199 zParentCol
= (const char*)sqlite3_value_text(apVal
[1]);
5200 zChild
= (const char*)sqlite3_value_text(apVal
[2]);
5201 zChildCol
= (const char*)sqlite3_value_text(apVal
[3]);
5203 sqlite3_result_text(pCtx
, "", -1, SQLITE_STATIC
);
5204 rc
= sqlite3_table_column_metadata(
5205 db
, "main", zParent
, zParentCol
, 0, &zParentSeq
, 0, 0, 0
5207 if( rc
==SQLITE_OK
){
5208 rc
= sqlite3_table_column_metadata(
5209 db
, "main", zChild
, zChildCol
, 0, &zChildSeq
, 0, 0, 0
5213 if( rc
==SQLITE_OK
&& sqlite3_stricmp(zParentSeq
, zChildSeq
) ){
5214 char *z
= sqlite3_mprintf(" COLLATE %s", zParentSeq
);
5215 sqlite3_result_text(pCtx
, z
, -1, SQLITE_TRANSIENT
);
5222 ** The implementation of dot-command ".lint fkey-indexes".
5224 static int lintFkeyIndexes(
5225 ShellState
*pState
, /* Current shell tool state */
5226 char **azArg
, /* Array of arguments passed to dot command */
5227 int nArg
/* Number of entries in azArg[] */
5229 sqlite3
*db
= pState
->db
; /* Database handle to query "main" db of */
5230 FILE *out
= pState
->out
; /* Stream to write non-error output to */
5231 int bVerbose
= 0; /* If -verbose is present */
5232 int bGroupByParent
= 0; /* If -groupbyparent is present */
5233 int i
; /* To iterate through azArg[] */
5234 const char *zIndent
= ""; /* How much to indent CREATE INDEX by */
5235 int rc
; /* Return code */
5236 sqlite3_stmt
*pSql
= 0; /* Compiled version of SQL statement below */
5239 ** This SELECT statement returns one row for each foreign key constraint
5240 ** in the schema of the main database. The column values are:
5242 ** 0. The text of an SQL statement similar to:
5244 ** "EXPLAIN QUERY PLAN SELECT rowid FROM child_table WHERE child_key=?"
5246 ** This is the same SELECT that the foreign keys implementation needs
5247 ** to run internally on child tables. If there is an index that can
5248 ** be used to optimize this query, then it can also be used by the FK
5249 ** implementation to optimize DELETE or UPDATE statements on the parent
5252 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
5253 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema
5254 ** contains an index that can be used to optimize the query.
5256 ** 2. Human readable text that describes the child table and columns. e.g.
5258 ** "child_table(child_key1, child_key2)"
5260 ** 3. Human readable text that describes the parent table and columns. e.g.
5262 ** "parent_table(parent_key1, parent_key2)"
5264 ** 4. A full CREATE INDEX statement for an index that could be used to
5265 ** optimize DELETE or UPDATE statements on the parent table. e.g.
5267 ** "CREATE INDEX child_table_child_key ON child_table(child_key)"
5269 ** 5. The name of the parent table.
5271 ** These six values are used by the C logic below to generate the report.
5275 " 'EXPLAIN QUERY PLAN SELECT rowid FROM ' || quote(s.name) || ' WHERE '"
5276 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
5277 " || fkey_collate_clause("
5278 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
5280 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('"
5281 " || group_concat('*=?', ' AND ') || ')'"
5283 " s.name || '(' || group_concat(f.[from], ', ') || ')'"
5285 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
5287 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
5288 " || ' ON ' || quote(s.name) || '('"
5289 " || group_concat(quote(f.[from]) ||"
5290 " fkey_collate_clause("
5291 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
5295 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f "
5296 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
5297 "GROUP BY s.name, f.id "
5298 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
5300 const char *zGlobIPK
= "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)";
5302 for(i
=2; i
<nArg
; i
++){
5303 int n
= (int)strlen(azArg
[i
]);
5304 if( n
>1 && sqlite3_strnicmp("-verbose", azArg
[i
], n
)==0 ){
5307 else if( n
>1 && sqlite3_strnicmp("-groupbyparent", azArg
[i
], n
)==0 ){
5312 raw_printf(stderr
, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
5315 return SQLITE_ERROR
;
5319 /* Register the fkey_collate_clause() SQL function */
5320 rc
= sqlite3_create_function(db
, "fkey_collate_clause", 4, SQLITE_UTF8
,
5321 0, shellFkeyCollateClause
, 0, 0
5325 if( rc
==SQLITE_OK
){
5326 rc
= sqlite3_prepare_v2(db
, zSql
, -1, &pSql
, 0);
5328 if( rc
==SQLITE_OK
){
5329 sqlite3_bind_int(pSql
, 1, bGroupByParent
);
5332 if( rc
==SQLITE_OK
){
5335 while( SQLITE_ROW
==sqlite3_step(pSql
) ){
5337 sqlite3_stmt
*pExplain
= 0;
5338 const char *zEQP
= (const char*)sqlite3_column_text(pSql
, 0);
5339 const char *zGlob
= (const char*)sqlite3_column_text(pSql
, 1);
5340 const char *zFrom
= (const char*)sqlite3_column_text(pSql
, 2);
5341 const char *zTarget
= (const char*)sqlite3_column_text(pSql
, 3);
5342 const char *zCI
= (const char*)sqlite3_column_text(pSql
, 4);
5343 const char *zParent
= (const char*)sqlite3_column_text(pSql
, 5);
5345 rc
= sqlite3_prepare_v2(db
, zEQP
, -1, &pExplain
, 0);
5346 if( rc
!=SQLITE_OK
) break;
5347 if( SQLITE_ROW
==sqlite3_step(pExplain
) ){
5348 const char *zPlan
= (const char*)sqlite3_column_text(pExplain
, 3);
5350 0==sqlite3_strglob(zGlob
, zPlan
)
5351 || 0==sqlite3_strglob(zGlobIPK
, zPlan
)
5354 rc
= sqlite3_finalize(pExplain
);
5355 if( rc
!=SQLITE_OK
) break;
5358 raw_printf(stderr
, "Error: internal error");
5362 && (bVerbose
|| res
==0)
5363 && (zPrev
==0 || sqlite3_stricmp(zParent
, zPrev
))
5365 raw_printf(out
, "-- Parent table %s\n", zParent
);
5366 sqlite3_free(zPrev
);
5367 zPrev
= sqlite3_mprintf("%s", zParent
);
5371 raw_printf(out
, "%s%s --> %s\n", zIndent
, zCI
, zTarget
);
5372 }else if( bVerbose
){
5373 raw_printf(out
, "%s/* no extra indexes required for %s -> %s */\n",
5374 zIndent
, zFrom
, zTarget
5379 sqlite3_free(zPrev
);
5381 if( rc
!=SQLITE_OK
){
5382 raw_printf(stderr
, "%s\n", sqlite3_errmsg(db
));
5385 rc2
= sqlite3_finalize(pSql
);
5386 if( rc
==SQLITE_OK
&& rc2
!=SQLITE_OK
){
5388 raw_printf(stderr
, "%s\n", sqlite3_errmsg(db
));
5391 raw_printf(stderr
, "%s\n", sqlite3_errmsg(db
));
5398 ** Implementation of ".lint" dot command.
5400 static int lintDotCommand(
5401 ShellState
*pState
, /* Current shell tool state */
5402 char **azArg
, /* Array of arguments passed to dot command */
5403 int nArg
/* Number of entries in azArg[] */
5406 n
= (nArg
>=2 ? (int)strlen(azArg
[1]) : 0);
5407 if( n
<1 || sqlite3_strnicmp(azArg
[1], "fkey-indexes", n
) ) goto usage
;
5408 return lintFkeyIndexes(pState
, azArg
, nArg
);
5411 raw_printf(stderr
, "Usage %s sub-command ?switches...?\n", azArg
[0]);
5412 raw_printf(stderr
, "Where sub-commands are:\n");
5413 raw_printf(stderr
, " fkey-indexes\n");
5414 return SQLITE_ERROR
;
5419 ** If an input line begins with "." then invoke this routine to
5420 ** process that line.
5422 ** Return 1 on error, 2 to exit, and 0 otherwise.
5424 static int do_meta_command(char *zLine
, ShellState
*p
){
5431 /* Parse the input line into tokens.
5433 while( zLine
[h
] && nArg
<ArraySize(azArg
) ){
5434 while( IsSpace(zLine
[h
]) ){ h
++; }
5435 if( zLine
[h
]==0 ) break;
5436 if( zLine
[h
]=='\'' || zLine
[h
]=='"' ){
5437 int delim
= zLine
[h
++];
5438 azArg
[nArg
++] = &zLine
[h
];
5439 while( zLine
[h
] && zLine
[h
]!=delim
){
5440 if( zLine
[h
]=='\\' && delim
=='"' && zLine
[h
+1]!=0 ) h
++;
5443 if( zLine
[h
]==delim
){
5446 if( delim
=='"' ) resolve_backslashes(azArg
[nArg
-1]);
5448 azArg
[nArg
++] = &zLine
[h
];
5449 while( zLine
[h
] && !IsSpace(zLine
[h
]) ){ h
++; }
5450 if( zLine
[h
] ) zLine
[h
++] = 0;
5451 resolve_backslashes(azArg
[nArg
-1]);
5455 /* Process the input line.
5457 if( nArg
==0 ) return 0; /* no tokens, no error */
5458 n
= strlen30(azArg
[0]);
5461 #ifndef SQLITE_OMIT_AUTHORIZATION
5462 if( c
=='a' && strncmp(azArg
[0], "auth", n
)==0 ){
5464 raw_printf(stderr
, "Usage: .auth ON|OFF\n");
5466 goto meta_command_exit
;
5469 if( booleanValue(azArg
[1]) ){
5470 sqlite3_set_authorizer(p
->db
, shellAuth
, p
);
5472 sqlite3_set_authorizer(p
->db
, 0, 0);
5477 if( (c
=='b' && n
>=3 && strncmp(azArg
[0], "backup", n
)==0)
5478 || (c
=='s' && n
>=3 && strncmp(azArg
[0], "save", n
)==0)
5480 const char *zDestFile
= 0;
5481 const char *zDb
= 0;
5483 sqlite3_backup
*pBackup
;
5485 for(j
=1; j
<nArg
; j
++){
5486 const char *z
= azArg
[j
];
5488 while( z
[0]=='-' ) z
++;
5489 /* No options to process at this time */
5491 utf8_printf(stderr
, "unknown option: %s\n", azArg
[j
]);
5494 }else if( zDestFile
==0 ){
5495 zDestFile
= azArg
[j
];
5498 zDestFile
= azArg
[j
];
5500 raw_printf(stderr
, "too many arguments to .backup\n");
5505 raw_printf(stderr
, "missing FILENAME argument on .backup\n");
5508 if( zDb
==0 ) zDb
= "main";
5509 rc
= sqlite3_open(zDestFile
, &pDest
);
5510 if( rc
!=SQLITE_OK
){
5511 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", zDestFile
);
5512 sqlite3_close(pDest
);
5516 pBackup
= sqlite3_backup_init(pDest
, "main", p
->db
, zDb
);
5518 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(pDest
));
5519 sqlite3_close(pDest
);
5522 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
){}
5523 sqlite3_backup_finish(pBackup
);
5524 if( rc
==SQLITE_DONE
){
5527 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(pDest
));
5530 sqlite3_close(pDest
);
5533 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "bail", n
)==0 ){
5535 bail_on_error
= booleanValue(azArg
[1]);
5537 raw_printf(stderr
, "Usage: .bail on|off\n");
5542 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "binary", n
)==0 ){
5544 if( booleanValue(azArg
[1]) ){
5545 setBinaryMode(p
->out
, 1);
5547 setTextMode(p
->out
, 1);
5550 raw_printf(stderr
, "Usage: .binary on|off\n");
5555 if( c
=='c' && strcmp(azArg
[0],"cd")==0 ){
5557 #if defined(_WIN32) || defined(WIN32)
5558 wchar_t *z
= sqlite3_win32_utf8_to_unicode(azArg
[1]);
5559 rc
= !SetCurrentDirectoryW(z
);
5562 rc
= chdir(azArg
[1]);
5565 utf8_printf(stderr
, "Cannot change to directory \"%s\"\n", azArg
[1]);
5569 raw_printf(stderr
, "Usage: .cd DIRECTORY\n");
5574 /* The undocumented ".breakpoint" command causes a call to the no-op
5575 ** routine named test_breakpoint().
5577 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "breakpoint", n
)==0 ){
5581 if( c
=='c' && n
>=3 && strncmp(azArg
[0], "changes", n
)==0 ){
5583 setOrClearFlag(p
, SHFLG_CountChanges
, azArg
[1]);
5585 raw_printf(stderr
, "Usage: .changes on|off\n");
5590 /* Cancel output redirection, if it is currently set (by .testcase)
5591 ** Then read the content of the testcase-out.txt file and compare against
5592 ** azArg[1]. If there are differences, report an error and exit.
5594 if( c
=='c' && n
>=3 && strncmp(azArg
[0], "check", n
)==0 ){
5598 raw_printf(stderr
, "Usage: .check GLOB-PATTERN\n");
5600 }else if( (zRes
= readFile("testcase-out.txt", 0))==0 ){
5601 raw_printf(stderr
, "Error: cannot read 'testcase-out.txt'\n");
5603 }else if( testcase_glob(azArg
[1],zRes
)==0 ){
5605 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
5606 p
->zTestcase
, azArg
[1], zRes
);
5609 utf8_printf(stdout
, "testcase-%s ok\n", p
->zTestcase
);
5615 if( c
=='c' && strncmp(azArg
[0], "clone", n
)==0 ){
5617 tryToClone(p
, azArg
[1]);
5619 raw_printf(stderr
, "Usage: .clone FILENAME\n");
5624 if( c
=='d' && n
>1 && strncmp(azArg
[0], "databases", n
)==0 ){
5628 memcpy(&data
, p
, sizeof(data
));
5629 data
.showHeader
= 0;
5630 data
.cMode
= data
.mode
= MODE_List
;
5631 sqlite3_snprintf(sizeof(data
.colSeparator
),data
.colSeparator
,": ");
5633 sqlite3_exec(p
->db
, "SELECT name, file FROM pragma_database_list",
5634 callback
, &data
, &zErrMsg
);
5636 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
5637 sqlite3_free(zErrMsg
);
5642 if( c
=='d' && strncmp(azArg
[0], "dbinfo", n
)==0 ){
5643 rc
= shell_dbinfo_command(p
, nArg
, azArg
);
5646 if( c
=='d' && strncmp(azArg
[0], "dump", n
)==0 ){
5647 const char *zLike
= 0;
5649 int savedShowHeader
= p
->showHeader
;
5650 ShellClearFlag(p
, SHFLG_PreserveRowid
|SHFLG_Newlines
);
5651 for(i
=1; i
<nArg
; i
++){
5652 if( azArg
[i
][0]=='-' ){
5653 const char *z
= azArg
[i
]+1;
5654 if( z
[0]=='-' ) z
++;
5655 if( strcmp(z
,"preserve-rowids")==0 ){
5656 #ifdef SQLITE_OMIT_VIRTUALTABLE
5657 raw_printf(stderr
, "The --preserve-rowids option is not compatible"
5658 " with SQLITE_OMIT_VIRTUALTABLE\n");
5660 goto meta_command_exit
;
5662 ShellSetFlag(p
, SHFLG_PreserveRowid
);
5665 if( strcmp(z
,"newlines")==0 ){
5666 ShellSetFlag(p
, SHFLG_Newlines
);
5669 raw_printf(stderr
, "Unknown option \"%s\" on \".dump\"\n", azArg
[i
]);
5671 goto meta_command_exit
;
5674 raw_printf(stderr
, "Usage: .dump ?--preserve-rowids? "
5675 "?--newlines? ?LIKE-PATTERN?\n");
5677 goto meta_command_exit
;
5683 /* When playing back a "dump", the content might appear in an order
5684 ** which causes immediate foreign key constraints to be violated.
5685 ** So disable foreign-key constraint enforcement to prevent problems. */
5686 raw_printf(p
->out
, "PRAGMA foreign_keys=OFF;\n");
5687 raw_printf(p
->out
, "BEGIN TRANSACTION;\n");
5688 p
->writableSchema
= 0;
5690 /* Set writable_schema=ON since doing so forces SQLite to initialize
5691 ** as much of the schema as it can even if the sqlite_master table is
5693 sqlite3_exec(p
->db
, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
5696 run_schema_dump_query(p
,
5697 "SELECT name, type, sql FROM sqlite_master "
5698 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
5700 run_schema_dump_query(p
,
5701 "SELECT name, type, sql FROM sqlite_master "
5702 "WHERE name=='sqlite_sequence'"
5704 run_table_dump_query(p
,
5705 "SELECT sql FROM sqlite_master "
5706 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
5710 zSql
= sqlite3_mprintf(
5711 "SELECT name, type, sql FROM sqlite_master "
5712 "WHERE tbl_name LIKE %Q AND type=='table'"
5713 " AND sql NOT NULL", zLike
);
5714 run_schema_dump_query(p
,zSql
);
5716 zSql
= sqlite3_mprintf(
5717 "SELECT sql FROM sqlite_master "
5718 "WHERE sql NOT NULL"
5719 " AND type IN ('index','trigger','view')"
5720 " AND tbl_name LIKE %Q", zLike
);
5721 run_table_dump_query(p
, zSql
, 0);
5724 if( p
->writableSchema
){
5725 raw_printf(p
->out
, "PRAGMA writable_schema=OFF;\n");
5726 p
->writableSchema
= 0;
5728 sqlite3_exec(p
->db
, "PRAGMA writable_schema=OFF;", 0, 0, 0);
5729 sqlite3_exec(p
->db
, "RELEASE dump;", 0, 0, 0);
5730 raw_printf(p
->out
, p
->nErr
? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
5731 p
->showHeader
= savedShowHeader
;
5734 if( c
=='e' && strncmp(azArg
[0], "echo", n
)==0 ){
5736 setOrClearFlag(p
, SHFLG_Echo
, azArg
[1]);
5738 raw_printf(stderr
, "Usage: .echo on|off\n");
5743 if( c
=='e' && strncmp(azArg
[0], "eqp", n
)==0 ){
5745 if( strcmp(azArg
[1],"full")==0 ){
5748 p
->autoEQP
= booleanValue(azArg
[1]);
5751 raw_printf(stderr
, "Usage: .eqp on|off|full\n");
5756 if( c
=='e' && strncmp(azArg
[0], "exit", n
)==0 ){
5757 if( nArg
>1 && (rc
= (int)integerValue(azArg
[1]))!=0 ) exit(rc
);
5761 /* The ".explain" command is automatic now. It is largely pointless. It
5762 ** retained purely for backwards compatibility */
5763 if( c
=='e' && strncmp(azArg
[0], "explain", n
)==0 ){
5766 if( strcmp(azArg
[1],"auto")==0 ){
5769 val
= booleanValue(azArg
[1]);
5772 if( val
==1 && p
->mode
!=MODE_Explain
){
5773 p
->normalMode
= p
->mode
;
5774 p
->mode
= MODE_Explain
;
5777 if( p
->mode
==MODE_Explain
) p
->mode
= p
->normalMode
;
5779 }else if( val
==99 ){
5780 if( p
->mode
==MODE_Explain
) p
->mode
= p
->normalMode
;
5785 if( c
=='f' && strncmp(azArg
[0], "fullschema", n
)==0 ){
5789 memcpy(&data
, p
, sizeof(data
));
5790 data
.showHeader
= 0;
5791 data
.cMode
= data
.mode
= MODE_Semi
;
5792 if( nArg
==2 && optionMatch(azArg
[1], "indent") ){
5793 data
.cMode
= data
.mode
= MODE_Pretty
;
5797 raw_printf(stderr
, "Usage: .fullschema ?--indent?\n");
5799 goto meta_command_exit
;
5802 rc
= sqlite3_exec(p
->db
,
5804 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
5805 " FROM sqlite_master UNION ALL"
5806 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
5807 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
5809 callback
, &data
, &zErrMsg
5811 if( rc
==SQLITE_OK
){
5812 sqlite3_stmt
*pStmt
;
5813 rc
= sqlite3_prepare_v2(p
->db
,
5814 "SELECT rowid FROM sqlite_master"
5815 " WHERE name GLOB 'sqlite_stat[134]'",
5817 doStats
= sqlite3_step(pStmt
)==SQLITE_ROW
;
5818 sqlite3_finalize(pStmt
);
5821 raw_printf(p
->out
, "/* No STAT tables available */\n");
5823 raw_printf(p
->out
, "ANALYZE sqlite_master;\n");
5824 sqlite3_exec(p
->db
, "SELECT 'ANALYZE sqlite_master'",
5825 callback
, &data
, &zErrMsg
);
5826 data
.cMode
= data
.mode
= MODE_Insert
;
5827 data
.zDestTable
= "sqlite_stat1";
5828 shell_exec(p
->db
, "SELECT * FROM sqlite_stat1",
5829 shell_callback
, &data
,&zErrMsg
);
5830 data
.zDestTable
= "sqlite_stat3";
5831 shell_exec(p
->db
, "SELECT * FROM sqlite_stat3",
5832 shell_callback
, &data
,&zErrMsg
);
5833 data
.zDestTable
= "sqlite_stat4";
5834 shell_exec(p
->db
, "SELECT * FROM sqlite_stat4",
5835 shell_callback
, &data
, &zErrMsg
);
5836 raw_printf(p
->out
, "ANALYZE sqlite_master;\n");
5840 if( c
=='h' && strncmp(azArg
[0], "headers", n
)==0 ){
5842 p
->showHeader
= booleanValue(azArg
[1]);
5844 raw_printf(stderr
, "Usage: .headers on|off\n");
5849 if( c
=='h' && strncmp(azArg
[0], "help", n
)==0 ){
5850 utf8_printf(p
->out
, "%s", zHelp
);
5853 if( c
=='i' && strncmp(azArg
[0], "import", n
)==0 ){
5854 char *zTable
; /* Insert data into this table */
5855 char *zFile
; /* Name of file to extra content from */
5856 sqlite3_stmt
*pStmt
= NULL
; /* A statement */
5857 int nCol
; /* Number of columns in the table */
5858 int nByte
; /* Number of bytes in an SQL string */
5859 int i
, j
; /* Loop counters */
5860 int needCommit
; /* True to COMMIT or ROLLBACK at end */
5861 int nSep
; /* Number of bytes in p->colSeparator[] */
5862 char *zSql
; /* An SQL statement */
5863 ImportCtx sCtx
; /* Reader context */
5864 char *(SQLITE_CDECL
*xRead
)(ImportCtx
*); /* Func to read one value */
5865 int (SQLITE_CDECL
*xCloser
)(FILE*); /* Func to close file */
5868 raw_printf(stderr
, "Usage: .import FILE TABLE\n");
5869 goto meta_command_exit
;
5874 memset(&sCtx
, 0, sizeof(sCtx
));
5876 nSep
= strlen30(p
->colSeparator
);
5879 "Error: non-null column separator required for import\n");
5883 raw_printf(stderr
, "Error: multi-character column separators not allowed"
5887 nSep
= strlen30(p
->rowSeparator
);
5889 raw_printf(stderr
, "Error: non-null row separator required for import\n");
5892 if( nSep
==2 && p
->mode
==MODE_Csv
&& strcmp(p
->rowSeparator
, SEP_CrLf
)==0 ){
5893 /* When importing CSV (only), if the row separator is set to the
5894 ** default output row separator, change it to the default input
5895 ** row separator. This avoids having to maintain different input
5896 ** and output row separators. */
5897 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Row
);
5898 nSep
= strlen30(p
->rowSeparator
);
5901 raw_printf(stderr
, "Error: multi-character row separators not allowed"
5907 if( sCtx
.zFile
[0]=='|' ){
5908 #ifdef SQLITE_OMIT_POPEN
5909 raw_printf(stderr
, "Error: pipes are not supported in this OS\n");
5912 sCtx
.in
= popen(sCtx
.zFile
+1, "r");
5913 sCtx
.zFile
= "<pipe>";
5917 sCtx
.in
= fopen(sCtx
.zFile
, "rb");
5920 if( p
->mode
==MODE_Ascii
){
5921 xRead
= ascii_read_one_field
;
5923 xRead
= csv_read_one_field
;
5926 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", zFile
);
5929 sCtx
.cColSep
= p
->colSeparator
[0];
5930 sCtx
.cRowSep
= p
->rowSeparator
[0];
5931 zSql
= sqlite3_mprintf("SELECT * FROM %s", zTable
);
5933 raw_printf(stderr
, "Error: out of memory\n");
5937 nByte
= strlen30(zSql
);
5938 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
5939 import_append_char(&sCtx
, 0); /* To ensure sCtx.z is allocated */
5940 if( rc
&& sqlite3_strglob("no such table: *", sqlite3_errmsg(p
->db
))==0 ){
5941 char *zCreate
= sqlite3_mprintf("CREATE TABLE %s", zTable
);
5943 while( xRead(&sCtx
) ){
5944 zCreate
= sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate
, cSep
, sCtx
.z
);
5946 if( sCtx
.cTerm
!=sCtx
.cColSep
) break;
5949 sqlite3_free(zCreate
);
5950 sqlite3_free(sCtx
.z
);
5952 utf8_printf(stderr
,"%s: empty file\n", sCtx
.zFile
);
5955 zCreate
= sqlite3_mprintf("%z\n)", zCreate
);
5956 rc
= sqlite3_exec(p
->db
, zCreate
, 0, 0, 0);
5957 sqlite3_free(zCreate
);
5959 utf8_printf(stderr
, "CREATE TABLE %s(...) failed: %s\n", zTable
,
5960 sqlite3_errmsg(p
->db
));
5961 sqlite3_free(sCtx
.z
);
5965 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
5969 if (pStmt
) sqlite3_finalize(pStmt
);
5970 utf8_printf(stderr
,"Error: %s\n", sqlite3_errmsg(p
->db
));
5974 nCol
= sqlite3_column_count(pStmt
);
5975 sqlite3_finalize(pStmt
);
5977 if( nCol
==0 ) return 0; /* no columns, no error */
5978 zSql
= sqlite3_malloc64( nByte
*2 + 20 + nCol
*2 );
5980 raw_printf(stderr
, "Error: out of memory\n");
5984 sqlite3_snprintf(nByte
+20, zSql
, "INSERT INTO \"%w\" VALUES(?", zTable
);
5986 for(i
=1; i
<nCol
; i
++){
5992 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
5995 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
5996 if (pStmt
) sqlite3_finalize(pStmt
);
6000 needCommit
= sqlite3_get_autocommit(p
->db
);
6001 if( needCommit
) sqlite3_exec(p
->db
, "BEGIN", 0, 0, 0);
6003 int startLine
= sCtx
.nLine
;
6004 for(i
=0; i
<nCol
; i
++){
6005 char *z
= xRead(&sCtx
);
6007 ** Did we reach end-of-file before finding any columns?
6008 ** If so, stop instead of NULL filling the remaining columns.
6010 if( z
==0 && i
==0 ) break;
6012 ** Did we reach end-of-file OR end-of-line before finding any
6013 ** columns in ASCII mode? If so, stop instead of NULL filling
6014 ** the remaining columns.
6016 if( p
->mode
==MODE_Ascii
&& (z
==0 || z
[0]==0) && i
==0 ) break;
6017 sqlite3_bind_text(pStmt
, i
+1, z
, -1, SQLITE_TRANSIENT
);
6018 if( i
<nCol
-1 && sCtx
.cTerm
!=sCtx
.cColSep
){
6019 utf8_printf(stderr
, "%s:%d: expected %d columns but found %d - "
6020 "filling the rest with NULL\n",
6021 sCtx
.zFile
, startLine
, nCol
, i
+1);
6023 while( i
<=nCol
){ sqlite3_bind_null(pStmt
, i
); i
++; }
6026 if( sCtx
.cTerm
==sCtx
.cColSep
){
6030 }while( sCtx
.cTerm
==sCtx
.cColSep
);
6031 utf8_printf(stderr
, "%s:%d: expected %d columns but found %d - "
6033 sCtx
.zFile
, startLine
, nCol
, i
);
6036 sqlite3_step(pStmt
);
6037 rc
= sqlite3_reset(pStmt
);
6038 if( rc
!=SQLITE_OK
){
6039 utf8_printf(stderr
, "%s:%d: INSERT failed: %s\n", sCtx
.zFile
,
6040 startLine
, sqlite3_errmsg(p
->db
));
6043 }while( sCtx
.cTerm
!=EOF
);
6046 sqlite3_free(sCtx
.z
);
6047 sqlite3_finalize(pStmt
);
6048 if( needCommit
) sqlite3_exec(p
->db
, "COMMIT", 0, 0, 0);
6051 #ifndef SQLITE_UNTESTABLE
6052 if( c
=='i' && strncmp(azArg
[0], "imposter", n
)==0 ){
6055 sqlite3_stmt
*pStmt
;
6059 utf8_printf(stderr
, "Usage: .imposter INDEX IMPOSTER\n");
6061 goto meta_command_exit
;
6064 zSql
= sqlite3_mprintf("SELECT rootpage FROM sqlite_master"
6065 " WHERE name='%q' AND type='index'", azArg
[1]);
6066 sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
6068 if( sqlite3_step(pStmt
)==SQLITE_ROW
){
6069 tnum
= sqlite3_column_int(pStmt
, 0);
6071 sqlite3_finalize(pStmt
);
6073 utf8_printf(stderr
, "no such index: \"%s\"\n", azArg
[1]);
6075 goto meta_command_exit
;
6077 zSql
= sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg
[1]);
6078 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
6081 while( sqlite3_step(pStmt
)==SQLITE_ROW
){
6083 const char *zCol
= (const char*)sqlite3_column_text(pStmt
,2);
6086 if( sqlite3_column_int(pStmt
,1)==-1 ){
6089 sqlite3_snprintf(sizeof(zLabel
),zLabel
,"expr%d",i
);
6094 zCollist
= sqlite3_mprintf("\"%w\"", zCol
);
6096 zCollist
= sqlite3_mprintf("%z,\"%w\"", zCollist
, zCol
);
6099 sqlite3_finalize(pStmt
);
6100 zSql
= sqlite3_mprintf(
6101 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%s))WITHOUT ROWID",
6102 azArg
[2], zCollist
, zCollist
);
6103 sqlite3_free(zCollist
);
6104 rc
= sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER
, p
->db
, "main", 1, tnum
);
6105 if( rc
==SQLITE_OK
){
6106 rc
= sqlite3_exec(p
->db
, zSql
, 0, 0, 0);
6107 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER
, p
->db
, "main", 0, 0);
6109 utf8_printf(stderr
, "Error in [%s]: %s\n", zSql
, sqlite3_errmsg(p
->db
));
6111 utf8_printf(stdout
, "%s;\n", zSql
);
6113 "WARNING: writing to an imposter table will corrupt the index!\n"
6117 raw_printf(stderr
, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc
);
6122 #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
6124 #ifdef SQLITE_ENABLE_IOTRACE
6125 if( c
=='i' && strncmp(azArg
[0], "iotrace", n
)==0 ){
6126 SQLITE_API
extern void (SQLITE_CDECL
*sqlite3IoTrace
)(const char*, ...);
6127 if( iotrace
&& iotrace
!=stdout
) fclose(iotrace
);
6131 }else if( strcmp(azArg
[1], "-")==0 ){
6132 sqlite3IoTrace
= iotracePrintf
;
6135 iotrace
= fopen(azArg
[1], "w");
6137 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", azArg
[1]);
6141 sqlite3IoTrace
= iotracePrintf
;
6147 if( c
=='l' && n
>=5 && strncmp(azArg
[0], "limits", n
)==0 ){
6148 static const struct {
6149 const char *zLimitName
; /* Name of a limit */
6150 int limitCode
; /* Integer code for that limit */
6152 { "length", SQLITE_LIMIT_LENGTH
},
6153 { "sql_length", SQLITE_LIMIT_SQL_LENGTH
},
6154 { "column", SQLITE_LIMIT_COLUMN
},
6155 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH
},
6156 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT
},
6157 { "vdbe_op", SQLITE_LIMIT_VDBE_OP
},
6158 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG
},
6159 { "attached", SQLITE_LIMIT_ATTACHED
},
6160 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH
},
6161 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER
},
6162 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH
},
6163 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS
},
6168 for(i
=0; i
<ArraySize(aLimit
); i
++){
6169 printf("%20s %d\n", aLimit
[i
].zLimitName
,
6170 sqlite3_limit(p
->db
, aLimit
[i
].limitCode
, -1));
6173 raw_printf(stderr
, "Usage: .limit NAME ?NEW-VALUE?\n");
6175 goto meta_command_exit
;
6178 n2
= strlen30(azArg
[1]);
6179 for(i
=0; i
<ArraySize(aLimit
); i
++){
6180 if( sqlite3_strnicmp(aLimit
[i
].zLimitName
, azArg
[1], n2
)==0 ){
6184 utf8_printf(stderr
, "ambiguous limit: \"%s\"\n", azArg
[1]);
6186 goto meta_command_exit
;
6191 utf8_printf(stderr
, "unknown limit: \"%s\"\n"
6192 "enter \".limits\" with no arguments for a list.\n",
6195 goto meta_command_exit
;
6198 sqlite3_limit(p
->db
, aLimit
[iLimit
].limitCode
,
6199 (int)integerValue(azArg
[2]));
6201 printf("%20s %d\n", aLimit
[iLimit
].zLimitName
,
6202 sqlite3_limit(p
->db
, aLimit
[iLimit
].limitCode
, -1));
6206 if( c
=='l' && n
>2 && strncmp(azArg
[0], "lint", n
)==0 ){
6208 lintDotCommand(p
, azArg
, nArg
);
6211 #ifndef SQLITE_OMIT_LOAD_EXTENSION
6212 if( c
=='l' && strncmp(azArg
[0], "load", n
)==0 ){
6213 const char *zFile
, *zProc
;
6216 raw_printf(stderr
, "Usage: .load FILE ?ENTRYPOINT?\n");
6218 goto meta_command_exit
;
6221 zProc
= nArg
>=3 ? azArg
[2] : 0;
6223 rc
= sqlite3_load_extension(p
->db
, zFile
, zProc
, &zErrMsg
);
6224 if( rc
!=SQLITE_OK
){
6225 utf8_printf(stderr
, "Error: %s\n", zErrMsg
);
6226 sqlite3_free(zErrMsg
);
6232 if( c
=='l' && strncmp(azArg
[0], "log", n
)==0 ){
6234 raw_printf(stderr
, "Usage: .log FILENAME\n");
6237 const char *zFile
= azArg
[1];
6238 output_file_close(p
->pLog
);
6239 p
->pLog
= output_file_open(zFile
);
6243 if( c
=='m' && strncmp(azArg
[0], "mode", n
)==0 ){
6244 const char *zMode
= nArg
>=2 ? azArg
[1] : "";
6245 int n2
= (int)strlen(zMode
);
6247 if( c2
=='l' && n2
>2 && strncmp(azArg
[1],"lines",n2
)==0 ){
6248 p
->mode
= MODE_Line
;
6249 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Row
);
6250 }else if( c2
=='c' && strncmp(azArg
[1],"columns",n2
)==0 ){
6251 p
->mode
= MODE_Column
;
6252 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Row
);
6253 }else if( c2
=='l' && n2
>2 && strncmp(azArg
[1],"list",n2
)==0 ){
6254 p
->mode
= MODE_List
;
6255 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Column
);
6256 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Row
);
6257 }else if( c2
=='h' && strncmp(azArg
[1],"html",n2
)==0 ){
6258 p
->mode
= MODE_Html
;
6259 }else if( c2
=='t' && strncmp(azArg
[1],"tcl",n2
)==0 ){
6261 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Space
);
6262 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Row
);
6263 }else if( c2
=='c' && strncmp(azArg
[1],"csv",n2
)==0 ){
6265 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Comma
);
6266 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_CrLf
);
6267 }else if( c2
=='t' && strncmp(azArg
[1],"tabs",n2
)==0 ){
6268 p
->mode
= MODE_List
;
6269 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Tab
);
6270 }else if( c2
=='i' && strncmp(azArg
[1],"insert",n2
)==0 ){
6271 p
->mode
= MODE_Insert
;
6272 set_table_name(p
, nArg
>=3 ? azArg
[2] : "table");
6273 }else if( c2
=='q' && strncmp(azArg
[1],"quote",n2
)==0 ){
6274 p
->mode
= MODE_Quote
;
6275 }else if( c2
=='a' && strncmp(azArg
[1],"ascii",n2
)==0 ){
6276 p
->mode
= MODE_Ascii
;
6277 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Unit
);
6278 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Record
);
6279 }else if( nArg
==1 ){
6280 raw_printf(p
->out
, "current output mode: %s\n", modeDescr
[p
->mode
]);
6282 raw_printf(stderr
, "Error: mode should be one of: "
6283 "ascii column csv html insert line list quote tabs tcl\n");
6289 if( c
=='n' && strncmp(azArg
[0], "nullvalue", n
)==0 ){
6291 sqlite3_snprintf(sizeof(p
->nullValue
), p
->nullValue
,
6292 "%.*s", (int)ArraySize(p
->nullValue
)-1, azArg
[1]);
6294 raw_printf(stderr
, "Usage: .nullvalue STRING\n");
6299 if( c
=='o' && strncmp(azArg
[0], "open", n
)==0 && n
>=2 ){
6300 char *zNewFilename
; /* Name of the database file to open */
6301 int iName
= 1; /* Index in azArg[] of the filename */
6302 int newFlag
= 0; /* True to delete file before opening */
6303 /* Close the existing database */
6304 session_close_all(p
);
6305 sqlite3_close(p
->db
);
6308 sqlite3_free(p
->zFreeOnClose
);
6309 p
->zFreeOnClose
= 0;
6310 /* Check for command-line arguments */
6311 for(iName
=1; iName
<nArg
&& azArg
[iName
][0]=='-'; iName
++){
6312 const char *z
= azArg
[iName
];
6313 if( optionMatch(z
,"new") ){
6315 }else if( z
[0]=='-' ){
6316 utf8_printf(stderr
, "unknown option: %s\n", z
);
6318 goto meta_command_exit
;
6321 /* If a filename is specified, try to open it first */
6322 zNewFilename
= nArg
>iName
? sqlite3_mprintf("%s", azArg
[iName
]) : 0;
6324 if( newFlag
) shellDeleteFile(zNewFilename
);
6325 p
->zDbFilename
= zNewFilename
;
6328 utf8_printf(stderr
, "Error: cannot open '%s'\n", zNewFilename
);
6329 sqlite3_free(zNewFilename
);
6331 p
->zFreeOnClose
= zNewFilename
;
6335 /* As a fall-back open a TEMP database */
6342 && (strncmp(azArg
[0], "output", n
)==0 || strncmp(azArg
[0], "once", n
)==0)
6344 const char *zFile
= nArg
>=2 ? azArg
[1] : "stdout";
6346 utf8_printf(stderr
, "Usage: .%s FILE\n", azArg
[0]);
6348 goto meta_command_exit
;
6350 if( n
>1 && strncmp(azArg
[0], "once", n
)==0 ){
6352 raw_printf(stderr
, "Usage: .once FILE\n");
6354 goto meta_command_exit
;
6361 if( zFile
[0]=='|' ){
6362 #ifdef SQLITE_OMIT_POPEN
6363 raw_printf(stderr
, "Error: pipes are not supported in this OS\n");
6367 p
->out
= popen(zFile
+ 1, "w");
6369 utf8_printf(stderr
,"Error: cannot open pipe \"%s\"\n", zFile
+ 1);
6373 sqlite3_snprintf(sizeof(p
->outfile
), p
->outfile
, "%s", zFile
);
6377 p
->out
= output_file_open(zFile
);
6379 if( strcmp(zFile
,"off")!=0 ){
6380 utf8_printf(stderr
,"Error: cannot write to \"%s\"\n", zFile
);
6385 sqlite3_snprintf(sizeof(p
->outfile
), p
->outfile
, "%s", zFile
);
6390 if( c
=='p' && n
>=3 && strncmp(azArg
[0], "print", n
)==0 ){
6392 for(i
=1; i
<nArg
; i
++){
6393 if( i
>1 ) raw_printf(p
->out
, " ");
6394 utf8_printf(p
->out
, "%s", azArg
[i
]);
6396 raw_printf(p
->out
, "\n");
6399 if( c
=='p' && strncmp(azArg
[0], "prompt", n
)==0 ){
6401 strncpy(mainPrompt
,azArg
[1],(int)ArraySize(mainPrompt
)-1);
6404 strncpy(continuePrompt
,azArg
[2],(int)ArraySize(continuePrompt
)-1);
6408 if( c
=='q' && strncmp(azArg
[0], "quit", n
)==0 ){
6412 if( c
=='r' && n
>=3 && strncmp(azArg
[0], "read", n
)==0 ){
6415 raw_printf(stderr
, "Usage: .read FILE\n");
6417 goto meta_command_exit
;
6419 alt
= fopen(azArg
[1], "rb");
6421 utf8_printf(stderr
,"Error: cannot open \"%s\"\n", azArg
[1]);
6424 rc
= process_input(p
, alt
);
6429 if( c
=='r' && n
>=3 && strncmp(azArg
[0], "restore", n
)==0 ){
6430 const char *zSrcFile
;
6433 sqlite3_backup
*pBackup
;
6437 zSrcFile
= azArg
[1];
6439 }else if( nArg
==3 ){
6440 zSrcFile
= azArg
[2];
6443 raw_printf(stderr
, "Usage: .restore ?DB? FILE\n");
6445 goto meta_command_exit
;
6447 rc
= sqlite3_open(zSrcFile
, &pSrc
);
6448 if( rc
!=SQLITE_OK
){
6449 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", zSrcFile
);
6450 sqlite3_close(pSrc
);
6454 pBackup
= sqlite3_backup_init(p
->db
, zDb
, pSrc
, "main");
6456 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
6457 sqlite3_close(pSrc
);
6460 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
6461 || rc
==SQLITE_BUSY
){
6462 if( rc
==SQLITE_BUSY
){
6463 if( nTimeout
++ >= 3 ) break;
6467 sqlite3_backup_finish(pBackup
);
6468 if( rc
==SQLITE_DONE
){
6470 }else if( rc
==SQLITE_BUSY
|| rc
==SQLITE_LOCKED
){
6471 raw_printf(stderr
, "Error: source database is busy\n");
6474 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
6477 sqlite3_close(pSrc
);
6481 if( c
=='s' && strncmp(azArg
[0], "scanstats", n
)==0 ){
6483 p
->scanstatsOn
= booleanValue(azArg
[1]);
6484 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
6485 raw_printf(stderr
, "Warning: .scanstats not available in this build.\n");
6488 raw_printf(stderr
, "Usage: .scanstats on|off\n");
6493 if( c
=='s' && strncmp(azArg
[0], "schema", n
)==0 ){
6497 const char *zDiv
= 0;
6501 memcpy(&data
, p
, sizeof(data
));
6502 data
.showHeader
= 0;
6503 data
.cMode
= data
.mode
= MODE_Semi
;
6505 if( nArg
>=2 && optionMatch(azArg
[1], "indent") ){
6506 data
.cMode
= data
.mode
= MODE_Pretty
;
6508 if( nArg
==2 ) azArg
[1] = azArg
[2];
6510 if( nArg
==2 && azArg
[1][0]!='-' ){
6512 for(i
=0; azArg
[1][i
]; i
++) azArg
[1][i
] = ToLower(azArg
[1][i
]);
6513 if( strcmp(azArg
[1],"sqlite_master")==0 ){
6514 char *new_argv
[2], *new_colv
[2];
6515 new_argv
[0] = "CREATE TABLE sqlite_master (\n"
6519 " rootpage integer,\n"
6523 new_colv
[0] = "sql";
6525 callback(&data
, 1, new_argv
, new_colv
);
6527 }else if( strcmp(azArg
[1],"sqlite_temp_master")==0 ){
6528 char *new_argv
[2], *new_colv
[2];
6529 new_argv
[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
6533 " rootpage integer,\n"
6537 new_colv
[0] = "sql";
6539 callback(&data
, 1, new_argv
, new_colv
);
6544 }else if( nArg
==1 ){
6547 raw_printf(stderr
, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n");
6549 goto meta_command_exit
;
6552 sqlite3_stmt
*pStmt
= 0;
6553 rc
= sqlite3_prepare_v2(p
->db
, "SELECT name FROM pragma_database_list",
6556 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
6557 sqlite3_finalize(pStmt
);
6559 goto meta_command_exit
;
6561 appendText(&sSelect
, "SELECT sql FROM", 0);
6563 while( sqlite3_step(pStmt
)==SQLITE_ROW
){
6564 const char *zDb
= (const char*)sqlite3_column_text(pStmt
, 0);
6566 sqlite3_snprintf(sizeof(zScNum
), zScNum
, "%d", ++iSchema
);
6567 appendText(&sSelect
, zDiv
, 0);
6568 zDiv
= " UNION ALL ";
6569 if( strcmp(zDb
, "main")!=0 ){
6570 appendText(&sSelect
, "SELECT shell_add_schema(sql,", 0);
6571 appendText(&sSelect
, zDb
, '"');
6572 appendText(&sSelect
, ") AS sql, type, tbl_name, name, rowid,", 0);
6573 appendText(&sSelect
, zScNum
, 0);
6574 appendText(&sSelect
, " AS snum, ", 0);
6575 appendText(&sSelect
, zDb
, '\'');
6576 appendText(&sSelect
, " AS sname FROM ", 0);
6577 appendText(&sSelect
, zDb
, '"');
6578 appendText(&sSelect
, ".sqlite_master", 0);
6580 appendText(&sSelect
, "SELECT sql, type, tbl_name, name, rowid, ", 0);
6581 appendText(&sSelect
, zScNum
, 0);
6582 appendText(&sSelect
, " AS snum, 'main' AS sname FROM sqlite_master",0);
6585 sqlite3_finalize(pStmt
);
6586 appendText(&sSelect
, ") WHERE ", 0);
6588 char *zQarg
= sqlite3_mprintf("%Q", azArg
[1]);
6589 if( strchr(azArg
[1], '.') ){
6590 appendText(&sSelect
, "lower(printf('%s.%s',sname,tbl_name))", 0);
6592 appendText(&sSelect
, "lower(tbl_name)", 0);
6594 appendText(&sSelect
, strchr(azArg
[1], '*') ? " GLOB " : " LIKE ", 0);
6595 appendText(&sSelect
, zQarg
, 0);
6596 appendText(&sSelect
, " AND ", 0);
6597 sqlite3_free(zQarg
);
6599 appendText(&sSelect
, "type!='meta' AND sql IS NOT NULL"
6600 " ORDER BY snum, rowid", 0);
6601 rc
= sqlite3_exec(p
->db
, sSelect
.z
, callback
, &data
, &zErrMsg
);
6605 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
6606 sqlite3_free(zErrMsg
);
6608 }else if( rc
!= SQLITE_OK
){
6609 raw_printf(stderr
,"Error: querying schema information\n");
6616 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
6617 if( c
=='s' && n
==11 && strncmp(azArg
[0], "selecttrace", n
)==0 ){
6618 sqlite3SelectTrace
= (int)integerValue(azArg
[1]);
6622 #if defined(SQLITE_ENABLE_SESSION)
6623 if( c
=='s' && strncmp(azArg
[0],"session",n
)==0 && n
>=3 ){
6624 OpenSession
*pSession
= &p
->aSession
[0];
6625 char **azCmd
= &azArg
[1];
6627 int nCmd
= nArg
- 1;
6629 if( nArg
<=1 ) goto session_syntax_error
;
6632 for(iSes
=0; iSes
<p
->nSession
; iSes
++){
6633 if( strcmp(p
->aSession
[iSes
].zName
, azArg
[1])==0 ) break;
6635 if( iSes
<p
->nSession
){
6636 pSession
= &p
->aSession
[iSes
];
6640 pSession
= &p
->aSession
[0];
6645 /* .session attach TABLE
6646 ** Invoke the sqlite3session_attach() interface to attach a particular
6647 ** table so that it is never filtered.
6649 if( strcmp(azCmd
[0],"attach")==0 ){
6650 if( nCmd
!=2 ) goto session_syntax_error
;
6651 if( pSession
->p
==0 ){
6653 raw_printf(stderr
, "ERROR: No sessions are open\n");
6655 rc
= sqlite3session_attach(pSession
->p
, azCmd
[1]);
6657 raw_printf(stderr
, "ERROR: sqlite3session_attach() returns %d\n", rc
);
6663 /* .session changeset FILE
6664 ** .session patchset FILE
6665 ** Write a changeset or patchset into a file. The file is overwritten.
6667 if( strcmp(azCmd
[0],"changeset")==0 || strcmp(azCmd
[0],"patchset")==0 ){
6669 if( nCmd
!=2 ) goto session_syntax_error
;
6670 if( pSession
->p
==0 ) goto session_not_open
;
6671 out
= fopen(azCmd
[1], "wb");
6673 utf8_printf(stderr
, "ERROR: cannot open \"%s\" for writing\n", azCmd
[1]);
6677 if( azCmd
[0][0]=='c' ){
6678 rc
= sqlite3session_changeset(pSession
->p
, &szChng
, &pChng
);
6680 rc
= sqlite3session_patchset(pSession
->p
, &szChng
, &pChng
);
6683 printf("Error: error code %d\n", rc
);
6687 && fwrite(pChng
, szChng
, 1, out
)!=1 ){
6688 raw_printf(stderr
, "ERROR: Failed to write entire %d-byte output\n",
6691 sqlite3_free(pChng
);
6697 ** Close the identified session
6699 if( strcmp(azCmd
[0], "close")==0 ){
6700 if( nCmd
!=1 ) goto session_syntax_error
;
6702 session_close(pSession
);
6703 p
->aSession
[iSes
] = p
->aSession
[--p
->nSession
];
6707 /* .session enable ?BOOLEAN?
6708 ** Query or set the enable flag
6710 if( strcmp(azCmd
[0], "enable")==0 ){
6712 if( nCmd
>2 ) goto session_syntax_error
;
6713 ii
= nCmd
==1 ? -1 : booleanValue(azCmd
[1]);
6715 ii
= sqlite3session_enable(pSession
->p
, ii
);
6716 utf8_printf(p
->out
, "session %s enable flag = %d\n",
6717 pSession
->zName
, ii
);
6721 /* .session filter GLOB ....
6722 ** Set a list of GLOB patterns of table names to be excluded.
6724 if( strcmp(azCmd
[0], "filter")==0 ){
6726 if( nCmd
<2 ) goto session_syntax_error
;
6728 for(ii
=0; ii
<pSession
->nFilter
; ii
++){
6729 sqlite3_free(pSession
->azFilter
[ii
]);
6731 sqlite3_free(pSession
->azFilter
);
6732 nByte
= sizeof(pSession
->azFilter
[0])*(nCmd
-1);
6733 pSession
->azFilter
= sqlite3_malloc( nByte
);
6734 if( pSession
->azFilter
==0 ){
6735 raw_printf(stderr
, "Error: out or memory\n");
6738 for(ii
=1; ii
<nCmd
; ii
++){
6739 pSession
->azFilter
[ii
-1] = sqlite3_mprintf("%s", azCmd
[ii
]);
6741 pSession
->nFilter
= ii
-1;
6745 /* .session indirect ?BOOLEAN?
6746 ** Query or set the indirect flag
6748 if( strcmp(azCmd
[0], "indirect")==0 ){
6750 if( nCmd
>2 ) goto session_syntax_error
;
6751 ii
= nCmd
==1 ? -1 : booleanValue(azCmd
[1]);
6753 ii
= sqlite3session_indirect(pSession
->p
, ii
);
6754 utf8_printf(p
->out
, "session %s indirect flag = %d\n",
6755 pSession
->zName
, ii
);
6760 ** Determine if the session is empty
6762 if( strcmp(azCmd
[0], "isempty")==0 ){
6764 if( nCmd
!=1 ) goto session_syntax_error
;
6766 ii
= sqlite3session_isempty(pSession
->p
);
6767 utf8_printf(p
->out
, "session %s isempty flag = %d\n",
6768 pSession
->zName
, ii
);
6773 ** List all currently open sessions
6775 if( strcmp(azCmd
[0],"list")==0 ){
6776 for(i
=0; i
<p
->nSession
; i
++){
6777 utf8_printf(p
->out
, "%d %s\n", i
, p
->aSession
[i
].zName
);
6781 /* .session open DB NAME
6782 ** Open a new session called NAME on the attached database DB.
6783 ** DB is normally "main".
6785 if( strcmp(azCmd
[0],"open")==0 ){
6787 if( nCmd
!=3 ) goto session_syntax_error
;
6789 if( zName
[0]==0 ) goto session_syntax_error
;
6790 for(i
=0; i
<p
->nSession
; i
++){
6791 if( strcmp(p
->aSession
[i
].zName
,zName
)==0 ){
6792 utf8_printf(stderr
, "Session \"%s\" already exists\n", zName
);
6793 goto meta_command_exit
;
6796 if( p
->nSession
>=ArraySize(p
->aSession
) ){
6797 raw_printf(stderr
, "Maximum of %d sessions\n", ArraySize(p
->aSession
));
6798 goto meta_command_exit
;
6800 pSession
= &p
->aSession
[p
->nSession
];
6801 rc
= sqlite3session_create(p
->db
, azCmd
[1], &pSession
->p
);
6803 raw_printf(stderr
, "Cannot open session: error code=%d\n", rc
);
6805 goto meta_command_exit
;
6807 pSession
->nFilter
= 0;
6808 sqlite3session_table_filter(pSession
->p
, session_filter
, pSession
);
6810 pSession
->zName
= sqlite3_mprintf("%s", zName
);
6812 /* If no command name matches, show a syntax error */
6813 session_syntax_error
:
6819 /* Undocumented commands for internal testing. Subject to change
6820 ** without notice. */
6821 if( c
=='s' && n
>=10 && strncmp(azArg
[0], "selftest-", 9)==0 ){
6822 if( strncmp(azArg
[0]+9, "boolean", n
-9)==0 ){
6824 for(i
=1; i
<nArg
; i
++){
6825 v
= booleanValue(azArg
[i
]);
6826 utf8_printf(p
->out
, "%s: %d 0x%x\n", azArg
[i
], v
, v
);
6829 if( strncmp(azArg
[0]+9, "integer", n
-9)==0 ){
6830 int i
; sqlite3_int64 v
;
6831 for(i
=1; i
<nArg
; i
++){
6833 v
= integerValue(azArg
[i
]);
6834 sqlite3_snprintf(sizeof(zBuf
),zBuf
,"%s: %lld 0x%llx\n", azArg
[i
],v
,v
);
6835 utf8_printf(p
->out
, "%s", zBuf
);
6841 if( c
=='s' && n
>=4 && strncmp(azArg
[0],"selftest",n
)==0 ){
6842 int bIsInit
= 0; /* True to initialize the SELFTEST table */
6843 int bVerbose
= 0; /* Verbose output */
6844 int bSelftestExists
; /* True if SELFTEST already exists */
6845 int i
, k
; /* Loop counters */
6846 int nTest
= 0; /* Number of tests runs */
6847 int nErr
= 0; /* Number of errors seen */
6848 ShellText str
; /* Answer for a query */
6849 sqlite3_stmt
*pStmt
= 0; /* Query against the SELFTEST table */
6852 for(i
=1; i
<nArg
; i
++){
6853 const char *z
= azArg
[i
];
6854 if( z
[0]=='-' && z
[1]=='-' ) z
++;
6855 if( strcmp(z
,"-init")==0 ){
6858 if( strcmp(z
,"-v")==0 ){
6862 utf8_printf(stderr
, "Unknown option \"%s\" on \"%s\"\n",
6863 azArg
[i
], azArg
[0]);
6864 raw_printf(stderr
, "Should be one of: --init -v\n");
6866 goto meta_command_exit
;
6869 if( sqlite3_table_column_metadata(p
->db
,"main","selftest",0,0,0,0,0,0)
6871 bSelftestExists
= 0;
6873 bSelftestExists
= 1;
6876 createSelftestTable(p
);
6877 bSelftestExists
= 1;
6880 appendText(&str
, "x", 0);
6881 for(k
=bSelftestExists
; k
>=0; k
--){
6883 rc
= sqlite3_prepare_v2(p
->db
,
6884 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
6887 rc
= sqlite3_prepare_v2(p
->db
,
6888 "VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
6889 " (1,'run','PRAGMA integrity_check','ok')",
6893 raw_printf(stderr
, "Error querying the selftest table\n");
6895 sqlite3_finalize(pStmt
);
6896 goto meta_command_exit
;
6898 for(i
=1; sqlite3_step(pStmt
)==SQLITE_ROW
; i
++){
6899 int tno
= sqlite3_column_int(pStmt
, 0);
6900 const char *zOp
= (const char*)sqlite3_column_text(pStmt
, 1);
6901 const char *zSql
= (const char*)sqlite3_column_text(pStmt
, 2);
6902 const char *zAns
= (const char*)sqlite3_column_text(pStmt
, 3);
6906 char *zQuote
= sqlite3_mprintf("%q", zSql
);
6907 printf("%d: %s %s\n", tno
, zOp
, zSql
);
6908 sqlite3_free(zQuote
);
6910 if( strcmp(zOp
,"memo")==0 ){
6911 utf8_printf(p
->out
, "%s\n", zSql
);
6913 if( strcmp(zOp
,"run")==0 ){
6917 rc
= sqlite3_exec(p
->db
, zSql
, captureOutputCallback
, &str
, &zErrMsg
);
6920 utf8_printf(p
->out
, "Result: %s\n", str
.z
);
6922 if( rc
|| zErrMsg
){
6925 utf8_printf(p
->out
, "%d: error-code-%d: %s\n", tno
, rc
, zErrMsg
);
6926 sqlite3_free(zErrMsg
);
6927 }else if( strcmp(zAns
,str
.z
)!=0 ){
6930 utf8_printf(p
->out
, "%d: Expected: [%s]\n", tno
, zAns
);
6931 utf8_printf(p
->out
, "%d: Got: [%s]\n", tno
, str
.z
);
6936 "Unknown operation \"%s\" on selftest line %d\n", zOp
, tno
);
6940 } /* End loop over rows of content from SELFTEST */
6941 sqlite3_finalize(pStmt
);
6942 } /* End loop over k */
6944 utf8_printf(p
->out
, "%d errors out of %d tests\n", nErr
, nTest
);
6947 if( c
=='s' && strncmp(azArg
[0], "separator", n
)==0 ){
6948 if( nArg
<2 || nArg
>3 ){
6949 raw_printf(stderr
, "Usage: .separator COL ?ROW?\n");
6953 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
,
6954 "%.*s", (int)ArraySize(p
->colSeparator
)-1, azArg
[1]);
6957 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
,
6958 "%.*s", (int)ArraySize(p
->rowSeparator
)-1, azArg
[2]);
6962 if( c
=='s' && n
>=4 && strncmp(azArg
[0],"sha3sum",n
)==0 ){
6963 const char *zLike
= 0; /* Which table to checksum. 0 means everything */
6964 int i
; /* Loop counter */
6965 int bSchema
= 0; /* Also hash the schema */
6966 int bSeparate
= 0; /* Hash each table separately */
6967 int iSize
= 224; /* Hash algorithm to use */
6968 int bDebug
= 0; /* Only show the query that would have run */
6969 sqlite3_stmt
*pStmt
; /* For querying tables names */
6970 char *zSql
; /* SQL to be run */
6971 char *zSep
; /* Separator */
6972 ShellText sSql
; /* Complete SQL for the query to run the hash */
6973 ShellText sQuery
; /* Set of queries used to read all content */
6975 for(i
=1; i
<nArg
; i
++){
6976 const char *z
= azArg
[i
];
6979 if( z
[0]=='-' ) z
++;
6980 if( strcmp(z
,"schema")==0 ){
6983 if( strcmp(z
,"sha3-224")==0 || strcmp(z
,"sha3-256")==0
6984 || strcmp(z
,"sha3-384")==0 || strcmp(z
,"sha3-512")==0
6986 iSize
= atoi(&z
[5]);
6988 if( strcmp(z
,"debug")==0 ){
6992 utf8_printf(stderr
, "Unknown option \"%s\" on \"%s\"\n",
6993 azArg
[i
], azArg
[0]);
6994 raw_printf(stderr
, "Should be one of: --schema"
6995 " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
6997 goto meta_command_exit
;
7000 raw_printf(stderr
, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
7002 goto meta_command_exit
;
7006 if( sqlite3_strlike("sqlite_%", zLike
, 0)==0 ) bSchema
= 1;
7010 zSql
= "SELECT lower(name) FROM sqlite_master"
7011 " WHERE type='table' AND coalesce(rootpage,0)>1"
7012 " UNION ALL SELECT 'sqlite_master'"
7013 " ORDER BY 1 collate nocase";
7015 zSql
= "SELECT lower(name) FROM sqlite_master"
7016 " WHERE type='table' AND coalesce(rootpage,0)>1"
7017 " AND name NOT LIKE 'sqlite_%'"
7018 " ORDER BY 1 collate nocase";
7020 sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
7023 appendText(&sSql
, "WITH [sha3sum$query](a,b) AS(",0);
7025 while( SQLITE_ROW
==sqlite3_step(pStmt
) ){
7026 const char *zTab
= (const char*)sqlite3_column_text(pStmt
,0);
7027 if( zLike
&& sqlite3_strlike(zLike
, zTab
, 0)!=0 ) continue;
7028 if( strncmp(zTab
, "sqlite_",7)!=0 ){
7029 appendText(&sQuery
,"SELECT * FROM ", 0);
7030 appendText(&sQuery
,zTab
,'"');
7031 appendText(&sQuery
," NOT INDEXED;", 0);
7032 }else if( strcmp(zTab
, "sqlite_master")==0 ){
7033 appendText(&sQuery
,"SELECT type,name,tbl_name,sql FROM sqlite_master"
7034 " ORDER BY name;", 0);
7035 }else if( strcmp(zTab
, "sqlite_sequence")==0 ){
7036 appendText(&sQuery
,"SELECT name,seq FROM sqlite_sequence"
7037 " ORDER BY name;", 0);
7038 }else if( strcmp(zTab
, "sqlite_stat1")==0 ){
7039 appendText(&sQuery
,"SELECT tbl,idx,stat FROM sqlite_stat1"
7040 " ORDER BY tbl,idx;", 0);
7041 }else if( strcmp(zTab
, "sqlite_stat3")==0
7042 || strcmp(zTab
, "sqlite_stat4")==0 ){
7043 appendText(&sQuery
, "SELECT * FROM ", 0);
7044 appendText(&sQuery
, zTab
, 0);
7045 appendText(&sQuery
, " ORDER BY tbl, idx, rowid;\n", 0);
7047 appendText(&sSql
, zSep
, 0);
7048 appendText(&sSql
, sQuery
.z
, '\'');
7050 appendText(&sSql
, ",", 0);
7051 appendText(&sSql
, zTab
, '\'');
7054 sqlite3_finalize(pStmt
);
7056 zSql
= sqlite3_mprintf(
7058 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
7059 " FROM [sha3sum$query]",
7062 zSql
= sqlite3_mprintf(
7064 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
7065 " FROM [sha3sum$query]",
7071 utf8_printf(p
->out
, "%s\n", zSql
);
7073 shell_exec(p
->db
, zSql
, shell_callback
, p
, 0);
7079 && (strncmp(azArg
[0], "shell", n
)==0 || strncmp(azArg
[0],"system",n
)==0)
7084 raw_printf(stderr
, "Usage: .system COMMAND\n");
7086 goto meta_command_exit
;
7088 zCmd
= sqlite3_mprintf(strchr(azArg
[1],' ')==0?"%s":"\"%s\"", azArg
[1]);
7089 for(i
=2; i
<nArg
; i
++){
7090 zCmd
= sqlite3_mprintf(strchr(azArg
[i
],' ')==0?"%z %s":"%z \"%s\"",
7095 if( x
) raw_printf(stderr
, "System command returns %d\n", x
);
7098 if( c
=='s' && strncmp(azArg
[0], "show", n
)==0 ){
7099 static const char *azBool
[] = { "off", "on", "full", "unk" };
7102 raw_printf(stderr
, "Usage: .show\n");
7104 goto meta_command_exit
;
7106 utf8_printf(p
->out
, "%12.12s: %s\n","echo",
7107 azBool
[ShellHasFlag(p
, SHFLG_Echo
)]);
7108 utf8_printf(p
->out
, "%12.12s: %s\n","eqp", azBool
[p
->autoEQP
&3]);
7109 utf8_printf(p
->out
, "%12.12s: %s\n","explain",
7110 p
->mode
==MODE_Explain
? "on" : p
->autoExplain
? "auto" : "off");
7111 utf8_printf(p
->out
,"%12.12s: %s\n","headers", azBool
[p
->showHeader
!=0]);
7112 utf8_printf(p
->out
, "%12.12s: %s\n","mode", modeDescr
[p
->mode
]);
7113 utf8_printf(p
->out
, "%12.12s: ", "nullvalue");
7114 output_c_string(p
->out
, p
->nullValue
);
7115 raw_printf(p
->out
, "\n");
7116 utf8_printf(p
->out
,"%12.12s: %s\n","output",
7117 strlen30(p
->outfile
) ? p
->outfile
: "stdout");
7118 utf8_printf(p
->out
,"%12.12s: ", "colseparator");
7119 output_c_string(p
->out
, p
->colSeparator
);
7120 raw_printf(p
->out
, "\n");
7121 utf8_printf(p
->out
,"%12.12s: ", "rowseparator");
7122 output_c_string(p
->out
, p
->rowSeparator
);
7123 raw_printf(p
->out
, "\n");
7124 utf8_printf(p
->out
, "%12.12s: %s\n","stats", azBool
[p
->statsOn
!=0]);
7125 utf8_printf(p
->out
, "%12.12s: ", "width");
7126 for (i
=0;i
<(int)ArraySize(p
->colWidth
) && p
->colWidth
[i
] != 0;i
++) {
7127 raw_printf(p
->out
, "%d ", p
->colWidth
[i
]);
7129 raw_printf(p
->out
, "\n");
7130 utf8_printf(p
->out
, "%12.12s: %s\n", "filename",
7131 p
->zDbFilename
? p
->zDbFilename
: "");
7134 if( c
=='s' && strncmp(azArg
[0], "stats", n
)==0 ){
7136 p
->statsOn
= booleanValue(azArg
[1]);
7137 }else if( nArg
==1 ){
7138 display_stats(p
->db
, p
, 0);
7140 raw_printf(stderr
, "Usage: .stats ?on|off?\n");
7145 if( (c
=='t' && n
>1 && strncmp(azArg
[0], "tables", n
)==0)
7146 || (c
=='i' && (strncmp(azArg
[0], "indices", n
)==0
7147 || strncmp(azArg
[0], "indexes", n
)==0) )
7149 sqlite3_stmt
*pStmt
;
7156 rc
= sqlite3_prepare_v2(p
->db
, "PRAGMA database_list", -1, &pStmt
, 0);
7157 if( rc
) return shellDatabaseError(p
->db
);
7159 if( nArg
>2 && c
=='i' ){
7160 /* It is an historical accident that the .indexes command shows an error
7161 ** when called with the wrong number of arguments whereas the .tables
7162 ** command does not. */
7163 raw_printf(stderr
, "Usage: .indexes ?LIKE-PATTERN?\n");
7165 goto meta_command_exit
;
7167 for(ii
=0; sqlite3_step(pStmt
)==SQLITE_ROW
; ii
++){
7168 const char *zDbName
= (const char*)sqlite3_column_text(pStmt
, 1);
7169 if( zDbName
==0 ) continue;
7170 if( s
.z
&& s
.z
[0] ) appendText(&s
, " UNION ALL ", 0);
7171 if( sqlite3_stricmp(zDbName
, "main")==0 ){
7172 appendText(&s
, "SELECT name FROM ", 0);
7174 appendText(&s
, "SELECT ", 0);
7175 appendText(&s
, zDbName
, '\'');
7176 appendText(&s
, "||'.'||name FROM ", 0);
7178 appendText(&s
, zDbName
, '"');
7179 appendText(&s
, ".sqlite_master ", 0);
7181 appendText(&s
," WHERE type IN ('table','view')"
7182 " AND name NOT LIKE 'sqlite_%'"
7183 " AND name LIKE ?1", 0);
7185 appendText(&s
," WHERE type='index'"
7186 " AND tbl_name LIKE ?1", 0);
7189 rc
= sqlite3_finalize(pStmt
);
7190 appendText(&s
, " ORDER BY 1", 0);
7191 rc
= sqlite3_prepare_v2(p
->db
, s
.z
, -1, &pStmt
, 0);
7193 if( rc
) return shellDatabaseError(p
->db
);
7195 /* Run the SQL statement prepared by the above block. Store the results
7196 ** as an array of nul-terminated strings in azResult[]. */
7200 sqlite3_bind_text(pStmt
, 1, azArg
[1], -1, SQLITE_TRANSIENT
);
7202 sqlite3_bind_text(pStmt
, 1, "%", -1, SQLITE_STATIC
);
7204 while( sqlite3_step(pStmt
)==SQLITE_ROW
){
7207 int n2
= nAlloc
*2 + 10;
7208 azNew
= sqlite3_realloc64(azResult
, sizeof(azResult
[0])*n2
);
7210 rc
= shellNomemError();
7216 azResult
[nRow
] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt
, 0));
7217 if( 0==azResult
[nRow
] ){
7218 rc
= shellNomemError();
7223 if( sqlite3_finalize(pStmt
)!=SQLITE_OK
){
7224 rc
= shellDatabaseError(p
->db
);
7227 /* Pretty-print the contents of array azResult[] to the output */
7228 if( rc
==0 && nRow
>0 ){
7229 int len
, maxlen
= 0;
7231 int nPrintCol
, nPrintRow
;
7232 for(i
=0; i
<nRow
; i
++){
7233 len
= strlen30(azResult
[i
]);
7234 if( len
>maxlen
) maxlen
= len
;
7236 nPrintCol
= 80/(maxlen
+2);
7237 if( nPrintCol
<1 ) nPrintCol
= 1;
7238 nPrintRow
= (nRow
+ nPrintCol
- 1)/nPrintCol
;
7239 for(i
=0; i
<nPrintRow
; i
++){
7240 for(j
=i
; j
<nRow
; j
+=nPrintRow
){
7241 char *zSp
= j
<nPrintRow
? "" : " ";
7242 utf8_printf(p
->out
, "%s%-*s", zSp
, maxlen
,
7243 azResult
[j
] ? azResult
[j
]:"");
7245 raw_printf(p
->out
, "\n");
7249 for(ii
=0; ii
<nRow
; ii
++) sqlite3_free(azResult
[ii
]);
7250 sqlite3_free(azResult
);
7253 /* Begin redirecting output to the file "testcase-out.txt" */
7254 if( c
=='t' && strcmp(azArg
[0],"testcase")==0 ){
7256 p
->out
= output_file_open("testcase-out.txt");
7258 raw_printf(stderr
, "Error: cannot open 'testcase-out.txt'\n");
7261 sqlite3_snprintf(sizeof(p
->zTestcase
), p
->zTestcase
, "%s", azArg
[1]);
7263 sqlite3_snprintf(sizeof(p
->zTestcase
), p
->zTestcase
, "?");
7267 #ifndef SQLITE_UNTESTABLE
7268 if( c
=='t' && n
>=8 && strncmp(azArg
[0], "testctrl", n
)==0 && nArg
>=2 ){
7269 static const struct {
7270 const char *zCtrlName
; /* Name of a test-control option */
7271 int ctrlCode
; /* Integer code for that option */
7273 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE
},
7274 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE
},
7275 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET
},
7276 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST
},
7277 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL
},
7278 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
},
7279 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE
},
7280 { "assert", SQLITE_TESTCTRL_ASSERT
},
7281 { "always", SQLITE_TESTCTRL_ALWAYS
},
7282 { "reserve", SQLITE_TESTCTRL_RESERVE
},
7283 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS
},
7284 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD
},
7285 { "byteorder", SQLITE_TESTCTRL_BYTEORDER
},
7286 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT
},
7287 { "imposter", SQLITE_TESTCTRL_IMPOSTER
},
7294 /* convert testctrl text option to value. allow any unique prefix
7295 ** of the option name, or a numerical value. */
7296 n2
= strlen30(azArg
[1]);
7297 for(i
=0; i
<ArraySize(aCtrl
); i
++){
7298 if( strncmp(azArg
[1], aCtrl
[i
].zCtrlName
, n2
)==0 ){
7300 testctrl
= aCtrl
[i
].ctrlCode
;
7302 utf8_printf(stderr
, "ambiguous option name: \"%s\"\n", azArg
[1]);
7308 if( testctrl
<0 ) testctrl
= (int)integerValue(azArg
[1]);
7309 if( (testctrl
<SQLITE_TESTCTRL_FIRST
) || (testctrl
>SQLITE_TESTCTRL_LAST
) ){
7310 utf8_printf(stderr
,"Error: invalid testctrl option: %s\n", azArg
[1]);
7314 /* sqlite3_test_control(int, db, int) */
7315 case SQLITE_TESTCTRL_OPTIMIZATIONS
:
7316 case SQLITE_TESTCTRL_RESERVE
:
7318 int opt
= (int)strtol(azArg
[2], 0, 0);
7319 rc2
= sqlite3_test_control(testctrl
, p
->db
, opt
);
7320 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
7322 utf8_printf(stderr
,"Error: testctrl %s takes a single int option\n",
7327 /* sqlite3_test_control(int) */
7328 case SQLITE_TESTCTRL_PRNG_SAVE
:
7329 case SQLITE_TESTCTRL_PRNG_RESTORE
:
7330 case SQLITE_TESTCTRL_PRNG_RESET
:
7331 case SQLITE_TESTCTRL_BYTEORDER
:
7333 rc2
= sqlite3_test_control(testctrl
);
7334 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
7336 utf8_printf(stderr
,"Error: testctrl %s takes no options\n",
7341 /* sqlite3_test_control(int, uint) */
7342 case SQLITE_TESTCTRL_PENDING_BYTE
:
7344 unsigned int opt
= (unsigned int)integerValue(azArg
[2]);
7345 rc2
= sqlite3_test_control(testctrl
, opt
);
7346 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
7348 utf8_printf(stderr
,"Error: testctrl %s takes a single unsigned"
7349 " int option\n", azArg
[1]);
7353 /* sqlite3_test_control(int, int) */
7354 case SQLITE_TESTCTRL_ASSERT
:
7355 case SQLITE_TESTCTRL_ALWAYS
:
7356 case SQLITE_TESTCTRL_NEVER_CORRUPT
:
7358 int opt
= booleanValue(azArg
[2]);
7359 rc2
= sqlite3_test_control(testctrl
, opt
);
7360 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
7362 utf8_printf(stderr
,"Error: testctrl %s takes a single int option\n",
7367 /* sqlite3_test_control(int, char *) */
7368 #ifdef SQLITE_N_KEYWORD
7369 case SQLITE_TESTCTRL_ISKEYWORD
:
7371 const char *opt
= azArg
[2];
7372 rc2
= sqlite3_test_control(testctrl
, opt
);
7373 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
7376 "Error: testctrl %s takes a single char * option\n",
7382 case SQLITE_TESTCTRL_IMPOSTER
:
7384 rc2
= sqlite3_test_control(testctrl
, p
->db
,
7386 integerValue(azArg
[3]),
7387 integerValue(azArg
[4]));
7388 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
7390 raw_printf(stderr
,"Usage: .testctrl imposter dbName onoff tnum\n");
7394 case SQLITE_TESTCTRL_BITVEC_TEST
:
7395 case SQLITE_TESTCTRL_FAULT_INSTALL
:
7396 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
:
7399 "Error: CLI support for testctrl %s not implemented\n",
7405 #endif /* !defined(SQLITE_UNTESTABLE) */
7407 if( c
=='t' && n
>4 && strncmp(azArg
[0], "timeout", n
)==0 ){
7409 sqlite3_busy_timeout(p
->db
, nArg
>=2 ? (int)integerValue(azArg
[1]) : 0);
7412 if( c
=='t' && n
>=5 && strncmp(azArg
[0], "timer", n
)==0 ){
7414 enableTimer
= booleanValue(azArg
[1]);
7415 if( enableTimer
&& !HAS_TIMER
){
7416 raw_printf(stderr
, "Error: timer not available on this system.\n");
7420 raw_printf(stderr
, "Usage: .timer on|off\n");
7425 if( c
=='t' && strncmp(azArg
[0], "trace", n
)==0 ){
7428 raw_printf(stderr
, "Usage: .trace FILE|off\n");
7430 goto meta_command_exit
;
7432 output_file_close(p
->traceOut
);
7433 p
->traceOut
= output_file_open(azArg
[1]);
7434 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
7435 if( p
->traceOut
==0 ){
7436 sqlite3_trace_v2(p
->db
, 0, 0, 0);
7438 sqlite3_trace_v2(p
->db
, SQLITE_TRACE_STMT
, sql_trace_callback
,p
->traceOut
);
7443 #if SQLITE_USER_AUTHENTICATION
7444 if( c
=='u' && strncmp(azArg
[0], "user", n
)==0 ){
7446 raw_printf(stderr
, "Usage: .user SUBCOMMAND ...\n");
7448 goto meta_command_exit
;
7451 if( strcmp(azArg
[1],"login")==0 ){
7453 raw_printf(stderr
, "Usage: .user login USER PASSWORD\n");
7455 goto meta_command_exit
;
7457 rc
= sqlite3_user_authenticate(p
->db
, azArg
[2], azArg
[3],
7458 (int)strlen(azArg
[3]));
7460 utf8_printf(stderr
, "Authentication failed for user %s\n", azArg
[2]);
7463 }else if( strcmp(azArg
[1],"add")==0 ){
7465 raw_printf(stderr
, "Usage: .user add USER PASSWORD ISADMIN\n");
7467 goto meta_command_exit
;
7469 rc
= sqlite3_user_add(p
->db
, azArg
[2],
7470 azArg
[3], (int)strlen(azArg
[3]),
7471 booleanValue(azArg
[4]));
7473 raw_printf(stderr
, "User-Add failed: %d\n", rc
);
7476 }else if( strcmp(azArg
[1],"edit")==0 ){
7478 raw_printf(stderr
, "Usage: .user edit USER PASSWORD ISADMIN\n");
7480 goto meta_command_exit
;
7482 rc
= sqlite3_user_change(p
->db
, azArg
[2],
7483 azArg
[3], (int)strlen(azArg
[3]),
7484 booleanValue(azArg
[4]));
7486 raw_printf(stderr
, "User-Edit failed: %d\n", rc
);
7489 }else if( strcmp(azArg
[1],"delete")==0 ){
7491 raw_printf(stderr
, "Usage: .user delete USER\n");
7493 goto meta_command_exit
;
7495 rc
= sqlite3_user_delete(p
->db
, azArg
[2]);
7497 raw_printf(stderr
, "User-Delete failed: %d\n", rc
);
7501 raw_printf(stderr
, "Usage: .user login|add|edit|delete ...\n");
7503 goto meta_command_exit
;
7506 #endif /* SQLITE_USER_AUTHENTICATION */
7508 if( c
=='v' && strncmp(azArg
[0], "version", n
)==0 ){
7509 utf8_printf(p
->out
, "SQLite %s %s\n" /*extra-version-info*/,
7510 sqlite3_libversion(), sqlite3_sourceid());
7513 if( c
=='v' && strncmp(azArg
[0], "vfsinfo", n
)==0 ){
7514 const char *zDbName
= nArg
==2 ? azArg
[1] : "main";
7515 sqlite3_vfs
*pVfs
= 0;
7517 sqlite3_file_control(p
->db
, zDbName
, SQLITE_FCNTL_VFS_POINTER
, &pVfs
);
7519 utf8_printf(p
->out
, "vfs.zName = \"%s\"\n", pVfs
->zName
);
7520 raw_printf(p
->out
, "vfs.iVersion = %d\n", pVfs
->iVersion
);
7521 raw_printf(p
->out
, "vfs.szOsFile = %d\n", pVfs
->szOsFile
);
7522 raw_printf(p
->out
, "vfs.mxPathname = %d\n", pVfs
->mxPathname
);
7527 if( c
=='v' && strncmp(azArg
[0], "vfslist", n
)==0 ){
7529 sqlite3_vfs
*pCurrent
= 0;
7531 sqlite3_file_control(p
->db
, "main", SQLITE_FCNTL_VFS_POINTER
, &pCurrent
);
7533 for(pVfs
=sqlite3_vfs_find(0); pVfs
; pVfs
=pVfs
->pNext
){
7534 utf8_printf(p
->out
, "vfs.zName = \"%s\"%s\n", pVfs
->zName
,
7535 pVfs
==pCurrent
? " <--- CURRENT" : "");
7536 raw_printf(p
->out
, "vfs.iVersion = %d\n", pVfs
->iVersion
);
7537 raw_printf(p
->out
, "vfs.szOsFile = %d\n", pVfs
->szOsFile
);
7538 raw_printf(p
->out
, "vfs.mxPathname = %d\n", pVfs
->mxPathname
);
7540 raw_printf(p
->out
, "-----------------------------------\n");
7545 if( c
=='v' && strncmp(azArg
[0], "vfsname", n
)==0 ){
7546 const char *zDbName
= nArg
==2 ? azArg
[1] : "main";
7549 sqlite3_file_control(p
->db
, zDbName
, SQLITE_FCNTL_VFSNAME
, &zVfsName
);
7551 utf8_printf(p
->out
, "%s\n", zVfsName
);
7552 sqlite3_free(zVfsName
);
7557 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
7558 if( c
=='w' && strncmp(azArg
[0], "wheretrace", n
)==0 ){
7559 sqlite3WhereTrace
= nArg
>=2 ? booleanValue(azArg
[1]) : 0xff;
7563 if( c
=='w' && strncmp(azArg
[0], "width", n
)==0 ){
7565 assert( nArg
<=ArraySize(azArg
) );
7566 for(j
=1; j
<nArg
&& j
<ArraySize(p
->colWidth
); j
++){
7567 p
->colWidth
[j
-1] = (int)integerValue(azArg
[j
]);
7572 utf8_printf(stderr
, "Error: unknown command or invalid arguments: "
7573 " \"%s\". Enter \".help\" for help\n", azArg
[0]);
7580 if( p
->outCount
==0 ) output_reset(p
);
7586 ** Return TRUE if a semicolon occurs anywhere in the first N characters
7589 static int line_contains_semicolon(const char *z
, int N
){
7591 for(i
=0; i
<N
; i
++){ if( z
[i
]==';' ) return 1; }
7596 ** Test to see if a line consists entirely of whitespace.
7598 static int _all_whitespace(const char *z
){
7600 if( IsSpace(z
[0]) ) continue;
7601 if( *z
=='/' && z
[1]=='*' ){
7603 while( *z
&& (*z
!='*' || z
[1]!='/') ){ z
++; }
7604 if( *z
==0 ) return 0;
7608 if( *z
=='-' && z
[1]=='-' ){
7610 while( *z
&& *z
!='\n' ){ z
++; }
7611 if( *z
==0 ) return 1;
7620 ** Return TRUE if the line typed in is an SQL command terminator other
7621 ** than a semi-colon. The SQL Server style "go" command is understood
7622 ** as is the Oracle "/".
7624 static int line_is_command_terminator(const char *zLine
){
7625 while( IsSpace(zLine
[0]) ){ zLine
++; };
7626 if( zLine
[0]=='/' && _all_whitespace(&zLine
[1]) ){
7627 return 1; /* Oracle */
7629 if( ToLower(zLine
[0])=='g' && ToLower(zLine
[1])=='o'
7630 && _all_whitespace(&zLine
[2]) ){
7631 return 1; /* SQL Server */
7637 ** Return true if zSql is a complete SQL statement. Return false if it
7638 ** ends in the middle of a string literal or C-style comment.
7640 static int line_is_complete(char *zSql
, int nSql
){
7642 if( zSql
==0 ) return 1;
7645 rc
= sqlite3_complete(zSql
);
7651 ** Run a single line of SQL
7653 static int runOneSqlLine(ShellState
*p
, char *zSql
, FILE *in
, int startline
){
7658 if( ShellHasFlag(p
,SHFLG_Backslash
) ) resolve_backslashes(zSql
);
7660 rc
= shell_exec(p
->db
, zSql
, shell_callback
, p
, &zErrMsg
);
7662 if( rc
|| zErrMsg
){
7664 if( in
!=0 || !stdin_is_interactive
){
7665 sqlite3_snprintf(sizeof(zPrefix
), zPrefix
,
7666 "Error: near line %d:", startline
);
7668 sqlite3_snprintf(sizeof(zPrefix
), zPrefix
, "Error:");
7671 utf8_printf(stderr
, "%s %s\n", zPrefix
, zErrMsg
);
7672 sqlite3_free(zErrMsg
);
7675 utf8_printf(stderr
, "%s %s\n", zPrefix
, sqlite3_errmsg(p
->db
));
7678 }else if( ShellHasFlag(p
, SHFLG_CountChanges
) ){
7679 raw_printf(p
->out
, "changes: %3d total_changes: %d\n",
7680 sqlite3_changes(p
->db
), sqlite3_total_changes(p
->db
));
7687 ** Read input from *in and process it. If *in==0 then input
7688 ** is interactive - the user is typing it it. Otherwise, input
7689 ** is coming from a file or device. A prompt is issued and history
7690 ** is saved only if input is interactive. An interrupt signal will
7691 ** cause this routine to exit immediately, unless input is interactive.
7693 ** Return the number of errors.
7695 static int process_input(ShellState
*p
, FILE *in
){
7696 char *zLine
= 0; /* A single input line */
7697 char *zSql
= 0; /* Accumulated SQL text */
7698 int nLine
; /* Length of current line */
7699 int nSql
= 0; /* Bytes of zSql[] used */
7700 int nAlloc
= 0; /* Allocated zSql[] space */
7701 int nSqlPrior
= 0; /* Bytes of zSql[] used by prior line */
7702 int rc
; /* Error code */
7703 int errCnt
= 0; /* Number of errors seen */
7704 int lineno
= 0; /* Current line number */
7705 int startline
= 0; /* Line number for start of current input */
7707 while( errCnt
==0 || !bail_on_error
|| (in
==0 && stdin_is_interactive
) ){
7709 zLine
= one_input_line(in
, zLine
, nSql
>0);
7712 if( in
==0 && stdin_is_interactive
) printf("\n");
7715 if( seenInterrupt
){
7720 if( nSql
==0 && _all_whitespace(zLine
) ){
7721 if( ShellHasFlag(p
, SHFLG_Echo
) ) printf("%s\n", zLine
);
7724 if( zLine
&& zLine
[0]=='.' && nSql
==0 ){
7725 if( ShellHasFlag(p
, SHFLG_Echo
) ) printf("%s\n", zLine
);
7726 rc
= do_meta_command(zLine
, p
);
7727 if( rc
==2 ){ /* exit requested */
7734 if( line_is_command_terminator(zLine
) && line_is_complete(zSql
, nSql
) ){
7735 memcpy(zLine
,";",2);
7737 nLine
= strlen30(zLine
);
7738 if( nSql
+nLine
+2>=nAlloc
){
7739 nAlloc
= nSql
+nLine
+100;
7740 zSql
= realloc(zSql
, nAlloc
);
7742 raw_printf(stderr
, "Error: out of memory\n");
7749 for(i
=0; zLine
[i
] && IsSpace(zLine
[i
]); i
++){}
7750 assert( nAlloc
>0 && zSql
!=0 );
7751 memcpy(zSql
, zLine
+i
, nLine
+1-i
);
7755 zSql
[nSql
++] = '\n';
7756 memcpy(zSql
+nSql
, zLine
, nLine
+1);
7759 if( nSql
&& line_contains_semicolon(&zSql
[nSqlPrior
], nSql
-nSqlPrior
)
7760 && sqlite3_complete(zSql
) ){
7761 errCnt
+= runOneSqlLine(p
, zSql
, in
, startline
);
7767 }else if( nSql
&& _all_whitespace(zSql
) ){
7768 if( ShellHasFlag(p
, SHFLG_Echo
) ) printf("%s\n", zSql
);
7772 if( nSql
&& !_all_whitespace(zSql
) ){
7773 runOneSqlLine(p
, zSql
, in
, startline
);
7781 ** Return a pathname which is the user's home directory. A
7782 ** 0 return indicates an error of some kind.
7784 static char *find_home_dir(int clearFlag
){
7785 static char *home_dir
= NULL
;
7791 if( home_dir
) return home_dir
;
7793 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
7794 && !defined(__RTP__) && !defined(_WRS_KERNEL)
7796 struct passwd
*pwent
;
7797 uid_t uid
= getuid();
7798 if( (pwent
=getpwuid(uid
)) != NULL
) {
7799 home_dir
= pwent
->pw_dir
;
7804 #if defined(_WIN32_WCE)
7805 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
7810 #if defined(_WIN32) || defined(WIN32)
7812 home_dir
= getenv("USERPROFILE");
7817 home_dir
= getenv("HOME");
7820 #if defined(_WIN32) || defined(WIN32)
7822 char *zDrive
, *zPath
;
7824 zDrive
= getenv("HOMEDRIVE");
7825 zPath
= getenv("HOMEPATH");
7826 if( zDrive
&& zPath
){
7827 n
= strlen30(zDrive
) + strlen30(zPath
) + 1;
7828 home_dir
= malloc( n
);
7829 if( home_dir
==0 ) return 0;
7830 sqlite3_snprintf(n
, home_dir
, "%s%s", zDrive
, zPath
);
7837 #endif /* !_WIN32_WCE */
7840 int n
= strlen30(home_dir
) + 1;
7841 char *z
= malloc( n
);
7842 if( z
) memcpy(z
, home_dir
, n
);
7850 ** Read input from the file given by sqliterc_override. Or if that
7851 ** parameter is NULL, take input from ~/.sqliterc
7853 ** Returns the number of errors.
7855 static void process_sqliterc(
7856 ShellState
*p
, /* Configuration data */
7857 const char *sqliterc_override
/* Name of config file. NULL to use default */
7859 char *home_dir
= NULL
;
7860 const char *sqliterc
= sqliterc_override
;
7864 if (sqliterc
== NULL
) {
7865 home_dir
= find_home_dir(0);
7867 raw_printf(stderr
, "-- warning: cannot find home directory;"
7868 " cannot read ~/.sqliterc\n");
7871 sqlite3_initialize();
7872 zBuf
= sqlite3_mprintf("%s/.sqliterc",home_dir
);
7875 in
= fopen(sqliterc
,"rb");
7877 if( stdin_is_interactive
){
7878 utf8_printf(stderr
,"-- Loading resources from %s\n",sqliterc
);
7880 process_input(p
,in
);
7887 ** Show available command line options
7889 static const char zOptions
[] =
7890 " -ascii set output mode to 'ascii'\n"
7891 " -bail stop after hitting an error\n"
7892 " -batch force batch I/O\n"
7893 " -column set output mode to 'column'\n"
7894 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
7895 " -csv set output mode to 'csv'\n"
7896 " -echo print commands before execution\n"
7897 " -init FILENAME read/process named file\n"
7898 " -[no]header turn headers on or off\n"
7899 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
7900 " -heap SIZE Size of heap for memsys3 or memsys5\n"
7902 " -help show this message\n"
7903 " -html set output mode to HTML\n"
7904 " -interactive force interactive I/O\n"
7905 " -line set output mode to 'line'\n"
7906 " -list set output mode to 'list'\n"
7907 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
7908 " -mmap N default mmap size set to N\n"
7909 #ifdef SQLITE_ENABLE_MULTIPLEX
7910 " -multiplex enable the multiplexor VFS\n"
7912 " -newline SEP set output row separator. Default: '\\n'\n"
7913 " -nullvalue TEXT set text string for NULL values. Default ''\n"
7914 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
7915 " -quote set output mode to 'quote'\n"
7916 " -separator SEP set output column separator. Default: '|'\n"
7917 " -stats print memory stats before each finalize\n"
7918 " -version show SQLite version\n"
7919 " -vfs NAME use NAME as the default VFS\n"
7920 #ifdef SQLITE_ENABLE_VFSTRACE
7921 " -vfstrace enable tracing of all VFS calls\n"
7924 static void usage(int showDetail
){
7926 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
7927 "FILENAME is the name of an SQLite database. A new database is created\n"
7928 "if the file does not previously exist.\n", Argv0
);
7930 utf8_printf(stderr
, "OPTIONS include:\n%s", zOptions
);
7932 raw_printf(stderr
, "Use the -help option for additional information\n");
7938 ** Initialize the state information in data
7940 static void main_init(ShellState
*data
) {
7941 memset(data
, 0, sizeof(*data
));
7942 data
->normalMode
= data
->cMode
= data
->mode
= MODE_List
;
7943 data
->autoExplain
= 1;
7944 memcpy(data
->colSeparator
,SEP_Column
, 2);
7945 memcpy(data
->rowSeparator
,SEP_Row
, 2);
7946 data
->showHeader
= 0;
7947 data
->shellFlgs
= SHFLG_Lookaside
;
7948 sqlite3_config(SQLITE_CONFIG_URI
, 1);
7949 sqlite3_config(SQLITE_CONFIG_LOG
, shellLog
, data
);
7950 sqlite3_config(SQLITE_CONFIG_MULTITHREAD
);
7951 sqlite3_snprintf(sizeof(mainPrompt
), mainPrompt
,"sqlite> ");
7952 sqlite3_snprintf(sizeof(continuePrompt
), continuePrompt
," ...> ");
7956 ** Output text to the console in a font that attracts extra attention.
7959 static void printBold(const char *zText
){
7960 HANDLE out
= GetStdHandle(STD_OUTPUT_HANDLE
);
7961 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo
;
7962 GetConsoleScreenBufferInfo(out
, &defaultScreenInfo
);
7963 SetConsoleTextAttribute(out
,
7964 FOREGROUND_RED
|FOREGROUND_INTENSITY
7966 printf("%s", zText
);
7967 SetConsoleTextAttribute(out
, defaultScreenInfo
.wAttributes
);
7970 static void printBold(const char *zText
){
7971 printf("\033[1m%s\033[0m", zText
);
7976 ** Get the argument to an --option. Throw an error and die if no argument
7979 static char *cmdline_option_value(int argc
, char **argv
, int i
){
7981 utf8_printf(stderr
, "%s: Error: missing argument to %s\n",
7982 argv
[0], argv
[argc
-1]);
7988 #ifndef SQLITE_SHELL_IS_UTF8
7989 # if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
7990 # define SQLITE_SHELL_IS_UTF8 (0)
7992 # define SQLITE_SHELL_IS_UTF8 (1)
7996 #if SQLITE_SHELL_IS_UTF8
7997 int SQLITE_CDECL
main(int argc
, char **argv
){
7999 int SQLITE_CDECL
wmain(int argc
, wchar_t **wargv
){
8004 const char *zInitFile
= 0;
8007 int warnInmemoryDb
= 0;
8012 setBinaryMode(stdin
, 0);
8013 setvbuf(stderr
, 0, _IONBF
, 0); /* Make sure stderr is unbuffered */
8014 stdin_is_interactive
= isatty(0);
8015 stdout_is_console
= isatty(1);
8017 #if USE_SYSTEM_SQLITE+0!=1
8018 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID
,60)!=0 ){
8019 utf8_printf(stderr
, "SQLite header and source version mismatch\n%s\n%s\n",
8020 sqlite3_sourceid(), SQLITE_SOURCE_ID
);
8025 #if !SQLITE_SHELL_IS_UTF8
8026 sqlite3_initialize();
8027 argv
= sqlite3_malloc64(sizeof(argv
[0])*argc
);
8029 raw_printf(stderr
, "out of memory\n");
8032 for(i
=0; i
<argc
; i
++){
8033 argv
[i
] = sqlite3_win32_unicode_to_utf8(wargv
[i
]);
8035 raw_printf(stderr
, "out of memory\n");
8040 assert( argc
>=1 && argv
&& argv
[0] );
8043 /* Make sure we have a valid signal handler early, before anything
8047 signal(SIGINT
, interrupt_handler
);
8050 #ifdef SQLITE_SHELL_DBNAME_PROC
8052 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
8053 ** of a C-function that will provide the name of the database file. Use
8054 ** this compile-time option to embed this shell program in larger
8056 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
8057 SQLITE_SHELL_DBNAME_PROC(&data
.zDbFilename
);
8062 /* Do an initial pass through the command-line argument to locate
8063 ** the name of the database file, the name of the initialization file,
8064 ** the size of the alternative malloc heap,
8065 ** and the first command to execute.
8067 for(i
=1; i
<argc
; i
++){
8071 if( data
.zDbFilename
==0 ){
8072 data
.zDbFilename
= z
;
8074 /* Excesss arguments are interpreted as SQL (or dot-commands) and
8075 ** mean that nothing is read from stdin */
8078 azCmd
= realloc(azCmd
, sizeof(azCmd
[0])*nCmd
);
8080 raw_printf(stderr
, "out of memory\n");
8086 if( z
[1]=='-' ) z
++;
8087 if( strcmp(z
,"-separator")==0
8088 || strcmp(z
,"-nullvalue")==0
8089 || strcmp(z
,"-newline")==0
8090 || strcmp(z
,"-cmd")==0
8092 (void)cmdline_option_value(argc
, argv
, ++i
);
8093 }else if( strcmp(z
,"-init")==0 ){
8094 zInitFile
= cmdline_option_value(argc
, argv
, ++i
);
8095 }else if( strcmp(z
,"-batch")==0 ){
8096 /* Need to check for batch mode here to so we can avoid printing
8097 ** informational messages (like from process_sqliterc) before
8098 ** we do the actual processing of arguments later in a second pass.
8100 stdin_is_interactive
= 0;
8101 }else if( strcmp(z
,"-heap")==0 ){
8102 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
8104 sqlite3_int64 szHeap
;
8106 zSize
= cmdline_option_value(argc
, argv
, ++i
);
8107 szHeap
= integerValue(zSize
);
8108 if( szHeap
>0x7fff0000 ) szHeap
= 0x7fff0000;
8109 sqlite3_config(SQLITE_CONFIG_HEAP
, malloc((int)szHeap
), (int)szHeap
, 64);
8111 (void)cmdline_option_value(argc
, argv
, ++i
);
8113 }else if( strcmp(z
,"-pagecache")==0 ){
8115 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
8116 if( sz
>70000 ) sz
= 70000;
8118 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
8119 sqlite3_config(SQLITE_CONFIG_PAGECACHE
,
8120 (n
>0 && sz
>0) ? malloc(n
*sz
) : 0, sz
, n
);
8121 data
.shellFlgs
|= SHFLG_Pagecache
;
8122 }else if( strcmp(z
,"-lookaside")==0 ){
8124 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
8126 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
8128 sqlite3_config(SQLITE_CONFIG_LOOKASIDE
, sz
, n
);
8129 if( sz
*n
==0 ) data
.shellFlgs
&= ~SHFLG_Lookaside
;
8130 #ifdef SQLITE_ENABLE_VFSTRACE
8131 }else if( strcmp(z
,"-vfstrace")==0 ){
8132 extern int vfstrace_register(
8133 const char *zTraceName
,
8134 const char *zOldVfsName
,
8135 int (*xOut
)(const char*,void*),
8139 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs
,stderr
,1);
8141 #ifdef SQLITE_ENABLE_MULTIPLEX
8142 }else if( strcmp(z
,"-multiplex")==0 ){
8143 extern int sqlite3_multiple_initialize(const char*,int);
8144 sqlite3_multiplex_initialize(0, 1);
8146 }else if( strcmp(z
,"-mmap")==0 ){
8147 sqlite3_int64 sz
= integerValue(cmdline_option_value(argc
,argv
,++i
));
8148 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE
, sz
, sz
);
8149 }else if( strcmp(z
,"-vfs")==0 ){
8150 sqlite3_vfs
*pVfs
= sqlite3_vfs_find(cmdline_option_value(argc
,argv
,++i
));
8152 sqlite3_vfs_register(pVfs
, 1);
8154 utf8_printf(stderr
, "no such VFS: \"%s\"\n", argv
[i
]);
8159 if( data
.zDbFilename
==0 ){
8160 #ifndef SQLITE_OMIT_MEMORYDB
8161 data
.zDbFilename
= ":memory:";
8162 warnInmemoryDb
= argc
==1;
8164 utf8_printf(stderr
,"%s: Error: no database filename specified\n", Argv0
);
8170 /* Go ahead and open the database file if it already exists. If the
8171 ** file does not exist, delay opening it. This prevents empty database
8172 ** files from being created if a user mistypes the database name argument
8173 ** to the sqlite command-line tool.
8175 if( access(data
.zDbFilename
, 0)==0 ){
8179 /* Process the initialization file if there is one. If no -init option
8180 ** is given on the command line, look for a file named ~/.sqliterc and
8181 ** try to process it.
8183 process_sqliterc(&data
,zInitFile
);
8185 /* Make a second pass through the command-line argument and set
8186 ** options. This second pass is delayed until after the initialization
8187 ** file is processed so that the command-line arguments will override
8188 ** settings in the initialization file.
8190 for(i
=1; i
<argc
; i
++){
8192 if( z
[0]!='-' ) continue;
8193 if( z
[1]=='-' ){ z
++; }
8194 if( strcmp(z
,"-init")==0 ){
8196 }else if( strcmp(z
,"-html")==0 ){
8197 data
.mode
= MODE_Html
;
8198 }else if( strcmp(z
,"-list")==0 ){
8199 data
.mode
= MODE_List
;
8200 }else if( strcmp(z
,"-quote")==0 ){
8201 data
.mode
= MODE_Quote
;
8202 }else if( strcmp(z
,"-line")==0 ){
8203 data
.mode
= MODE_Line
;
8204 }else if( strcmp(z
,"-column")==0 ){
8205 data
.mode
= MODE_Column
;
8206 }else if( strcmp(z
,"-csv")==0 ){
8207 data
.mode
= MODE_Csv
;
8208 memcpy(data
.colSeparator
,",",2);
8209 }else if( strcmp(z
,"-ascii")==0 ){
8210 data
.mode
= MODE_Ascii
;
8211 sqlite3_snprintf(sizeof(data
.colSeparator
), data
.colSeparator
,
8213 sqlite3_snprintf(sizeof(data
.rowSeparator
), data
.rowSeparator
,
8215 }else if( strcmp(z
,"-separator")==0 ){
8216 sqlite3_snprintf(sizeof(data
.colSeparator
), data
.colSeparator
,
8217 "%s",cmdline_option_value(argc
,argv
,++i
));
8218 }else if( strcmp(z
,"-newline")==0 ){
8219 sqlite3_snprintf(sizeof(data
.rowSeparator
), data
.rowSeparator
,
8220 "%s",cmdline_option_value(argc
,argv
,++i
));
8221 }else if( strcmp(z
,"-nullvalue")==0 ){
8222 sqlite3_snprintf(sizeof(data
.nullValue
), data
.nullValue
,
8223 "%s",cmdline_option_value(argc
,argv
,++i
));
8224 }else if( strcmp(z
,"-header")==0 ){
8225 data
.showHeader
= 1;
8226 }else if( strcmp(z
,"-noheader")==0 ){
8227 data
.showHeader
= 0;
8228 }else if( strcmp(z
,"-echo")==0 ){
8229 ShellSetFlag(&data
, SHFLG_Echo
);
8230 }else if( strcmp(z
,"-eqp")==0 ){
8232 }else if( strcmp(z
,"-eqpfull")==0 ){
8234 }else if( strcmp(z
,"-stats")==0 ){
8236 }else if( strcmp(z
,"-scanstats")==0 ){
8237 data
.scanstatsOn
= 1;
8238 }else if( strcmp(z
,"-backslash")==0 ){
8239 /* Undocumented command-line option: -backslash
8240 ** Causes C-style backslash escapes to be evaluated in SQL statements
8241 ** prior to sending the SQL into SQLite. Useful for injecting
8242 ** crazy bytes in the middle of SQL statements for testing and debugging.
8244 ShellSetFlag(&data
, SHFLG_Backslash
);
8245 }else if( strcmp(z
,"-bail")==0 ){
8247 }else if( strcmp(z
,"-version")==0 ){
8248 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
8250 }else if( strcmp(z
,"-interactive")==0 ){
8251 stdin_is_interactive
= 1;
8252 }else if( strcmp(z
,"-batch")==0 ){
8253 stdin_is_interactive
= 0;
8254 }else if( strcmp(z
,"-heap")==0 ){
8256 }else if( strcmp(z
,"-pagecache")==0 ){
8258 }else if( strcmp(z
,"-lookaside")==0 ){
8260 }else if( strcmp(z
,"-mmap")==0 ){
8262 }else if( strcmp(z
,"-vfs")==0 ){
8264 #ifdef SQLITE_ENABLE_VFSTRACE
8265 }else if( strcmp(z
,"-vfstrace")==0 ){
8268 #ifdef SQLITE_ENABLE_MULTIPLEX
8269 }else if( strcmp(z
,"-multiplex")==0 ){
8272 }else if( strcmp(z
,"-help")==0 ){
8274 }else if( strcmp(z
,"-cmd")==0 ){
8275 /* Run commands that follow -cmd first and separately from commands
8276 ** that simply appear on the command-line. This seems goofy. It would
8277 ** be better if all commands ran in the order that they appear. But
8278 ** we retain the goofy behavior for historical compatibility. */
8279 if( i
==argc
-1 ) break;
8280 z
= cmdline_option_value(argc
,argv
,++i
);
8282 rc
= do_meta_command(z
, &data
);
8283 if( rc
&& bail_on_error
) return rc
==2 ? 0 : rc
;
8286 rc
= shell_exec(data
.db
, z
, shell_callback
, &data
, &zErrMsg
);
8288 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
8289 if( bail_on_error
) return rc
!=0 ? rc
: 1;
8291 utf8_printf(stderr
,"Error: unable to process SQL \"%s\"\n", z
);
8292 if( bail_on_error
) return rc
;
8296 utf8_printf(stderr
,"%s: Error: unknown option: %s\n", Argv0
, z
);
8297 raw_printf(stderr
,"Use -help for a list of options.\n");
8300 data
.cMode
= data
.mode
;
8304 /* Run all arguments that do not begin with '-' as if they were separate
8305 ** command-line inputs, except for the argToSkip argument which contains
8306 ** the database filename.
8308 for(i
=0; i
<nCmd
; i
++){
8309 if( azCmd
[i
][0]=='.' ){
8310 rc
= do_meta_command(azCmd
[i
], &data
);
8311 if( rc
) return rc
==2 ? 0 : rc
;
8314 rc
= shell_exec(data
.db
, azCmd
[i
], shell_callback
, &data
, &zErrMsg
);
8316 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
8317 return rc
!=0 ? rc
: 1;
8319 utf8_printf(stderr
,"Error: unable to process SQL: %s\n", azCmd
[i
]);
8326 /* Run commands received from standard input
8328 if( stdin_is_interactive
){
8333 "SQLite version %s %.19s\n" /*extra-version-info*/
8334 "Enter \".help\" for usage hints.\n",
8335 sqlite3_libversion(), sqlite3_sourceid()
8337 if( warnInmemoryDb
){
8338 printf("Connected to a ");
8339 printBold("transient in-memory database");
8340 printf(".\nUse \".open FILENAME\" to reopen on a "
8341 "persistent database.\n");
8343 zHome
= find_home_dir(0);
8345 nHistory
= strlen30(zHome
) + 20;
8346 if( (zHistory
= malloc(nHistory
))!=0 ){
8347 sqlite3_snprintf(nHistory
, zHistory
,"%s/.sqlite_history", zHome
);
8350 if( zHistory
){ shell_read_history(zHistory
); }
8351 #if HAVE_READLINE || HAVE_EDITLINE
8352 rl_attempted_completion_function
= readline_completion
;
8353 #elif HAVE_LINENOISE
8354 linenoiseSetCompletionCallback(linenoise_completion
);
8356 rc
= process_input(&data
, 0);
8358 shell_stifle_history(2000);
8359 shell_write_history(zHistory
);
8363 rc
= process_input(&data
, stdin
);
8366 set_table_name(&data
, 0);
8368 session_close_all(&data
);
8369 sqlite3_close(data
.db
);
8371 sqlite3_free(data
.zFreeOnClose
);
8373 #if !SQLITE_SHELL_IS_UTF8
8374 for(i
=0; i
<argc
; i
++) sqlite3_free(argv
[i
]);