4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** This file contains code to implement the "sqlite" command line
13 ** utility for accessing SQLite databases.
15 #if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
16 /* This needs to come before any includes for MSVC compiler */
17 #define _CRT_SECURE_NO_WARNINGS
21 ** If requested, include the SQLite compiler options file for MSVC.
23 #if defined(INCLUDE_MSVC_H)
28 ** No support for loadable extensions in VxWorks.
30 #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
31 # define SQLITE_OMIT_LOAD_EXTENSION 1
35 ** Enable large-file support for fopen() and friends on unix.
37 #ifndef SQLITE_DISABLE_LFS
38 # define _LARGE_FILE 1
39 # ifndef _FILE_OFFSET_BITS
40 # define _FILE_OFFSET_BITS 64
42 # define _LARGEFILE_SOURCE 1
50 #if SQLITE_USER_AUTHENTICATION
51 # include "sqlite3userauth.h"
56 #if !defined(_WIN32) && !defined(WIN32)
58 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
62 # include <sys/types.h>
66 # include <readline/readline.h>
67 # include <readline/history.h>
71 # include <editline/readline.h>
74 #if HAVE_EDITLINE || HAVE_READLINE
76 # define shell_add_history(X) add_history(X)
77 # define shell_read_history(X) read_history(X)
78 # define shell_write_history(X) write_history(X)
79 # define shell_stifle_history(X) stifle_history(X)
80 # define shell_readline(X) readline(X)
84 # include "linenoise.h"
85 # define shell_add_history(X) linenoiseHistoryAdd(X)
86 # define shell_read_history(X) linenoiseHistoryLoad(X)
87 # define shell_write_history(X) linenoiseHistorySave(X)
88 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
89 # define shell_readline(X) linenoise(X)
93 # define shell_read_history(X)
94 # define shell_write_history(X)
95 # define shell_stifle_history(X)
97 # define SHELL_USE_LOCAL_GETLINE 1
101 #if defined(_WIN32) || defined(WIN32)
104 # define isatty(h) _isatty(h)
106 # define access(f,m) _access((f),(m))
109 # define popen _popen
111 # define pclose _pclose
113 /* Make sure isatty() has a prototype. */
114 extern int isatty(int);
116 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
117 /* popen and pclose are not C89 functions and so are
118 ** sometimes omitted from the <stdio.h> header */
119 extern FILE *popen(const char*,const char*);
120 extern int pclose(FILE*);
122 # define SQLITE_OMIT_POPEN 1
126 #if defined(_WIN32_WCE)
127 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
128 * thus we always assume that we have a console. That can be
129 * overridden with the -batch command line option.
134 /* ctype macros that work with signed characters */
135 #define IsSpace(X) isspace((unsigned char)X)
136 #define IsDigit(X) isdigit((unsigned char)X)
137 #define ToLower(X) (char)tolower((unsigned char)X)
139 /* On Windows, we normally run with output mode of TEXT so that \n characters
140 ** are automatically translated into \r\n. However, this behavior needs
141 ** to be disabled in some cases (ex: when generating CSV output and when
142 ** rendering quoted strings that contain \n characters). The following
143 ** routines take care of that.
145 #if defined(_WIN32) || defined(WIN32)
146 static void setBinaryMode(FILE *out){
148 _setmode(_fileno(out), _O_BINARY);
150 static void setTextMode(FILE *out){
152 _setmode(_fileno(out), _O_TEXT);
155 # define setBinaryMode(X)
156 # define setTextMode(X)
160 /* True if the timer is enabled */
161 static int enableTimer = 0;
163 /* Return the current wall-clock time */
164 static sqlite3_int64 timeOfDay(void){
165 static sqlite3_vfs *clockVfs = 0;
167 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
168 if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
169 clockVfs->xCurrentTimeInt64(clockVfs, &t);
172 clockVfs->xCurrentTime(clockVfs, &r);
173 t = (sqlite3_int64)(r*86400000.0);
178 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
179 #include <sys/time.h>
180 #include <sys/resource.h>
182 /* VxWorks does not support getrusage() as far as we can determine */
183 #if defined(_WRS_KERNEL) || defined(__RTP__)
185 struct timeval ru_utime; /* user CPU time used */
186 struct timeval ru_stime; /* system CPU time used */
188 #define getrusage(A,B) memset(B,0,sizeof(*B))
191 /* Saved resource information for the beginning of an operation */
192 static struct rusage sBegin; /* CPU time at start */
193 static sqlite3_int64 iBegin; /* Wall-clock time at start */
196 ** Begin timing an operation
198 static void beginTimer(void){
200 getrusage(RUSAGE_SELF, &sBegin);
201 iBegin = timeOfDay();
205 /* Return the difference of two time_structs in seconds */
206 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
207 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
208 (double)(pEnd->tv_sec - pStart->tv_sec);
212 ** Print the timing results.
214 static void endTimer(void){
216 sqlite3_int64 iEnd = timeOfDay();
218 getrusage(RUSAGE_SELF, &sEnd);
219 printf("Run Time: real %.3f user %f sys %f\n",
220 (iEnd - iBegin)*0.001,
221 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
222 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
226 #define BEGIN_TIMER beginTimer()
227 #define END_TIMER endTimer()
230 #elif (defined(_WIN32) || defined(WIN32))
234 /* Saved resource information for the beginning of an operation */
235 static HANDLE hProcess;
236 static FILETIME ftKernelBegin;
237 static FILETIME ftUserBegin;
238 static sqlite3_int64 ftWallBegin;
239 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
240 LPFILETIME, LPFILETIME);
241 static GETPROCTIMES getProcessTimesAddr = NULL;
244 ** Check to see if we have timer support. Return 1 if necessary
245 ** support found (or found previously).
247 static int hasTimer(void){
248 if( getProcessTimesAddr ){
251 /* GetProcessTimes() isn't supported in WIN95 and some other Windows
252 ** versions. See if the version we are running on has it, and if it
253 ** does, save off a pointer to it and the current process handle.
255 hProcess = GetCurrentProcess();
257 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
258 if( NULL != hinstLib ){
259 getProcessTimesAddr =
260 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
261 if( NULL != getProcessTimesAddr ){
264 FreeLibrary(hinstLib);
272 ** Begin timing an operation
274 static void beginTimer(void){
275 if( enableTimer && getProcessTimesAddr ){
276 FILETIME ftCreation, ftExit;
277 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
278 &ftKernelBegin,&ftUserBegin);
279 ftWallBegin = timeOfDay();
283 /* Return the difference of two FILETIME structs in seconds */
284 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
285 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
286 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
287 return (double) ((i64End - i64Start) / 10000000.0);
291 ** Print the timing results.
293 static void endTimer(void){
294 if( enableTimer && getProcessTimesAddr){
295 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
296 sqlite3_int64 ftWallEnd = timeOfDay();
297 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
298 printf("Run Time: real %.3f user %f sys %f\n",
299 (ftWallEnd - ftWallBegin)*0.001,
300 timeDiff(&ftUserBegin, &ftUserEnd),
301 timeDiff(&ftKernelBegin, &ftKernelEnd));
305 #define BEGIN_TIMER beginTimer()
306 #define END_TIMER endTimer()
307 #define HAS_TIMER hasTimer()
316 ** Used to prevent warnings about unused parameters
318 #define UNUSED_PARAMETER(x) (void)(x)
321 ** If the following flag is set, then command execution stops
322 ** at an error if we are not interactive.
324 static int bail_on_error = 0;
327 ** Threat stdin as an interactive input if the following variable
328 ** is true. Otherwise, assume stdin is connected to a file or pipe.
330 static int stdin_is_interactive = 1;
333 ** The following is the open SQLite database. We make a pointer
334 ** to this database a static variable so that it can be accessed
335 ** by the SIGINT handler to interrupt database processing.
337 static sqlite3 *globalDb = 0;
340 ** True if an interrupt (Control-C) has been received.
342 static volatile int seenInterrupt = 0;
345 ** This is the name of our program. It is set in main(), used
346 ** in a number of other places, mostly for error messages.
351 ** Prompt strings. Initialized in main. Settable with
352 ** .prompt main continue
354 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
355 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
358 ** Write I/O traces to the following stream.
360 #ifdef SQLITE_ENABLE_IOTRACE
361 static FILE *iotrace = 0;
365 ** This routine works like printf in that its first argument is a
366 ** format string and subsequent arguments are values to be substituted
367 ** in place of % fields. The result of formatting this string
368 ** is written to iotrace.
370 #ifdef SQLITE_ENABLE_IOTRACE
371 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
374 if( iotrace==0 ) return;
375 va_start(ap, zFormat);
376 z = sqlite3_vmprintf(zFormat, ap);
378 fprintf(iotrace, "%s", z);
385 ** Determines if a string is a number of not.
387 static int isNumber(const char *z, int *realnum){
388 if( *z=='-' || *z=='+' ) z++;
393 if( realnum ) *realnum = 0;
394 while( IsDigit(*z) ){ z++; }
397 if( !IsDigit(*z) ) return 0;
398 while( IsDigit(*z) ){ z++; }
399 if( realnum ) *realnum = 1;
401 if( *z=='e' || *z=='E' ){
403 if( *z=='+' || *z=='-' ) z++;
404 if( !IsDigit(*z) ) return 0;
405 while( IsDigit(*z) ){ z++; }
406 if( realnum ) *realnum = 1;
412 ** A global char* and an SQL function to access its current value
413 ** from within an SQL statement. This program used to use the
414 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
415 ** The correct way to do this with sqlite3 is to use the bind API, but
416 ** since the shell is built around the callback paradigm it would be a lot
417 ** of work. Instead just use this hack, which is quite harmless.
419 static const char *zShellStatic = 0;
420 static void shellstaticFunc(
421 sqlite3_context *context,
426 assert( zShellStatic );
427 UNUSED_PARAMETER(argc);
428 UNUSED_PARAMETER(argv);
429 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
434 ** This routine reads a line of text from FILE in, stores
435 ** the text in memory obtained from malloc() and returns a pointer
436 ** to the text. NULL is returned at end of file, or if malloc()
439 ** If zLine is not NULL then it is a malloced buffer returned from
440 ** a previous call to this routine that may be reused.
442 static char *local_getline(char *zLine, FILE *in){
443 int nLine = zLine==0 ? 0 : 100;
448 nLine = nLine*2 + 100;
449 zLine = realloc(zLine, nLine);
450 if( zLine==0 ) return 0;
452 if( fgets(&zLine[n], nLine - n, in)==0 ){
460 while( zLine[n] ) n++;
461 if( n>0 && zLine[n-1]=='\n' ){
463 if( n>0 && zLine[n-1]=='\r' ) n--;
472 ** Retrieve a single line of input text.
474 ** If in==0 then read from standard input and prompt before each line.
475 ** If isContinuation is true, then a continuation prompt is appropriate.
476 ** If isContinuation is zero, then the main prompt should be used.
478 ** If zPrior is not NULL then it is a buffer from a prior call to this
479 ** routine that can be reused.
481 ** The result is stored in space obtained from malloc() and must either
482 ** be freed by the caller or else passed back into this routine via the
483 ** zPrior argument for reuse.
485 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
489 zResult = local_getline(zPrior, in);
491 zPrompt = isContinuation ? continuePrompt : mainPrompt;
492 #if SHELL_USE_LOCAL_GETLINE
493 printf("%s", zPrompt);
495 zResult = local_getline(zPrior, stdin);
498 zResult = shell_readline(zPrompt);
499 if( zResult && *zResult ) shell_add_history(zResult);
506 ** Shell output mode information from before ".explain on",
507 ** saved so that it can be restored by ".explain off"
509 typedef struct SavedModeInfo SavedModeInfo;
510 struct SavedModeInfo {
511 int valid; /* Is there legit data in here? */
512 int mode; /* Mode prior to ".explain on" */
513 int showHeader; /* The ".header" setting prior to ".explain on" */
514 int colWidth[100]; /* Column widths prior to ".explain on" */
518 ** State information about the database connection is contained in an
519 ** instance of the following structure.
521 typedef struct ShellState ShellState;
523 sqlite3 *db; /* The database */
524 int echoOn; /* True to echo input commands */
525 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
526 int statsOn; /* True to display memory stats before each finalize */
527 int scanstatsOn; /* True to display scan stats before each finalize */
528 int backslashOn; /* Resolve C-style \x escapes in SQL input text */
529 int outCount; /* Revert to stdout when reaching zero */
530 int cnt; /* Number of records displayed so far */
531 FILE *out; /* Write results here */
532 FILE *traceOut; /* Output for sqlite3_trace() */
533 int nErr; /* Number of errors seen */
534 int mode; /* An output mode setting */
535 int writableSchema; /* True if PRAGMA writable_schema=ON */
536 int showHeader; /* True to show column names in List or Column mode */
537 unsigned shellFlgs; /* Various flags */
538 char *zDestTable; /* Name of destination table when MODE_Insert */
539 char colSeparator[20]; /* Column separator character for several modes */
540 char rowSeparator[20]; /* Row separator character for MODE_Ascii */
541 int colWidth[100]; /* Requested width of each column when in column mode*/
542 int actualWidth[100]; /* Actual width of each column */
543 char nullValue[20]; /* The text to print when a NULL comes back from
545 SavedModeInfo normalMode;/* Holds the mode just before .explain ON */
546 char outfile[FILENAME_MAX]; /* Filename for *out */
547 const char *zDbFilename; /* name of the database file */
548 char *zFreeOnClose; /* Filename to free when closing */
549 const char *zVfs; /* Name of VFS to use */
550 sqlite3_stmt *pStmt; /* Current statement if any. */
551 FILE *pLog; /* Write log output here */
552 int *aiIndent; /* Array of indents used in MODE_Explain */
553 int nIndent; /* Size of array aiIndent[] */
554 int iIndent; /* Index of current op in aiIndent[] */
558 ** These are the allowed shellFlgs values
560 #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
561 #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
562 #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
565 ** These are the allowed modes.
567 #define MODE_Line 0 /* One column per line. Blank line between records */
568 #define MODE_Column 1 /* One record per line in neat columns */
569 #define MODE_List 2 /* One record per line with a separator */
570 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
571 #define MODE_Html 4 /* Generate an XHTML table */
572 #define MODE_Insert 5 /* Generate SQL "insert" statements */
573 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
574 #define MODE_Csv 7 /* Quote strings, numbers are plain */
575 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
576 #define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */
578 static const char *modeDescr[] = {
592 ** These are the column/row/line separators used by the various
593 ** import/export modes.
595 #define SEP_Column "|"
598 #define SEP_Space " "
599 #define SEP_Comma ","
600 #define SEP_CrLf "\r\n"
601 #define SEP_Unit "\x1F"
602 #define SEP_Record "\x1E"
605 ** Number of elements in an array
607 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
610 ** Compute a string length that is limited to what can be stored in
611 ** lower 30 bits of a 32-bit signed integer.
613 static int strlen30(const char *z){
615 while( *z2 ){ z2++; }
616 return 0x3fffffff & (int)(z2 - z);
620 ** A callback for the sqlite3_log() interface.
622 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
623 ShellState *p = (ShellState*)pArg;
624 if( p->pLog==0 ) return;
625 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
630 ** Output the given string as a hex-encoded blob (eg. X'1234' )
632 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
634 char *zBlob = (char *)pBlob;
636 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
641 ** Output the given string as a quoted string using SQL quoting conventions.
643 static void output_quoted_string(FILE *out, const char *z){
648 if( z[i]=='\'' ) nSingle++;
651 fprintf(out,"'%s'",z);
655 for(i=0; z[i] && z[i]!='\''; i++){}
659 }else if( z[i]=='\'' ){
660 fprintf(out,"%.*s''",i,z);
673 ** Output the given string as a quoted according to C or TCL quoting rules.
675 static void output_c_string(FILE *out, const char *z){
678 while( (c = *(z++))!=0 ){
694 }else if( !isprint(c&0xff) ){
695 fprintf(out, "\\%03o", c&0xff);
704 ** Output the given string with characters that are special to
707 static void output_html_string(FILE *out, const char *z){
719 fprintf(out,"%.*s",i,z);
723 }else if( z[i]=='&' ){
724 fprintf(out,"&");
725 }else if( z[i]=='>' ){
727 }else if( z[i]=='\"' ){
728 fprintf(out,""");
729 }else if( z[i]=='\'' ){
730 fprintf(out,"'");
739 ** If a field contains any character identified by a 1 in the following
740 ** array, then the string must be quoted for CSV.
742 static const char needCsvQuote[] = {
743 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
744 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
745 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
746 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
747 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
748 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
750 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
751 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
752 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
753 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
754 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
755 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
756 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
757 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
758 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
762 ** Output a single term of CSV. Actually, p->colSeparator is used for
763 ** the separator, which may or may not be a comma. p->nullValue is
764 ** the null value. Strings are quoted if necessary. The separator
765 ** is only issued if bSep is true.
767 static void output_csv(ShellState *p, const char *z, int bSep){
770 fprintf(out,"%s",p->nullValue);
773 int nSep = strlen30(p->colSeparator);
775 if( needCsvQuote[((unsigned char*)z)[i]]
776 || (z[i]==p->colSeparator[0] &&
777 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
785 if( z[i]=='"' ) putc('"', out);
790 fprintf(out, "%s", z);
794 fprintf(p->out, "%s", p->colSeparator);
800 ** This routine runs when the user presses Ctrl-C
802 static void interrupt_handler(int NotUsed){
803 UNUSED_PARAMETER(NotUsed);
805 if( seenInterrupt>2 ) exit(1);
806 if( globalDb ) sqlite3_interrupt(globalDb);
811 ** This is the callback routine that the shell
812 ** invokes for each row of a query result.
814 static int shell_callback(
816 int nArg, /* Number of result columns */
817 char **azArg, /* Text of each result column */
818 char **azCol, /* Column names */
819 int *aiType /* Column types */
822 ShellState *p = (ShellState*)pArg;
827 if( azArg==0 ) break;
828 for(i=0; i<nArg; i++){
829 int len = strlen30(azCol[i] ? azCol[i] : "");
832 if( p->cnt++>0 ) fprintf(p->out, "%s", p->rowSeparator);
833 for(i=0; i<nArg; i++){
834 fprintf(p->out,"%*s = %s%s", w, azCol[i],
835 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
842 for(i=0; i<nArg; i++){
844 if( i<ArraySize(p->colWidth) ){
850 w = strlen30(azCol[i] ? azCol[i] : "");
852 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue);
855 if( i<ArraySize(p->actualWidth) ){
856 p->actualWidth[i] = w;
860 fprintf(p->out,"%*.*s%s",-w,-w,azCol[i],
861 i==nArg-1 ? p->rowSeparator : " ");
863 fprintf(p->out,"%-*.*s%s",w,w,azCol[i],
864 i==nArg-1 ? p->rowSeparator : " ");
869 for(i=0; i<nArg; i++){
871 if( i<ArraySize(p->actualWidth) ){
872 w = p->actualWidth[i];
877 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
878 "----------------------------------------------------------",
879 i==nArg-1 ? p->rowSeparator : " ");
883 if( azArg==0 ) break;
884 for(i=0; i<nArg; i++){
886 if( i<ArraySize(p->actualWidth) ){
887 w = p->actualWidth[i];
891 if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
892 w = strlen30(azArg[i]);
894 if( i==1 && p->aiIndent && p->pStmt ){
895 if( p->iIndent<p->nIndent ){
896 fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
901 fprintf(p->out,"%*.*s%s",-w,-w,
902 azArg[i] ? azArg[i] : p->nullValue,
903 i==nArg-1 ? p->rowSeparator : " ");
905 fprintf(p->out,"%-*.*s%s",w,w,
906 azArg[i] ? azArg[i] : p->nullValue,
907 i==nArg-1 ? p->rowSeparator : " ");
914 if( p->cnt++==0 && p->showHeader ){
915 for(i=0; i<nArg; i++){
916 fprintf(p->out,"%s%s",azCol[i],
917 i==nArg-1 ? p->rowSeparator : p->colSeparator);
920 if( azArg==0 ) break;
921 for(i=0; i<nArg; i++){
923 if( z==0 ) z = p->nullValue;
924 fprintf(p->out, "%s", z);
926 fprintf(p->out, "%s", p->colSeparator);
927 }else if( p->mode==MODE_Semi ){
928 fprintf(p->out, ";%s", p->rowSeparator);
930 fprintf(p->out, "%s", p->rowSeparator);
936 if( p->cnt++==0 && p->showHeader ){
937 fprintf(p->out,"<TR>");
938 for(i=0; i<nArg; i++){
939 fprintf(p->out,"<TH>");
940 output_html_string(p->out, azCol[i]);
941 fprintf(p->out,"</TH>\n");
943 fprintf(p->out,"</TR>\n");
945 if( azArg==0 ) break;
946 fprintf(p->out,"<TR>");
947 for(i=0; i<nArg; i++){
948 fprintf(p->out,"<TD>");
949 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
950 fprintf(p->out,"</TD>\n");
952 fprintf(p->out,"</TR>\n");
956 if( p->cnt++==0 && p->showHeader ){
957 for(i=0; i<nArg; i++){
958 output_c_string(p->out,azCol[i] ? azCol[i] : "");
959 if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
961 fprintf(p->out, "%s", p->rowSeparator);
963 if( azArg==0 ) break;
964 for(i=0; i<nArg; i++){
965 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
966 if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
968 fprintf(p->out, "%s", p->rowSeparator);
972 setBinaryMode(p->out);
973 if( p->cnt++==0 && p->showHeader ){
974 for(i=0; i<nArg; i++){
975 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
977 fprintf(p->out, "%s", p->rowSeparator);
980 for(i=0; i<nArg; i++){
981 output_csv(p, azArg[i], i<nArg-1);
983 fprintf(p->out, "%s", p->rowSeparator);
990 if( azArg==0 ) break;
991 fprintf(p->out,"INSERT INTO %s",p->zDestTable);
994 for(i=0; i<nArg; i++){
995 char *zSep = i>0 ? ",": "";
996 fprintf(p->out, "%s%s", zSep, azCol[i]);
1000 fprintf(p->out," VALUES(");
1001 for(i=0; i<nArg; i++){
1002 char *zSep = i>0 ? ",": "";
1003 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
1004 fprintf(p->out,"%sNULL",zSep);
1005 }else if( aiType && aiType[i]==SQLITE_TEXT ){
1006 if( zSep[0] ) fprintf(p->out,"%s",zSep);
1007 output_quoted_string(p->out, azArg[i]);
1008 }else if( aiType && (aiType[i]==SQLITE_INTEGER
1009 || aiType[i]==SQLITE_FLOAT) ){
1010 fprintf(p->out,"%s%s",zSep, azArg[i]);
1011 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
1012 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
1013 int nBlob = sqlite3_column_bytes(p->pStmt, i);
1014 if( zSep[0] ) fprintf(p->out,"%s",zSep);
1015 output_hex_blob(p->out, pBlob, nBlob);
1016 }else if( isNumber(azArg[i], 0) ){
1017 fprintf(p->out,"%s%s",zSep, azArg[i]);
1019 if( zSep[0] ) fprintf(p->out,"%s",zSep);
1020 output_quoted_string(p->out, azArg[i]);
1023 fprintf(p->out,");\n");
1027 if( p->cnt++==0 && p->showHeader ){
1028 for(i=0; i<nArg; i++){
1029 if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1030 fprintf(p->out,"%s",azCol[i] ? azCol[i] : "");
1032 fprintf(p->out, "%s", p->rowSeparator);
1034 if( azArg==0 ) break;
1035 for(i=0; i<nArg; i++){
1036 if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1037 fprintf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
1039 fprintf(p->out, "%s", p->rowSeparator);
1047 ** This is the callback routine that the SQLite library
1048 ** invokes for each row of a query result.
1050 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1051 /* since we don't have type info, call the shell_callback with a NULL value */
1052 return shell_callback(pArg, nArg, azArg, azCol, NULL);
1056 ** Set the destination table field of the ShellState structure to
1057 ** the name of the table given. Escape any quote characters in the
1060 static void set_table_name(ShellState *p, const char *zName){
1065 if( p->zDestTable ){
1066 free(p->zDestTable);
1069 if( zName==0 ) return;
1070 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1071 for(i=n=0; zName[i]; i++, n++){
1072 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1074 if( zName[i]=='\'' ) n++;
1077 if( needQuote ) n += 2;
1078 z = p->zDestTable = malloc( n+1 );
1080 fprintf(stderr,"Error: out of memory\n");
1084 if( needQuote ) z[n++] = '\'';
1085 for(i=0; zName[i]; i++){
1087 if( zName[i]=='\'' ) z[n++] = '\'';
1089 if( needQuote ) z[n++] = '\'';
1093 /* zIn is either a pointer to a NULL-terminated string in memory obtained
1094 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1095 ** added to zIn, and the result returned in memory obtained from malloc().
1096 ** zIn, if it was not NULL, is freed.
1098 ** If the third argument, quote, is not '\0', then it is used as a
1099 ** quote character for zAppend.
1101 static char *appendText(char *zIn, char const *zAppend, char quote){
1104 int nAppend = strlen30(zAppend);
1105 int nIn = (zIn?strlen30(zIn):0);
1107 len = nAppend+nIn+1;
1110 for(i=0; i<nAppend; i++){
1111 if( zAppend[i]==quote ) len++;
1115 zIn = (char *)realloc(zIn, len);
1121 char *zCsr = &zIn[nIn];
1123 for(i=0; i<nAppend; i++){
1124 *zCsr++ = zAppend[i];
1125 if( zAppend[i]==quote ) *zCsr++ = quote;
1129 assert( (zCsr-zIn)==len );
1131 memcpy(&zIn[nIn], zAppend, nAppend);
1140 ** Execute a query statement that will generate SQL output. Print
1141 ** the result columns, comma-separated, on a line and then add a
1142 ** semicolon terminator to the end of that line.
1144 ** If the number of columns is 1 and that column contains text "--"
1145 ** then write the semicolon on a separate line. That way, if a
1146 ** "--" comment occurs at the end of the statement, the comment
1147 ** won't consume the semicolon terminator.
1149 static int run_table_dump_query(
1150 ShellState *p, /* Query context */
1151 const char *zSelect, /* SELECT statement to extract content */
1152 const char *zFirstRow /* Print before first row, if not NULL */
1154 sqlite3_stmt *pSelect;
1159 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
1160 if( rc!=SQLITE_OK || !pSelect ){
1161 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1162 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1165 rc = sqlite3_step(pSelect);
1166 nResult = sqlite3_column_count(pSelect);
1167 while( rc==SQLITE_ROW ){
1169 fprintf(p->out, "%s", zFirstRow);
1172 z = (const char*)sqlite3_column_text(pSelect, 0);
1173 fprintf(p->out, "%s", z);
1174 for(i=1; i<nResult; i++){
1175 fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
1178 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
1180 fprintf(p->out, "\n;\n");
1182 fprintf(p->out, ";\n");
1184 rc = sqlite3_step(pSelect);
1186 rc = sqlite3_finalize(pSelect);
1187 if( rc!=SQLITE_OK ){
1188 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1189 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1195 ** Allocate space and save off current error string.
1197 static char *save_err_msg(
1198 sqlite3 *db /* Database to query */
1200 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1201 char *zErrMsg = sqlite3_malloc64(nErrMsg);
1203 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1209 ** Display memory stats.
1211 static int display_stats(
1212 sqlite3 *db, /* Database to query */
1213 ShellState *pArg, /* Pointer to ShellState */
1214 int bReset /* True to reset the stats */
1219 if( pArg && pArg->out ){
1222 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1224 "Memory Used: %d (max %d) bytes\n",
1227 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1228 fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1230 if( pArg->shellFlgs & SHFLG_Pagecache ){
1232 sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1234 "Number of Pcache Pages Used: %d (max %d) pages\n",
1238 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1240 "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1242 if( pArg->shellFlgs & SHFLG_Scratch ){
1244 sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1245 fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n",
1249 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1251 "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1254 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1255 fprintf(pArg->out, "Largest Allocation: %d bytes\n",
1258 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1259 fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1262 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1263 fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1265 #ifdef YYTRACKMAXSTACKDEPTH
1267 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1268 fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1273 if( pArg && pArg->out && db ){
1274 if( pArg->shellFlgs & SHFLG_Lookaside ){
1276 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
1277 &iCur, &iHiwtr, bReset);
1278 fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n",
1280 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
1281 &iCur, &iHiwtr, bReset);
1282 fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr);
1283 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
1284 &iCur, &iHiwtr, bReset);
1285 fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr);
1286 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
1287 &iCur, &iHiwtr, bReset);
1288 fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr);
1291 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1292 fprintf(pArg->out, "Pager Heap Usage: %d bytes\n",iCur);
1294 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1295 fprintf(pArg->out, "Page cache hits: %d\n", iCur);
1297 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1298 fprintf(pArg->out, "Page cache misses: %d\n", iCur);
1300 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1301 fprintf(pArg->out, "Page cache writes: %d\n", iCur);
1303 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1304 fprintf(pArg->out, "Schema Heap Usage: %d bytes\n",iCur);
1306 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1307 fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",iCur);
1310 if( pArg && pArg->out && db && pArg->pStmt ){
1311 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
1313 fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1314 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1315 fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1316 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
1317 fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1318 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
1319 fprintf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
1326 ** Display scan stats.
1328 static void display_scanstats(
1329 sqlite3 *db, /* Database to query */
1330 ShellState *pArg /* Pointer to ShellState */
1332 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
1333 UNUSED_PARAMETER(db);
1334 UNUSED_PARAMETER(pArg);
1337 fprintf(pArg->out, "-------- scanstats --------\n");
1339 for(k=0; k<=mx; k++){
1340 double rEstLoop = 1.0;
1342 sqlite3_stmt *p = pArg->pStmt;
1343 sqlite3_int64 nLoop, nVisit;
1346 const char *zExplain;
1347 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
1350 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
1351 if( iSid>mx ) mx = iSid;
1352 if( iSid!=k ) continue;
1354 rEstLoop = (double)nLoop;
1355 if( k>0 ) fprintf(pArg->out, "-------- subquery %d -------\n", k);
1358 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
1359 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
1360 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
1361 fprintf(pArg->out, "Loop %2d: %s\n", n, zExplain);
1364 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
1365 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
1369 fprintf(pArg->out, "---------------------------\n");
1374 ** Parameter azArray points to a zero-terminated array of strings. zStr
1375 ** points to a single nul-terminated string. Return non-zero if zStr
1376 ** is equal, according to strcmp(), to any of the strings in the array.
1377 ** Otherwise, return zero.
1379 static int str_in_array(const char *zStr, const char **azArray){
1381 for(i=0; azArray[i]; i++){
1382 if( 0==strcmp(zStr, azArray[i]) ) return 1;
1388 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1389 ** and populate the ShellState.aiIndent[] array with the number of
1390 ** spaces each opcode should be indented before it is output.
1392 ** The indenting rules are:
1394 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1395 ** all opcodes that occur between the p2 jump destination and the opcode
1396 ** itself by 2 spaces.
1398 ** * For each "Goto", if the jump destination is earlier in the program
1399 ** and ends on one of:
1400 ** Yield SeekGt SeekLt RowSetRead Rewind
1401 ** or if the P1 parameter is one instead of zero,
1402 ** then indent all opcodes between the earlier instruction
1403 ** and "Goto" by 2 spaces.
1405 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
1406 const char *zSql; /* The text of the SQL statement */
1407 const char *z; /* Used to check if this is an EXPLAIN */
1408 int *abYield = 0; /* True if op is an OP_Yield */
1409 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
1410 int iOp; /* Index of operation in p->aiIndent[] */
1412 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
1413 "NextIfOpen", "PrevIfOpen", 0 };
1414 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
1416 const char *azGoto[] = { "Goto", 0 };
1418 /* Try to figure out if this is really an EXPLAIN statement. If this
1419 ** cannot be verified, return early. */
1420 zSql = sqlite3_sql(pSql);
1421 if( zSql==0 ) return;
1422 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
1423 if( sqlite3_strnicmp(z, "explain", 7) ) return;
1425 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
1427 int iAddr = sqlite3_column_int(pSql, 0);
1428 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
1430 /* Set p2 to the P2 field of the current opcode. Then, assuming that
1431 ** p2 is an instruction address, set variable p2op to the index of that
1432 ** instruction in the aiIndent[] array. p2 and p2op may be different if
1433 ** the current instruction is part of a sub-program generated by an
1434 ** SQL trigger or foreign key. */
1435 int p2 = sqlite3_column_int(pSql, 3);
1436 int p2op = (p2 + (iOp-iAddr));
1438 /* Grow the p->aiIndent array as required */
1441 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
1442 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
1444 abYield[iOp] = str_in_array(zOp, azYield);
1445 p->aiIndent[iOp] = 0;
1448 if( str_in_array(zOp, azNext) ){
1449 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
1451 if( str_in_array(zOp, azGoto) && p2op<p->nIndent
1452 && (abYield[p2op] || sqlite3_column_int(pSql, 2))
1454 for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
1459 sqlite3_free(abYield);
1460 sqlite3_reset(pSql);
1464 ** Free the array allocated by explain_data_prepare().
1466 static void explain_data_delete(ShellState *p){
1467 sqlite3_free(p->aiIndent);
1474 ** Execute a statement or set of statements. Print
1475 ** any result rows/columns depending on the current mode
1476 ** set via the supplied callback.
1478 ** This is very similar to SQLite's built-in sqlite3_exec()
1479 ** function except it takes a slightly different callback
1480 ** and callback data argument.
1482 static int shell_exec(
1483 sqlite3 *db, /* An open database */
1484 const char *zSql, /* SQL to be evaluated */
1485 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1486 /* (not the same as sqlite3_exec) */
1487 ShellState *pArg, /* Pointer to ShellState */
1488 char **pzErrMsg /* Error msg written here */
1490 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1491 int rc = SQLITE_OK; /* Return Code */
1493 const char *zLeftover; /* Tail of unprocessed SQL */
1499 while( zSql[0] && (SQLITE_OK == rc) ){
1500 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1501 if( SQLITE_OK != rc ){
1503 *pzErrMsg = save_err_msg(db);
1507 /* this happens for a comment or white-space */
1509 while( IsSpace(zSql[0]) ) zSql++;
1513 /* save off the prepared statment handle and reset row count */
1515 pArg->pStmt = pStmt;
1519 /* echo the sql statement if echo on */
1520 if( pArg && pArg->echoOn ){
1521 const char *zStmtSql = sqlite3_sql(pStmt);
1522 fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1525 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1526 if( pArg && pArg->autoEQP ){
1527 sqlite3_stmt *pExplain;
1528 char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
1529 sqlite3_sql(pStmt));
1530 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
1531 if( rc==SQLITE_OK ){
1532 while( sqlite3_step(pExplain)==SQLITE_ROW ){
1533 fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0));
1534 fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
1535 fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
1536 fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
1539 sqlite3_finalize(pExplain);
1543 /* If the shell is currently in ".explain" mode, gather the extra
1544 ** data required to add indents to the output.*/
1545 if( pArg && pArg->mode==MODE_Explain ){
1546 explain_data_prepare(pArg, pStmt);
1549 /* perform the first step. this will tell us if we
1550 ** have a result set or not and how wide it is.
1552 rc = sqlite3_step(pStmt);
1553 /* if we have a result set... */
1554 if( SQLITE_ROW == rc ){
1555 /* if we have a callback... */
1557 /* allocate space for col name ptr, value ptr, and type */
1558 int nCol = sqlite3_column_count(pStmt);
1559 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
1563 char **azCols = (char **)pData; /* Names of result columns */
1564 char **azVals = &azCols[nCol]; /* Results */
1565 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1567 assert(sizeof(int) <= sizeof(char *));
1568 /* save off ptrs to column names */
1569 for(i=0; i<nCol; i++){
1570 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1573 /* extract the data and data types */
1574 for(i=0; i<nCol; i++){
1575 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
1576 if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
1579 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
1581 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1583 break; /* from for */
1587 /* if data and types extracted successfully... */
1588 if( SQLITE_ROW == rc ){
1589 /* call the supplied callback with the result row data */
1590 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1593 rc = sqlite3_step(pStmt);
1596 } while( SQLITE_ROW == rc );
1597 sqlite3_free(pData);
1601 rc = sqlite3_step(pStmt);
1602 } while( rc == SQLITE_ROW );
1606 explain_data_delete(pArg);
1608 /* print usage stats if stats on */
1609 if( pArg && pArg->statsOn ){
1610 display_stats(db, pArg, 0);
1613 /* print loop-counters if required */
1614 if( pArg && pArg->scanstatsOn ){
1615 display_scanstats(db, pArg);
1618 /* Finalize the statement just executed. If this fails, save a
1619 ** copy of the error message. Otherwise, set zSql to point to the
1620 ** next statement to execute. */
1621 rc2 = sqlite3_finalize(pStmt);
1622 if( rc!=SQLITE_NOMEM ) rc = rc2;
1623 if( rc==SQLITE_OK ){
1625 while( IsSpace(zSql[0]) ) zSql++;
1626 }else if( pzErrMsg ){
1627 *pzErrMsg = save_err_msg(db);
1630 /* clear saved stmt handle */
1642 ** This is a different callback routine used for dumping the database.
1643 ** Each row received by this callback consists of a table name,
1644 ** the table type ("index" or "table") and SQL to create the table.
1645 ** This routine should print text sufficient to recreate the table.
1647 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1652 const char *zPrepStmt = 0;
1653 ShellState *p = (ShellState *)pArg;
1655 UNUSED_PARAMETER(azCol);
1656 if( nArg!=3 ) return 1;
1661 if( strcmp(zTable, "sqlite_sequence")==0 ){
1662 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1663 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
1664 fprintf(p->out, "ANALYZE sqlite_master;\n");
1665 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1667 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1669 if( !p->writableSchema ){
1670 fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1671 p->writableSchema = 1;
1673 zIns = sqlite3_mprintf(
1674 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1675 "VALUES('table','%q','%q',0,'%q');",
1676 zTable, zTable, zSql);
1677 fprintf(p->out, "%s\n", zIns);
1681 fprintf(p->out, "%s;\n", zSql);
1684 if( strcmp(zType, "table")==0 ){
1685 sqlite3_stmt *pTableInfo = 0;
1687 char *zTableInfo = 0;
1691 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1692 zTableInfo = appendText(zTableInfo, zTable, '"');
1693 zTableInfo = appendText(zTableInfo, ");", 0);
1695 rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
1697 if( rc!=SQLITE_OK || !pTableInfo ){
1701 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1702 /* Always quote the table name, even if it appears to be pure ascii,
1703 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1704 zTmp = appendText(zTmp, zTable, '"');
1706 zSelect = appendText(zSelect, zTmp, '\'');
1709 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1710 rc = sqlite3_step(pTableInfo);
1711 while( rc==SQLITE_ROW ){
1712 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1713 zSelect = appendText(zSelect, "quote(", 0);
1714 zSelect = appendText(zSelect, zText, '"');
1715 rc = sqlite3_step(pTableInfo);
1716 if( rc==SQLITE_ROW ){
1717 zSelect = appendText(zSelect, "), ", 0);
1719 zSelect = appendText(zSelect, ") ", 0);
1723 rc = sqlite3_finalize(pTableInfo);
1724 if( rc!=SQLITE_OK || nRow==0 ){
1728 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1729 zSelect = appendText(zSelect, zTable, '"');
1731 rc = run_table_dump_query(p, zSelect, zPrepStmt);
1732 if( rc==SQLITE_CORRUPT ){
1733 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1734 run_table_dump_query(p, zSelect, 0);
1742 ** Run zQuery. Use dump_callback() as the callback routine so that
1743 ** the contents of the query are output as SQL statements.
1745 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1746 ** "ORDER BY rowid DESC" to the end.
1748 static int run_schema_dump_query(
1754 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1755 if( rc==SQLITE_CORRUPT ){
1757 int len = strlen30(zQuery);
1758 fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1760 fprintf(p->out, "/****** %s ******/\n", zErr);
1764 zQ2 = malloc( len+100 );
1765 if( zQ2==0 ) return rc;
1766 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1767 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1769 fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1771 rc = SQLITE_CORRUPT;
1780 ** Text of a help message
1782 static char zHelp[] =
1783 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1784 ".bail on|off Stop after hitting an error. Default OFF\n"
1785 ".binary on|off Turn binary output on or off. Default OFF\n"
1786 ".clone NEWDB Clone data into NEWDB from the existing database\n"
1787 ".databases List names and files of attached databases\n"
1788 ".dbinfo ?DB? Show status information about the database\n"
1789 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1790 " If TABLE specified, only dump tables matching\n"
1791 " LIKE pattern TABLE.\n"
1792 ".echo on|off Turn command echo on or off\n"
1793 ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n"
1794 ".exit Exit this program\n"
1795 ".explain ?on|off? Turn output mode suitable for EXPLAIN on or off.\n"
1796 " With no args, it turns EXPLAIN on.\n"
1797 ".fullschema Show schema and the content of sqlite_stat tables\n"
1798 ".headers on|off Turn display of headers on or off\n"
1799 ".help Show this message\n"
1800 ".import FILE TABLE Import data from FILE into TABLE\n"
1801 ".indexes ?TABLE? Show names of all indexes\n"
1802 " If TABLE specified, only show indexes for tables\n"
1803 " matching LIKE pattern TABLE.\n"
1804 #ifdef SQLITE_ENABLE_IOTRACE
1805 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1807 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT\n"
1808 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1809 ".load FILE ?ENTRY? Load an extension library\n"
1811 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1812 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1813 " ascii Columns/rows delimited by 0x1F and 0x1E\n"
1814 " csv Comma-separated values\n"
1815 " column Left-aligned columns. (See .width)\n"
1816 " html HTML <table> code\n"
1817 " insert SQL insert statements for TABLE\n"
1818 " line One value per line\n"
1819 " list Values delimited by .separator strings\n"
1820 " tabs Tab-separated values\n"
1821 " tcl TCL list elements\n"
1822 ".nullvalue STRING Use STRING in place of NULL values\n"
1823 ".once FILENAME Output for the next SQL command only to FILENAME\n"
1824 ".open ?FILENAME? Close existing database and reopen FILENAME\n"
1825 ".output ?FILENAME? Send output to FILENAME or stdout\n"
1826 ".print STRING... Print literal STRING\n"
1827 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1828 ".quit Exit this program\n"
1829 ".read FILENAME Execute SQL in FILENAME\n"
1830 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1831 ".save FILE Write in-memory database into FILE\n"
1832 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
1833 ".schema ?TABLE? Show the CREATE statements\n"
1834 " If TABLE specified, only show tables matching\n"
1835 " LIKE pattern TABLE.\n"
1836 ".separator COL ?ROW? Change the column separator and optionally the row\n"
1837 " separator for both the output mode and .import\n"
1838 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
1839 ".show Show the current values for various settings\n"
1840 ".stats on|off Turn stats on or off\n"
1841 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
1842 ".tables ?TABLE? List names of tables\n"
1843 " If TABLE specified, only list tables matching\n"
1844 " LIKE pattern TABLE.\n"
1845 ".timeout MS Try opening locked tables for MS milliseconds\n"
1846 ".timer on|off Turn SQL timer on or off\n"
1847 ".trace FILE|off Output each SQL statement as it is run\n"
1848 ".vfsname ?AUX? Print the name of the VFS stack\n"
1849 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1850 " Negative values right-justify\n"
1853 /* Forward reference */
1854 static int process_input(ShellState *p, FILE *in);
1856 ** Implementation of the "readfile(X)" SQL function. The entire content
1857 ** of the file named X is read and returned as a BLOB. NULL is returned
1858 ** if the file does not exist or is unreadable.
1860 static void readfileFunc(
1861 sqlite3_context *context,
1863 sqlite3_value **argv
1870 UNUSED_PARAMETER(argc);
1871 zName = (const char*)sqlite3_value_text(argv[0]);
1872 if( zName==0 ) return;
1873 in = fopen(zName, "rb");
1875 fseek(in, 0, SEEK_END);
1878 pBuf = sqlite3_malloc64( nIn );
1879 if( pBuf && 1==fread(pBuf, nIn, 1, in) ){
1880 sqlite3_result_blob(context, pBuf, nIn, sqlite3_free);
1888 ** Implementation of the "writefile(X,Y)" SQL function. The argument Y
1889 ** is written into file X. The number of bytes written is returned. Or
1890 ** NULL is returned if something goes wrong, such as being unable to open
1891 ** file X for writing.
1893 static void writefileFunc(
1894 sqlite3_context *context,
1896 sqlite3_value **argv
1903 UNUSED_PARAMETER(argc);
1904 zFile = (const char*)sqlite3_value_text(argv[0]);
1905 if( zFile==0 ) return;
1906 out = fopen(zFile, "wb");
1907 if( out==0 ) return;
1908 z = (const char*)sqlite3_value_blob(argv[1]);
1912 rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
1915 sqlite3_result_int64(context, rc);
1919 ** Make sure the database is open. If it is not, then open it. If
1920 ** the database fails to open, print an error message and exit.
1922 static void open_db(ShellState *p, int keepAlive){
1924 sqlite3_initialize();
1925 sqlite3_open(p->zDbFilename, &p->db);
1927 if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
1928 sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
1929 shellstaticFunc, 0, 0);
1931 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
1932 fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1933 p->zDbFilename, sqlite3_errmsg(p->db));
1934 if( keepAlive ) return;
1937 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1938 sqlite3_enable_load_extension(p->db, 1);
1940 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
1941 readfileFunc, 0, 0);
1942 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
1943 writefileFunc, 0, 0);
1948 ** Do C-language style dequoting.
1954 ** \v -> vertical tab
1956 ** \r -> carriage return
1961 ** \NNN -> ascii character NNN in octal
1963 static void resolve_backslashes(char *z){
1966 while( *z && *z!='\\' ) z++;
1967 for(i=j=0; (c = z[i])!=0; i++, j++){
1968 if( c=='\\' && z[i+1]!=0 ){
1986 }else if( c=='\'' ){
1988 }else if( c=='\\' ){
1990 }else if( c>='0' && c<='7' ){
1992 if( z[i+1]>='0' && z[i+1]<='7' ){
1994 c = (c<<3) + z[i] - '0';
1995 if( z[i+1]>='0' && z[i+1]<='7' ){
1997 c = (c<<3) + z[i] - '0';
2008 ** Return the value of a hexadecimal digit. Return -1 if the input
2009 ** is not a hex digit.
2011 static int hexDigitValue(char c){
2012 if( c>='0' && c<='9' ) return c - '0';
2013 if( c>='a' && c<='f' ) return c - 'a' + 10;
2014 if( c>='A' && c<='F' ) return c - 'A' + 10;
2019 ** Interpret zArg as an integer value, possibly with suffixes.
2021 static sqlite3_int64 integerValue(const char *zArg){
2022 sqlite3_int64 v = 0;
2023 static const struct { char *zSuffix; int iMult; } aMult[] = {
2025 { "MiB", 1024*1024 },
2026 { "GiB", 1024*1024*1024 },
2029 { "GB", 1000000000 },
2032 { "G", 1000000000 },
2039 }else if( zArg[0]=='+' ){
2042 if( zArg[0]=='0' && zArg[1]=='x' ){
2045 while( (x = hexDigitValue(zArg[0]))>=0 ){
2050 while( IsDigit(zArg[0]) ){
2051 v = v*10 + zArg[0] - '0';
2055 for(i=0; i<ArraySize(aMult); i++){
2056 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
2057 v *= aMult[i].iMult;
2061 return isNeg? -v : v;
2065 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2066 ** for TRUE and FALSE. Return the integer value if appropriate.
2068 static int booleanValue(char *zArg){
2070 if( zArg[0]=='0' && zArg[1]=='x' ){
2071 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2073 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
2075 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
2076 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
2079 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
2082 fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2088 ** Close an output file, assuming it is not stderr or stdout
2090 static void output_file_close(FILE *f){
2091 if( f && f!=stdout && f!=stderr ) fclose(f);
2095 ** Try to open an output file. The names "stdout" and "stderr" are
2096 ** recognized and do the right thing. NULL is returned if the output
2097 ** filename is "off".
2099 static FILE *output_file_open(const char *zFile){
2101 if( strcmp(zFile,"stdout")==0 ){
2103 }else if( strcmp(zFile, "stderr")==0 ){
2105 }else if( strcmp(zFile, "off")==0 ){
2108 f = fopen(zFile, "wb");
2110 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2117 ** A routine for handling output from sqlite3_trace().
2119 static void sql_trace_callback(void *pArg, const char *z){
2120 FILE *f = (FILE*)pArg;
2122 int i = (int)strlen(z);
2123 while( i>0 && z[i-1]==';' ){ i--; }
2124 fprintf(f, "%.*s;\n", i, z);
2129 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
2130 ** a useful spot to set a debugger breakpoint.
2132 static void test_breakpoint(void){
2133 static int nCall = 0;
2138 ** An object used to read a CSV and other files for import.
2140 typedef struct ImportCtx ImportCtx;
2142 const char *zFile; /* Name of the input file */
2143 FILE *in; /* Read the CSV text from this input stream */
2144 char *z; /* Accumulated text for a field */
2145 int n; /* Number of bytes in z */
2146 int nAlloc; /* Space allocated for z[] */
2147 int nLine; /* Current line number */
2148 int cTerm; /* Character that terminated the most recent field */
2149 int cColSep; /* The column separator character. (Usually ",") */
2150 int cRowSep; /* The row separator character. (Usually "\n") */
2153 /* Append a single byte to z[] */
2154 static void import_append_char(ImportCtx *p, int c){
2155 if( p->n+1>=p->nAlloc ){
2156 p->nAlloc += p->nAlloc + 100;
2157 p->z = sqlite3_realloc64(p->z, p->nAlloc);
2159 fprintf(stderr, "out of memory\n");
2163 p->z[p->n++] = (char)c;
2166 /* Read a single field of CSV text. Compatible with rfc4180 and extended
2167 ** with the option of having a separator other than ",".
2169 ** + Input comes from p->in.
2170 ** + Store results in p->z of length p->n. Space to hold p->z comes
2171 ** from sqlite3_malloc64().
2172 ** + Use p->cSep as the column separator. The default is ",".
2173 ** + Use p->rSep as the row separator. The default is "\n".
2174 ** + Keep track of the line number in p->nLine.
2175 ** + Store the character that terminates the field in p->cTerm. Store
2176 ** EOF on end-of-file.
2177 ** + Report syntax errors on stderr
2179 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
2181 int cSep = p->cColSep;
2182 int rSep = p->cRowSep;
2185 if( c==EOF || seenInterrupt ){
2191 int startLine = p->nLine;
2196 if( c==rSep ) p->nLine++;
2203 if( (c==cSep && pc==cQuote)
2204 || (c==rSep && pc==cQuote)
2205 || (c==rSep && pc=='\r' && ppc==cQuote)
2206 || (c==EOF && pc==cQuote)
2208 do{ p->n--; }while( p->z[p->n]!=cQuote );
2212 if( pc==cQuote && c!='\r' ){
2213 fprintf(stderr, "%s:%d: unescaped %c character\n",
2214 p->zFile, p->nLine, cQuote);
2217 fprintf(stderr, "%s:%d: unterminated %c-quoted field\n",
2218 p->zFile, startLine, cQuote);
2222 import_append_char(p, c);
2227 while( c!=EOF && c!=cSep && c!=rSep ){
2228 import_append_char(p, c);
2233 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
2237 if( p->z ) p->z[p->n] = 0;
2241 /* Read a single field of ASCII delimited text.
2243 ** + Input comes from p->in.
2244 ** + Store results in p->z of length p->n. Space to hold p->z comes
2245 ** from sqlite3_malloc64().
2246 ** + Use p->cSep as the column separator. The default is "\x1F".
2247 ** + Use p->rSep as the row separator. The default is "\x1E".
2248 ** + Keep track of the row number in p->nLine.
2249 ** + Store the character that terminates the field in p->cTerm. Store
2250 ** EOF on end-of-file.
2251 ** + Report syntax errors on stderr
2253 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
2255 int cSep = p->cColSep;
2256 int rSep = p->cRowSep;
2259 if( c==EOF || seenInterrupt ){
2263 while( c!=EOF && c!=cSep && c!=rSep ){
2264 import_append_char(p, c);
2271 if( p->z ) p->z[p->n] = 0;
2276 ** Try to transfer data for table zTable. If an error is seen while
2277 ** moving forward, try to go backwards. The backwards movement won't
2278 ** work for WITHOUT ROWID tables.
2280 static void tryToCloneData(
2285 sqlite3_stmt *pQuery = 0;
2286 sqlite3_stmt *pInsert = 0;
2291 int nTable = (int)strlen(zTable);
2294 const int spinRate = 10000;
2296 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
2297 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2299 fprintf(stderr, "Error %d: %s on [%s]\n",
2300 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2304 n = sqlite3_column_count(pQuery);
2305 zInsert = sqlite3_malloc64(200 + nTable + n*3);
2307 fprintf(stderr, "out of memory\n");
2310 sqlite3_snprintf(200+nTable,zInsert,
2311 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
2312 i = (int)strlen(zInsert);
2314 memcpy(zInsert+i, ",?", 2);
2317 memcpy(zInsert+i, ");", 3);
2318 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
2320 fprintf(stderr, "Error %d: %s on [%s]\n",
2321 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
2326 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2328 switch( sqlite3_column_type(pQuery, i) ){
2330 sqlite3_bind_null(pInsert, i+1);
2333 case SQLITE_INTEGER: {
2334 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
2337 case SQLITE_FLOAT: {
2338 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
2342 sqlite3_bind_text(pInsert, i+1,
2343 (const char*)sqlite3_column_text(pQuery,i),
2348 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
2349 sqlite3_column_bytes(pQuery,i),
2355 rc = sqlite3_step(pInsert);
2356 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
2357 fprintf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
2358 sqlite3_errmsg(newDb));
2360 sqlite3_reset(pInsert);
2362 if( (cnt%spinRate)==0 ){
2363 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
2367 if( rc==SQLITE_DONE ) break;
2368 sqlite3_finalize(pQuery);
2369 sqlite3_free(zQuery);
2370 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
2372 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2374 fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
2377 } /* End for(k=0...) */
2380 sqlite3_finalize(pQuery);
2381 sqlite3_finalize(pInsert);
2382 sqlite3_free(zQuery);
2383 sqlite3_free(zInsert);
2388 ** Try to transfer all rows of the schema that match zWhere. For
2389 ** each row, invoke xForEach() on the object defined by that row.
2390 ** If an error is encountered while moving forward through the
2391 ** sqlite_master table, try again moving backwards.
2393 static void tryToCloneSchema(
2397 void (*xForEach)(ShellState*,sqlite3*,const char*)
2399 sqlite3_stmt *pQuery = 0;
2402 const unsigned char *zName;
2403 const unsigned char *zSql;
2406 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2407 " WHERE %s", zWhere);
2408 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2410 fprintf(stderr, "Error: (%d) %s on [%s]\n",
2411 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2413 goto end_schema_xfer;
2415 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2416 zName = sqlite3_column_text(pQuery, 0);
2417 zSql = sqlite3_column_text(pQuery, 1);
2418 printf("%s... ", zName); fflush(stdout);
2419 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2421 fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2422 sqlite3_free(zErrMsg);
2426 xForEach(p, newDb, (const char*)zName);
2430 if( rc!=SQLITE_DONE ){
2431 sqlite3_finalize(pQuery);
2432 sqlite3_free(zQuery);
2433 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2434 " WHERE %s ORDER BY rowid DESC", zWhere);
2435 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2437 fprintf(stderr, "Error: (%d) %s on [%s]\n",
2438 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2440 goto end_schema_xfer;
2442 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2443 zName = sqlite3_column_text(pQuery, 0);
2444 zSql = sqlite3_column_text(pQuery, 1);
2445 printf("%s... ", zName); fflush(stdout);
2446 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2448 fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2449 sqlite3_free(zErrMsg);
2453 xForEach(p, newDb, (const char*)zName);
2459 sqlite3_finalize(pQuery);
2460 sqlite3_free(zQuery);
2464 ** Open a new database file named "zNewDb". Try to recover as much information
2465 ** as possible out of the main database (which might be corrupt) and write it
2468 static void tryToClone(ShellState *p, const char *zNewDb){
2471 if( access(zNewDb,0)==0 ){
2472 fprintf(stderr, "File \"%s\" already exists.\n", zNewDb);
2475 rc = sqlite3_open(zNewDb, &newDb);
2477 fprintf(stderr, "Cannot create output database: %s\n",
2478 sqlite3_errmsg(newDb));
2480 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
2481 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
2482 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
2483 tryToCloneSchema(p, newDb, "type!='table'", 0);
2484 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
2485 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2487 sqlite3_close(newDb);
2491 ** Change the output file back to stdout
2493 static void output_reset(ShellState *p){
2494 if( p->outfile[0]=='|' ){
2495 #ifndef SQLITE_OMIT_POPEN
2499 output_file_close(p->out);
2506 ** Run an SQL command and return the single integer result.
2508 static int db_int(ShellState *p, const char *zSql){
2509 sqlite3_stmt *pStmt;
2511 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2512 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
2513 res = sqlite3_column_int(pStmt,0);
2515 sqlite3_finalize(pStmt);
2520 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
2522 unsigned int get2byteInt(unsigned char *a){
2523 return (a[0]<<8) + a[1];
2525 unsigned int get4byteInt(unsigned char *a){
2526 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
2530 ** Implementation of the ".info" command.
2532 ** Return 1 on error, 2 to exit, and 0 otherwise.
2534 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
2535 static const struct { const char *zName; int ofst; } aField[] = {
2536 { "file change counter:", 24 },
2537 { "database page count:", 28 },
2538 { "freelist page count:", 36 },
2539 { "schema cookie:", 40 },
2540 { "schema format:", 44 },
2541 { "default cache size:", 48 },
2542 { "autovacuum top root:", 52 },
2543 { "incremental vacuum:", 64 },
2544 { "text encoding:", 56 },
2545 { "user version:", 60 },
2546 { "application id:", 68 },
2547 { "software version:", 96 },
2549 static const struct { const char *zName; const char *zSql; } aQuery[] = {
2550 { "number of tables:",
2551 "SELECT count(*) FROM %s WHERE type='table'" },
2552 { "number of indexes:",
2553 "SELECT count(*) FROM %s WHERE type='index'" },
2554 { "number of triggers:",
2555 "SELECT count(*) FROM %s WHERE type='trigger'" },
2556 { "number of views:",
2557 "SELECT count(*) FROM %s WHERE type='view'" },
2559 "SELECT total(length(sql)) FROM %s" },
2561 sqlite3_file *pFile;
2564 char *zDb = nArg>=2 ? azArg[1] : "main";
2565 unsigned char aHdr[100];
2567 if( p->db==0 ) return 1;
2568 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile);
2569 if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){
2572 i = pFile->pMethods->xRead(pFile, aHdr, 100, 0);
2574 fprintf(stderr, "unable to read database header\n");
2577 i = get2byteInt(aHdr+16);
2578 if( i==1 ) i = 65536;
2579 fprintf(p->out, "%-20s %d\n", "database page size:", i);
2580 fprintf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
2581 fprintf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
2582 fprintf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
2583 for(i=0; i<ArraySize(aField); i++){
2584 int ofst = aField[i].ofst;
2585 unsigned int val = get4byteInt(aHdr + ofst);
2586 fprintf(p->out, "%-20s %u", aField[i].zName, val);
2589 if( val==1 ) fprintf(p->out, " (utf8)");
2590 if( val==2 ) fprintf(p->out, " (utf16le)");
2591 if( val==3 ) fprintf(p->out, " (utf16be)");
2594 fprintf(p->out, "\n");
2597 zSchemaTab = sqlite3_mprintf("main.sqlite_master");
2598 }else if( strcmp(zDb,"temp")==0 ){
2599 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
2601 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
2603 for(i=0; i<ArraySize(aQuery); i++){
2604 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
2605 int val = db_int(p, zSql);
2607 fprintf(p->out, "%-20s %d\n", aQuery[i].zName, val);
2609 sqlite3_free(zSchemaTab);
2615 ** If an input line begins with "." then invoke this routine to
2616 ** process that line.
2618 ** Return 1 on error, 2 to exit, and 0 otherwise.
2620 static int do_meta_command(char *zLine, ShellState *p){
2627 /* Parse the input line into tokens.
2629 while( zLine[h] && nArg<ArraySize(azArg) ){
2630 while( IsSpace(zLine[h]) ){ h++; }
2631 if( zLine[h]==0 ) break;
2632 if( zLine[h]=='\'' || zLine[h]=='"' ){
2633 int delim = zLine[h++];
2634 azArg[nArg++] = &zLine[h];
2635 while( zLine[h] && zLine[h]!=delim ){
2636 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
2639 if( zLine[h]==delim ){
2642 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
2644 azArg[nArg++] = &zLine[h];
2645 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
2646 if( zLine[h] ) zLine[h++] = 0;
2647 resolve_backslashes(azArg[nArg-1]);
2651 /* Process the input line.
2653 if( nArg==0 ) return 0; /* no tokens, no error */
2654 n = strlen30(azArg[0]);
2656 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
2657 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
2659 const char *zDestFile = 0;
2660 const char *zDb = 0;
2662 sqlite3_backup *pBackup;
2664 for(j=1; j<nArg; j++){
2665 const char *z = azArg[j];
2667 while( z[0]=='-' ) z++;
2668 /* No options to process at this time */
2670 fprintf(stderr, "unknown option: %s\n", azArg[j]);
2673 }else if( zDestFile==0 ){
2674 zDestFile = azArg[j];
2677 zDestFile = azArg[j];
2679 fprintf(stderr, "too many arguments to .backup\n");
2684 fprintf(stderr, "missing FILENAME argument on .backup\n");
2687 if( zDb==0 ) zDb = "main";
2688 rc = sqlite3_open(zDestFile, &pDest);
2689 if( rc!=SQLITE_OK ){
2690 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
2691 sqlite3_close(pDest);
2695 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
2697 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2698 sqlite3_close(pDest);
2701 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
2702 sqlite3_backup_finish(pBackup);
2703 if( rc==SQLITE_DONE ){
2706 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2709 sqlite3_close(pDest);
2712 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
2714 bail_on_error = booleanValue(azArg[1]);
2716 fprintf(stderr, "Usage: .bail on|off\n");
2721 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
2723 if( booleanValue(azArg[1]) ){
2724 setBinaryMode(p->out);
2726 setTextMode(p->out);
2729 fprintf(stderr, "Usage: .binary on|off\n");
2734 /* The undocumented ".breakpoint" command causes a call to the no-op
2735 ** routine named test_breakpoint().
2737 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
2741 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
2743 tryToClone(p, azArg[1]);
2745 fprintf(stderr, "Usage: .clone FILENAME\n");
2750 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
2754 memcpy(&data, p, sizeof(data));
2755 data.showHeader = 1;
2756 data.mode = MODE_Column;
2757 data.colWidth[0] = 3;
2758 data.colWidth[1] = 15;
2759 data.colWidth[2] = 58;
2761 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
2763 fprintf(stderr,"Error: %s\n", zErrMsg);
2764 sqlite3_free(zErrMsg);
2769 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
2770 rc = shell_dbinfo_command(p, nArg, azArg);
2773 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
2775 /* When playing back a "dump", the content might appear in an order
2776 ** which causes immediate foreign key constraints to be violated.
2777 ** So disable foreign-key constraint enforcement to prevent problems. */
2778 if( nArg!=1 && nArg!=2 ){
2779 fprintf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
2781 goto meta_command_exit;
2783 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
2784 fprintf(p->out, "BEGIN TRANSACTION;\n");
2785 p->writableSchema = 0;
2786 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2789 run_schema_dump_query(p,
2790 "SELECT name, type, sql FROM sqlite_master "
2791 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2793 run_schema_dump_query(p,
2794 "SELECT name, type, sql FROM sqlite_master "
2795 "WHERE name=='sqlite_sequence'"
2797 run_table_dump_query(p,
2798 "SELECT sql FROM sqlite_master "
2799 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2803 for(i=1; i<nArg; i++){
2804 zShellStatic = azArg[i];
2805 run_schema_dump_query(p,
2806 "SELECT name, type, sql FROM sqlite_master "
2807 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2808 " AND sql NOT NULL");
2809 run_table_dump_query(p,
2810 "SELECT sql FROM sqlite_master "
2811 "WHERE sql NOT NULL"
2812 " AND type IN ('index','trigger','view')"
2813 " AND tbl_name LIKE shellstatic()", 0
2818 if( p->writableSchema ){
2819 fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
2820 p->writableSchema = 0;
2822 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2823 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
2824 fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
2827 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
2829 p->echoOn = booleanValue(azArg[1]);
2831 fprintf(stderr, "Usage: .echo on|off\n");
2836 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
2838 p->autoEQP = booleanValue(azArg[1]);
2840 fprintf(stderr, "Usage: .eqp on|off\n");
2845 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
2846 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
2850 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
2851 int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
2853 if(!p->normalMode.valid) {
2854 p->normalMode.valid = 1;
2855 p->normalMode.mode = p->mode;
2856 p->normalMode.showHeader = p->showHeader;
2857 memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth));
2859 /* We could put this code under the !p->explainValid
2860 ** condition so that it does not execute if we are already in
2861 ** explain mode. However, always executing it allows us an easy
2862 ** was to reset to explain mode in case the user previously
2863 ** did an .explain followed by a .width, .mode or .header
2866 p->mode = MODE_Explain;
2868 memset(p->colWidth,0,sizeof(p->colWidth));
2869 p->colWidth[0] = 4; /* addr */
2870 p->colWidth[1] = 13; /* opcode */
2871 p->colWidth[2] = 4; /* P1 */
2872 p->colWidth[3] = 4; /* P2 */
2873 p->colWidth[4] = 4; /* P3 */
2874 p->colWidth[5] = 13; /* P4 */
2875 p->colWidth[6] = 2; /* P5 */
2876 p->colWidth[7] = 13; /* Comment */
2877 }else if (p->normalMode.valid) {
2878 p->normalMode.valid = 0;
2879 p->mode = p->normalMode.mode;
2880 p->showHeader = p->normalMode.showHeader;
2881 memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth));
2885 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
2890 fprintf(stderr, "Usage: .fullschema\n");
2892 goto meta_command_exit;
2895 memcpy(&data, p, sizeof(data));
2896 data.showHeader = 0;
2897 data.mode = MODE_Semi;
2898 rc = sqlite3_exec(p->db,
2900 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2901 " FROM sqlite_master UNION ALL"
2902 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2903 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
2905 callback, &data, &zErrMsg
2907 if( rc==SQLITE_OK ){
2908 sqlite3_stmt *pStmt;
2909 rc = sqlite3_prepare_v2(p->db,
2910 "SELECT rowid FROM sqlite_master"
2911 " WHERE name GLOB 'sqlite_stat[134]'",
2913 doStats = sqlite3_step(pStmt)==SQLITE_ROW;
2914 sqlite3_finalize(pStmt);
2917 fprintf(p->out, "/* No STAT tables available */\n");
2919 fprintf(p->out, "ANALYZE sqlite_master;\n");
2920 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
2921 callback, &data, &zErrMsg);
2922 data.mode = MODE_Insert;
2923 data.zDestTable = "sqlite_stat1";
2924 shell_exec(p->db, "SELECT * FROM sqlite_stat1",
2925 shell_callback, &data,&zErrMsg);
2926 data.zDestTable = "sqlite_stat3";
2927 shell_exec(p->db, "SELECT * FROM sqlite_stat3",
2928 shell_callback, &data,&zErrMsg);
2929 data.zDestTable = "sqlite_stat4";
2930 shell_exec(p->db, "SELECT * FROM sqlite_stat4",
2931 shell_callback, &data, &zErrMsg);
2932 fprintf(p->out, "ANALYZE sqlite_master;\n");
2936 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
2938 p->showHeader = booleanValue(azArg[1]);
2940 fprintf(stderr, "Usage: .headers on|off\n");
2945 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
2946 fprintf(p->out, "%s", zHelp);
2949 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
2950 char *zTable; /* Insert data into this table */
2951 char *zFile; /* Name of file to extra content from */
2952 sqlite3_stmt *pStmt = NULL; /* A statement */
2953 int nCol; /* Number of columns in the table */
2954 int nByte; /* Number of bytes in an SQL string */
2955 int i, j; /* Loop counters */
2956 int needCommit; /* True to COMMIT or ROLLBACK at end */
2957 int nSep; /* Number of bytes in p->colSeparator[] */
2958 char *zSql; /* An SQL statement */
2959 ImportCtx sCtx; /* Reader context */
2960 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
2961 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
2964 fprintf(stderr, "Usage: .import FILE TABLE\n");
2965 goto meta_command_exit;
2970 memset(&sCtx, 0, sizeof(sCtx));
2972 nSep = strlen30(p->colSeparator);
2974 fprintf(stderr, "Error: non-null column separator required for import\n");
2978 fprintf(stderr, "Error: multi-character column separators not allowed"
2982 nSep = strlen30(p->rowSeparator);
2984 fprintf(stderr, "Error: non-null row separator required for import\n");
2987 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
2988 /* When importing CSV (only), if the row separator is set to the
2989 ** default output row separator, change it to the default input
2990 ** row separator. This avoids having to maintain different input
2991 ** and output row separators. */
2992 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
2993 nSep = strlen30(p->rowSeparator);
2996 fprintf(stderr, "Error: multi-character row separators not allowed"
3002 if( sCtx.zFile[0]=='|' ){
3003 #ifdef SQLITE_OMIT_POPEN
3004 fprintf(stderr, "Error: pipes are not supported in this OS\n");
3007 sCtx.in = popen(sCtx.zFile+1, "r");
3008 sCtx.zFile = "<pipe>";
3012 sCtx.in = fopen(sCtx.zFile, "rb");
3015 if( p->mode==MODE_Ascii ){
3016 xRead = ascii_read_one_field;
3018 xRead = csv_read_one_field;
3021 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
3024 sCtx.cColSep = p->colSeparator[0];
3025 sCtx.cRowSep = p->rowSeparator[0];
3026 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
3028 fprintf(stderr, "Error: out of memory\n");
3032 nByte = strlen30(zSql);
3033 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3034 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
3035 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
3036 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
3038 while( xRead(&sCtx) ){
3039 zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCtx.z);
3041 if( sCtx.cTerm!=sCtx.cColSep ) break;
3044 sqlite3_free(zCreate);
3045 sqlite3_free(sCtx.z);
3047 fprintf(stderr,"%s: empty file\n", sCtx.zFile);
3050 zCreate = sqlite3_mprintf("%z\n)", zCreate);
3051 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
3052 sqlite3_free(zCreate);
3054 fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
3055 sqlite3_errmsg(p->db));
3056 sqlite3_free(sCtx.z);
3060 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3064 if (pStmt) sqlite3_finalize(pStmt);
3065 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
3069 nCol = sqlite3_column_count(pStmt);
3070 sqlite3_finalize(pStmt);
3072 if( nCol==0 ) return 0; /* no columns, no error */
3073 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
3075 fprintf(stderr, "Error: out of memory\n");
3079 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
3081 for(i=1; i<nCol; i++){
3087 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3090 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3091 if (pStmt) sqlite3_finalize(pStmt);
3095 needCommit = sqlite3_get_autocommit(p->db);
3096 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
3098 int startLine = sCtx.nLine;
3099 for(i=0; i<nCol; i++){
3100 char *z = xRead(&sCtx);
3102 ** Did we reach end-of-file before finding any columns?
3103 ** If so, stop instead of NULL filling the remaining columns.
3105 if( z==0 && i==0 ) break;
3107 ** Did we reach end-of-file OR end-of-line before finding any
3108 ** columns in ASCII mode? If so, stop instead of NULL filling
3109 ** the remaining columns.
3111 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
3112 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
3113 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
3114 fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3115 "filling the rest with NULL\n",
3116 sCtx.zFile, startLine, nCol, i+1);
3118 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
3121 if( sCtx.cTerm==sCtx.cColSep ){
3125 }while( sCtx.cTerm==sCtx.cColSep );
3126 fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3128 sCtx.zFile, startLine, nCol, i);
3131 sqlite3_step(pStmt);
3132 rc = sqlite3_reset(pStmt);
3133 if( rc!=SQLITE_OK ){
3134 fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, startLine,
3135 sqlite3_errmsg(p->db));
3138 }while( sCtx.cTerm!=EOF );
3141 sqlite3_free(sCtx.z);
3142 sqlite3_finalize(pStmt);
3143 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
3146 if( c=='i' && (strncmp(azArg[0], "indices", n)==0
3147 || strncmp(azArg[0], "indexes", n)==0) ){
3151 memcpy(&data, p, sizeof(data));
3152 data.showHeader = 0;
3153 data.mode = MODE_List;
3155 rc = sqlite3_exec(p->db,
3156 "SELECT name FROM sqlite_master "
3157 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
3159 "SELECT name FROM sqlite_temp_master "
3160 "WHERE type='index' "
3162 callback, &data, &zErrMsg
3164 }else if( nArg==2 ){
3165 zShellStatic = azArg[1];
3166 rc = sqlite3_exec(p->db,
3167 "SELECT name FROM sqlite_master "
3168 "WHERE type='index' AND tbl_name LIKE shellstatic() "
3170 "SELECT name FROM sqlite_temp_master "
3171 "WHERE type='index' AND tbl_name LIKE shellstatic() "
3173 callback, &data, &zErrMsg
3177 fprintf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
3179 goto meta_command_exit;
3182 fprintf(stderr,"Error: %s\n", zErrMsg);
3183 sqlite3_free(zErrMsg);
3185 }else if( rc != SQLITE_OK ){
3186 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
3191 #ifdef SQLITE_ENABLE_IOTRACE
3192 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
3193 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
3194 if( iotrace && iotrace!=stdout ) fclose(iotrace);
3198 }else if( strcmp(azArg[1], "-")==0 ){
3199 sqlite3IoTrace = iotracePrintf;
3202 iotrace = fopen(azArg[1], "w");
3204 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
3208 sqlite3IoTrace = iotracePrintf;
3213 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
3214 static const struct {
3215 const char *zLimitName; /* Name of a limit */
3216 int limitCode; /* Integer code for that limit */
3218 { "length", SQLITE_LIMIT_LENGTH },
3219 { "sql_length", SQLITE_LIMIT_SQL_LENGTH },
3220 { "column", SQLITE_LIMIT_COLUMN },
3221 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH },
3222 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT },
3223 { "vdbe_op", SQLITE_LIMIT_VDBE_OP },
3224 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG },
3225 { "attached", SQLITE_LIMIT_ATTACHED },
3226 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
3227 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER },
3228 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH },
3229 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS },
3234 for(i=0; i<ArraySize(aLimit); i++){
3235 printf("%20s %d\n", aLimit[i].zLimitName,
3236 sqlite3_limit(p->db, aLimit[i].limitCode, -1));
3239 fprintf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
3241 goto meta_command_exit;
3244 n2 = strlen30(azArg[1]);
3245 for(i=0; i<ArraySize(aLimit); i++){
3246 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
3250 fprintf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
3252 goto meta_command_exit;
3257 fprintf(stderr, "unknown limit: \"%s\"\n"
3258 "enter \".limits\" with no arguments for a list.\n",
3261 goto meta_command_exit;
3264 sqlite3_limit(p->db, aLimit[iLimit].limitCode,
3265 (int)integerValue(azArg[2]));
3267 printf("%20s %d\n", aLimit[iLimit].zLimitName,
3268 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
3272 #ifndef SQLITE_OMIT_LOAD_EXTENSION
3273 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
3274 const char *zFile, *zProc;
3277 fprintf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
3279 goto meta_command_exit;
3282 zProc = nArg>=3 ? azArg[2] : 0;
3284 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
3285 if( rc!=SQLITE_OK ){
3286 fprintf(stderr, "Error: %s\n", zErrMsg);
3287 sqlite3_free(zErrMsg);
3293 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
3295 fprintf(stderr, "Usage: .log FILENAME\n");
3298 const char *zFile = azArg[1];
3299 output_file_close(p->pLog);
3300 p->pLog = output_file_open(zFile);
3304 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
3305 const char *zMode = nArg>=2 ? azArg[1] : "";
3306 int n2 = (int)strlen(zMode);
3308 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
3309 p->mode = MODE_Line;
3310 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
3311 p->mode = MODE_Column;
3312 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
3313 p->mode = MODE_List;
3314 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
3315 p->mode = MODE_Html;
3316 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
3318 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
3319 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
3321 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
3322 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
3323 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
3324 p->mode = MODE_List;
3325 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
3326 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
3327 p->mode = MODE_Insert;
3328 set_table_name(p, nArg>=3 ? azArg[2] : "table");
3329 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
3330 p->mode = MODE_Ascii;
3331 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
3332 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
3334 fprintf(stderr,"Error: mode should be one of: "
3335 "ascii column csv html insert line list tabs tcl\n");
3340 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
3342 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
3343 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
3345 fprintf(stderr, "Usage: .nullvalue STRING\n");
3350 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
3351 sqlite3 *savedDb = p->db;
3352 const char *zSavedFilename = p->zDbFilename;
3353 char *zNewFilename = 0;
3355 if( nArg>=2 ) zNewFilename = sqlite3_mprintf("%s", azArg[1]);
3356 p->zDbFilename = zNewFilename;
3359 sqlite3_close(savedDb);
3360 sqlite3_free(p->zFreeOnClose);
3361 p->zFreeOnClose = zNewFilename;
3363 sqlite3_free(zNewFilename);
3365 p->zDbFilename = zSavedFilename;
3370 && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
3372 const char *zFile = nArg>=2 ? azArg[1] : "stdout";
3374 fprintf(stderr, "Usage: .%s FILE\n", azArg[0]);
3376 goto meta_command_exit;
3378 if( n>1 && strncmp(azArg[0], "once", n)==0 ){
3380 fprintf(stderr, "Usage: .once FILE\n");
3382 goto meta_command_exit;
3389 if( zFile[0]=='|' ){
3390 #ifdef SQLITE_OMIT_POPEN
3391 fprintf(stderr,"Error: pipes are not supported in this OS\n");
3395 p->out = popen(zFile + 1, "w");
3397 fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
3401 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
3405 p->out = output_file_open(zFile);
3407 if( strcmp(zFile,"off")!=0 ){
3408 fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile);
3413 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
3418 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
3420 for(i=1; i<nArg; i++){
3421 if( i>1 ) fprintf(p->out, " ");
3422 fprintf(p->out, "%s", azArg[i]);
3424 fprintf(p->out, "\n");
3427 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
3429 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
3432 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
3436 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
3440 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
3443 fprintf(stderr, "Usage: .read FILE\n");
3445 goto meta_command_exit;
3447 alt = fopen(azArg[1], "rb");
3449 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
3452 rc = process_input(p, alt);
3457 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
3458 const char *zSrcFile;
3461 sqlite3_backup *pBackup;
3465 zSrcFile = azArg[1];
3467 }else if( nArg==3 ){
3468 zSrcFile = azArg[2];
3471 fprintf(stderr, "Usage: .restore ?DB? FILE\n");
3473 goto meta_command_exit;
3475 rc = sqlite3_open(zSrcFile, &pSrc);
3476 if( rc!=SQLITE_OK ){
3477 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
3478 sqlite3_close(pSrc);
3482 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
3484 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3485 sqlite3_close(pSrc);
3488 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
3489 || rc==SQLITE_BUSY ){
3490 if( rc==SQLITE_BUSY ){
3491 if( nTimeout++ >= 3 ) break;
3495 sqlite3_backup_finish(pBackup);
3496 if( rc==SQLITE_DONE ){
3498 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
3499 fprintf(stderr, "Error: source database is busy\n");
3502 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3505 sqlite3_close(pSrc);
3509 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
3511 p->scanstatsOn = booleanValue(azArg[1]);
3512 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
3513 fprintf(stderr, "Warning: .scanstats not available in this build.\n");
3516 fprintf(stderr, "Usage: .scanstats on|off\n");
3521 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
3525 memcpy(&data, p, sizeof(data));
3526 data.showHeader = 0;
3527 data.mode = MODE_Semi;
3530 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
3531 if( strcmp(azArg[1],"sqlite_master")==0 ){
3532 char *new_argv[2], *new_colv[2];
3533 new_argv[0] = "CREATE TABLE sqlite_master (\n"
3537 " rootpage integer,\n"
3541 new_colv[0] = "sql";
3543 callback(&data, 1, new_argv, new_colv);
3545 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
3546 char *new_argv[2], *new_colv[2];
3547 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
3551 " rootpage integer,\n"
3555 new_colv[0] = "sql";
3557 callback(&data, 1, new_argv, new_colv);
3560 zShellStatic = azArg[1];
3561 rc = sqlite3_exec(p->db,
3563 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3564 " FROM sqlite_master UNION ALL"
3565 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3566 "WHERE lower(tbl_name) LIKE shellstatic()"
3567 " AND type!='meta' AND sql NOTNULL "
3569 callback, &data, &zErrMsg);
3572 }else if( nArg==1 ){
3573 rc = sqlite3_exec(p->db,
3575 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3576 " FROM sqlite_master UNION ALL"
3577 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3578 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
3580 callback, &data, &zErrMsg
3583 fprintf(stderr, "Usage: .schema ?LIKE-PATTERN?\n");
3585 goto meta_command_exit;
3588 fprintf(stderr,"Error: %s\n", zErrMsg);
3589 sqlite3_free(zErrMsg);
3591 }else if( rc != SQLITE_OK ){
3592 fprintf(stderr,"Error: querying schema information\n");
3600 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3601 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
3602 extern int sqlite3SelectTrace;
3603 sqlite3SelectTrace = integerValue(azArg[1]);
3609 /* Undocumented commands for internal testing. Subject to change
3610 ** without notice. */
3611 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
3612 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
3614 for(i=1; i<nArg; i++){
3615 v = booleanValue(azArg[i]);
3616 fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
3619 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
3620 int i; sqlite3_int64 v;
3621 for(i=1; i<nArg; i++){
3623 v = integerValue(azArg[i]);
3624 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
3625 fprintf(p->out, "%s", zBuf);
3631 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
3632 if( nArg<2 || nArg>3 ){
3633 fprintf(stderr, "Usage: .separator COL ?ROW?\n");
3637 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
3638 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
3641 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
3642 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
3647 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
3652 fprintf(stderr, "Usage: .system COMMAND\n");
3654 goto meta_command_exit;
3656 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
3657 for(i=2; i<nArg; i++){
3658 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
3663 if( x ) fprintf(stderr, "System command returns %d\n", x);
3666 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
3669 fprintf(stderr, "Usage: .show\n");
3671 goto meta_command_exit;
3673 fprintf(p->out,"%12.12s: %s\n","echo", p->echoOn ? "on" : "off");
3674 fprintf(p->out,"%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off");
3675 fprintf(p->out,"%9.9s: %s\n","explain", p->normalMode.valid ? "on" :"off");
3676 fprintf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off");
3677 fprintf(p->out,"%12.12s: %s\n","mode", modeDescr[p->mode]);
3678 fprintf(p->out,"%12.12s: ", "nullvalue");
3679 output_c_string(p->out, p->nullValue);
3680 fprintf(p->out, "\n");
3681 fprintf(p->out,"%12.12s: %s\n","output",
3682 strlen30(p->outfile) ? p->outfile : "stdout");
3683 fprintf(p->out,"%12.12s: ", "colseparator");
3684 output_c_string(p->out, p->colSeparator);
3685 fprintf(p->out, "\n");
3686 fprintf(p->out,"%12.12s: ", "rowseparator");
3687 output_c_string(p->out, p->rowSeparator);
3688 fprintf(p->out, "\n");
3689 fprintf(p->out,"%12.12s: %s\n","stats", p->statsOn ? "on" : "off");
3690 fprintf(p->out,"%12.12s: ","width");
3691 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
3692 fprintf(p->out,"%d ",p->colWidth[i]);
3694 fprintf(p->out,"\n");
3697 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
3699 p->statsOn = booleanValue(azArg[1]);
3701 fprintf(stderr, "Usage: .stats on|off\n");
3706 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
3707 sqlite3_stmt *pStmt;
3713 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
3715 zSql = sqlite3_mprintf(
3716 "SELECT name FROM sqlite_master"
3717 " WHERE type IN ('table','view')"
3718 " AND name NOT LIKE 'sqlite_%%'"
3719 " AND name LIKE ?1");
3720 while( sqlite3_step(pStmt)==SQLITE_ROW ){
3721 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
3722 if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
3723 if( strcmp(zDbName,"temp")==0 ){
3724 zSql = sqlite3_mprintf(
3726 "SELECT 'temp.' || name FROM sqlite_temp_master"
3727 " WHERE type IN ('table','view')"
3728 " AND name NOT LIKE 'sqlite_%%'"
3729 " AND name LIKE ?1", zSql);
3731 zSql = sqlite3_mprintf(
3733 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
3734 " WHERE type IN ('table','view')"
3735 " AND name NOT LIKE 'sqlite_%%'"
3736 " AND name LIKE ?1", zSql, zDbName, zDbName);
3739 sqlite3_finalize(pStmt);
3740 zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
3741 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3747 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
3749 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
3751 while( sqlite3_step(pStmt)==SQLITE_ROW ){
3754 int n2 = nAlloc*2 + 10;
3755 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
3757 fprintf(stderr, "Error: out of memory\n");
3763 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
3764 if( azResult[nRow] ) nRow++;
3766 sqlite3_finalize(pStmt);
3768 int len, maxlen = 0;
3770 int nPrintCol, nPrintRow;
3771 for(i=0; i<nRow; i++){
3772 len = strlen30(azResult[i]);
3773 if( len>maxlen ) maxlen = len;
3775 nPrintCol = 80/(maxlen+2);
3776 if( nPrintCol<1 ) nPrintCol = 1;
3777 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
3778 for(i=0; i<nPrintRow; i++){
3779 for(j=i; j<nRow; j+=nPrintRow){
3780 char *zSp = j<nPrintRow ? "" : " ";
3781 fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");
3783 fprintf(p->out, "\n");
3786 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
3787 sqlite3_free(azResult);
3790 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
3791 static const struct {
3792 const char *zCtrlName; /* Name of a test-control option */
3793 int ctrlCode; /* Integer code for that option */
3795 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
3796 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
3797 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
3798 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
3799 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
3800 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
3801 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
3802 { "assert", SQLITE_TESTCTRL_ASSERT },
3803 { "always", SQLITE_TESTCTRL_ALWAYS },
3804 { "reserve", SQLITE_TESTCTRL_RESERVE },
3805 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
3806 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
3807 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
3808 { "byteorder", SQLITE_TESTCTRL_BYTEORDER },
3809 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT },
3810 { "imposter", SQLITE_TESTCTRL_IMPOSTER },
3817 /* convert testctrl text option to value. allow any unique prefix
3818 ** of the option name, or a numerical value. */
3819 n2 = strlen30(azArg[1]);
3820 for(i=0; i<ArraySize(aCtrl); i++){
3821 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n2)==0 ){
3823 testctrl = aCtrl[i].ctrlCode;
3825 fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
3831 if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
3832 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
3833 fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
3837 /* sqlite3_test_control(int, db, int) */
3838 case SQLITE_TESTCTRL_OPTIMIZATIONS:
3839 case SQLITE_TESTCTRL_RESERVE:
3841 int opt = (int)strtol(azArg[2], 0, 0);
3842 rc2 = sqlite3_test_control(testctrl, p->db, opt);
3843 fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
3845 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3850 /* sqlite3_test_control(int) */
3851 case SQLITE_TESTCTRL_PRNG_SAVE:
3852 case SQLITE_TESTCTRL_PRNG_RESTORE:
3853 case SQLITE_TESTCTRL_PRNG_RESET:
3854 case SQLITE_TESTCTRL_BYTEORDER:
3856 rc2 = sqlite3_test_control(testctrl);
3857 fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
3859 fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
3863 /* sqlite3_test_control(int, uint) */
3864 case SQLITE_TESTCTRL_PENDING_BYTE:
3866 unsigned int opt = (unsigned int)integerValue(azArg[2]);
3867 rc2 = sqlite3_test_control(testctrl, opt);
3868 fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
3870 fprintf(stderr,"Error: testctrl %s takes a single unsigned"
3871 " int option\n", azArg[1]);
3875 /* sqlite3_test_control(int, int) */
3876 case SQLITE_TESTCTRL_ASSERT:
3877 case SQLITE_TESTCTRL_ALWAYS:
3878 case SQLITE_TESTCTRL_NEVER_CORRUPT:
3880 int opt = booleanValue(azArg[2]);
3881 rc2 = sqlite3_test_control(testctrl, opt);
3882 fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
3884 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3889 /* sqlite3_test_control(int, char *) */
3890 #ifdef SQLITE_N_KEYWORD
3891 case SQLITE_TESTCTRL_ISKEYWORD:
3893 const char *opt = azArg[2];
3894 rc2 = sqlite3_test_control(testctrl, opt);
3895 fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
3897 fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
3903 case SQLITE_TESTCTRL_IMPOSTER:
3905 rc2 = sqlite3_test_control(testctrl, p->db,
3907 integerValue(azArg[3]),
3908 integerValue(azArg[4]));
3909 fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
3911 fprintf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
3915 case SQLITE_TESTCTRL_BITVEC_TEST:
3916 case SQLITE_TESTCTRL_FAULT_INSTALL:
3917 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
3918 case SQLITE_TESTCTRL_SCRATCHMALLOC:
3920 fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
3927 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
3929 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
3932 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
3934 enableTimer = booleanValue(azArg[1]);
3935 if( enableTimer && !HAS_TIMER ){
3936 fprintf(stderr, "Error: timer not available on this system.\n");
3940 fprintf(stderr, "Usage: .timer on|off\n");
3945 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
3948 fprintf(stderr, "Usage: .trace FILE|off\n");
3950 goto meta_command_exit;
3952 output_file_close(p->traceOut);
3953 p->traceOut = output_file_open(azArg[1]);
3954 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
3955 if( p->traceOut==0 ){
3956 sqlite3_trace(p->db, 0, 0);
3958 sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
3963 #if SQLITE_USER_AUTHENTICATION
3964 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
3966 fprintf(stderr, "Usage: .user SUBCOMMAND ...\n");
3968 goto meta_command_exit;
3971 if( strcmp(azArg[1],"login")==0 ){
3973 fprintf(stderr, "Usage: .user login USER PASSWORD\n");
3975 goto meta_command_exit;
3977 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
3978 (int)strlen(azArg[3]));
3980 fprintf(stderr, "Authentication failed for user %s\n", azArg[2]);
3983 }else if( strcmp(azArg[1],"add")==0 ){
3985 fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
3987 goto meta_command_exit;
3989 rc = sqlite3_user_add(p->db, azArg[2],
3990 azArg[3], (int)strlen(azArg[3]),
3991 booleanValue(azArg[4]));
3993 fprintf(stderr, "User-Add failed: %d\n", rc);
3996 }else if( strcmp(azArg[1],"edit")==0 ){
3998 fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
4000 goto meta_command_exit;
4002 rc = sqlite3_user_change(p->db, azArg[2],
4003 azArg[3], (int)strlen(azArg[3]),
4004 booleanValue(azArg[4]));
4006 fprintf(stderr, "User-Edit failed: %d\n", rc);
4009 }else if( strcmp(azArg[1],"delete")==0 ){
4011 fprintf(stderr, "Usage: .user delete USER\n");
4013 goto meta_command_exit;
4015 rc = sqlite3_user_delete(p->db, azArg[2]);
4017 fprintf(stderr, "User-Delete failed: %d\n", rc);
4021 fprintf(stderr, "Usage: .user login|add|edit|delete ...\n");
4023 goto meta_command_exit;
4026 #endif /* SQLITE_USER_AUTHENTICATION */
4028 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
4029 fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
4030 sqlite3_libversion(), sqlite3_sourceid());
4033 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
4034 const char *zDbName = nArg==2 ? azArg[1] : "main";
4037 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
4039 fprintf(p->out, "%s\n", zVfsName);
4040 sqlite3_free(zVfsName);
4045 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
4046 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
4047 extern int sqlite3WhereTrace;
4048 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
4052 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
4054 assert( nArg<=ArraySize(azArg) );
4055 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
4056 p->colWidth[j-1] = (int)integerValue(azArg[j]);
4061 fprintf(stderr, "Error: unknown command or invalid arguments: "
4062 " \"%s\". Enter \".help\" for help\n", azArg[0]);
4069 if( p->outCount==0 ) output_reset(p);
4075 ** Return TRUE if a semicolon occurs anywhere in the first N characters
4078 static int line_contains_semicolon(const char *z, int N){
4080 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
4085 ** Test to see if a line consists entirely of whitespace.
4087 static int _all_whitespace(const char *z){
4089 if( IsSpace(z[0]) ) continue;
4090 if( *z=='/' && z[1]=='*' ){
4092 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
4093 if( *z==0 ) return 0;
4097 if( *z=='-' && z[1]=='-' ){
4099 while( *z && *z!='\n' ){ z++; }
4100 if( *z==0 ) return 1;
4109 ** Return TRUE if the line typed in is an SQL command terminator other
4110 ** than a semi-colon. The SQL Server style "go" command is understood
4111 ** as is the Oracle "/".
4113 static int line_is_command_terminator(const char *zLine){
4114 while( IsSpace(zLine[0]) ){ zLine++; };
4115 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
4116 return 1; /* Oracle */
4118 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
4119 && _all_whitespace(&zLine[2]) ){
4120 return 1; /* SQL Server */
4126 ** Return true if zSql is a complete SQL statement. Return false if it
4127 ** ends in the middle of a string literal or C-style comment.
4129 static int line_is_complete(char *zSql, int nSql){
4131 if( zSql==0 ) return 1;
4134 rc = sqlite3_complete(zSql);
4140 ** Read input from *in and process it. If *in==0 then input
4141 ** is interactive - the user is typing it it. Otherwise, input
4142 ** is coming from a file or device. A prompt is issued and history
4143 ** is saved only if input is interactive. An interrupt signal will
4144 ** cause this routine to exit immediately, unless input is interactive.
4146 ** Return the number of errors.
4148 static int process_input(ShellState *p, FILE *in){
4149 char *zLine = 0; /* A single input line */
4150 char *zSql = 0; /* Accumulated SQL text */
4151 int nLine; /* Length of current line */
4152 int nSql = 0; /* Bytes of zSql[] used */
4153 int nAlloc = 0; /* Allocated zSql[] space */
4154 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
4155 char *zErrMsg; /* Error message returned */
4156 int rc; /* Error code */
4157 int errCnt = 0; /* Number of errors seen */
4158 int lineno = 0; /* Current line number */
4159 int startline = 0; /* Line number for start of current input */
4161 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
4163 zLine = one_input_line(in, zLine, nSql>0);
4166 if( stdin_is_interactive ) printf("\n");
4169 if( seenInterrupt ){
4174 if( nSql==0 && _all_whitespace(zLine) ){
4175 if( p->echoOn ) printf("%s\n", zLine);
4178 if( zLine && zLine[0]=='.' && nSql==0 ){
4179 if( p->echoOn ) printf("%s\n", zLine);
4180 rc = do_meta_command(zLine, p);
4181 if( rc==2 ){ /* exit requested */
4188 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
4189 memcpy(zLine,";",2);
4191 nLine = strlen30(zLine);
4192 if( nSql+nLine+2>=nAlloc ){
4193 nAlloc = nSql+nLine+100;
4194 zSql = realloc(zSql, nAlloc);
4196 fprintf(stderr, "Error: out of memory\n");
4203 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
4204 assert( nAlloc>0 && zSql!=0 );
4205 memcpy(zSql, zLine+i, nLine+1-i);
4209 zSql[nSql++] = '\n';
4210 memcpy(zSql+nSql, zLine, nLine+1);
4213 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
4214 && sqlite3_complete(zSql) ){
4217 if( p->backslashOn ) resolve_backslashes(zSql);
4219 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
4221 if( rc || zErrMsg ){
4223 if( in!=0 || !stdin_is_interactive ){
4224 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
4225 "Error: near line %d:", startline);
4227 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
4230 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
4231 sqlite3_free(zErrMsg);
4234 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
4243 }else if( nSql && _all_whitespace(zSql) ){
4244 if( p->echoOn ) printf("%s\n", zSql);
4249 if( !_all_whitespace(zSql) ){
4250 fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
4260 ** Return a pathname which is the user's home directory. A
4261 ** 0 return indicates an error of some kind.
4263 static char *find_home_dir(void){
4264 static char *home_dir = NULL;
4265 if( home_dir ) return home_dir;
4267 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
4268 && !defined(__RTP__) && !defined(_WRS_KERNEL)
4270 struct passwd *pwent;
4271 uid_t uid = getuid();
4272 if( (pwent=getpwuid(uid)) != NULL) {
4273 home_dir = pwent->pw_dir;
4278 #if defined(_WIN32_WCE)
4279 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
4284 #if defined(_WIN32) || defined(WIN32)
4286 home_dir = getenv("USERPROFILE");
4291 home_dir = getenv("HOME");
4294 #if defined(_WIN32) || defined(WIN32)
4296 char *zDrive, *zPath;
4298 zDrive = getenv("HOMEDRIVE");
4299 zPath = getenv("HOMEPATH");
4300 if( zDrive && zPath ){
4301 n = strlen30(zDrive) + strlen30(zPath) + 1;
4302 home_dir = malloc( n );
4303 if( home_dir==0 ) return 0;
4304 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
4311 #endif /* !_WIN32_WCE */
4314 int n = strlen30(home_dir) + 1;
4315 char *z = malloc( n );
4316 if( z ) memcpy(z, home_dir, n);
4324 ** Read input from the file given by sqliterc_override. Or if that
4325 ** parameter is NULL, take input from ~/.sqliterc
4327 ** Returns the number of errors.
4329 static void process_sqliterc(
4330 ShellState *p, /* Configuration data */
4331 const char *sqliterc_override /* Name of config file. NULL to use default */
4333 char *home_dir = NULL;
4334 const char *sqliterc = sqliterc_override;
4338 if (sqliterc == NULL) {
4339 home_dir = find_home_dir();
4341 fprintf(stderr, "-- warning: cannot find home directory;"
4342 " cannot read ~/.sqliterc\n");
4345 sqlite3_initialize();
4346 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
4349 in = fopen(sqliterc,"rb");
4351 if( stdin_is_interactive ){
4352 fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
4354 process_input(p,in);
4361 ** Show available command line options
4363 static const char zOptions[] =
4364 " -ascii set output mode to 'ascii'\n"
4365 " -bail stop after hitting an error\n"
4366 " -batch force batch I/O\n"
4367 " -column set output mode to 'column'\n"
4368 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
4369 " -csv set output mode to 'csv'\n"
4370 " -echo print commands before execution\n"
4371 " -init FILENAME read/process named file\n"
4372 " -[no]header turn headers on or off\n"
4373 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4374 " -heap SIZE Size of heap for memsys3 or memsys5\n"
4376 " -help show this message\n"
4377 " -html set output mode to HTML\n"
4378 " -interactive force interactive I/O\n"
4379 " -line set output mode to 'line'\n"
4380 " -list set output mode to 'list'\n"
4381 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
4382 " -mmap N default mmap size set to N\n"
4383 #ifdef SQLITE_ENABLE_MULTIPLEX
4384 " -multiplex enable the multiplexor VFS\n"
4386 " -newline SEP set output row separator. Default: '\\n'\n"
4387 " -nullvalue TEXT set text string for NULL values. Default ''\n"
4388 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
4389 " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n"
4390 " -separator SEP set output column separator. Default: '|'\n"
4391 " -stats print memory stats before each finalize\n"
4392 " -version show SQLite version\n"
4393 " -vfs NAME use NAME as the default VFS\n"
4394 #ifdef SQLITE_ENABLE_VFSTRACE
4395 " -vfstrace enable tracing of all VFS calls\n"
4398 static void usage(int showDetail){
4400 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
4401 "FILENAME is the name of an SQLite database. A new database is created\n"
4402 "if the file does not previously exist.\n", Argv0);
4404 fprintf(stderr, "OPTIONS include:\n%s", zOptions);
4406 fprintf(stderr, "Use the -help option for additional information\n");
4412 ** Initialize the state information in data
4414 static void main_init(ShellState *data) {
4415 memset(data, 0, sizeof(*data));
4416 data->mode = MODE_List;
4417 memcpy(data->colSeparator,SEP_Column, 2);
4418 memcpy(data->rowSeparator,SEP_Row, 2);
4419 data->showHeader = 0;
4420 data->shellFlgs = SHFLG_Lookaside;
4421 sqlite3_config(SQLITE_CONFIG_URI, 1);
4422 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
4423 sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
4424 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
4425 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
4429 ** Output text to the console in a font that attracts extra attention.
4432 static void printBold(const char *zText){
4433 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
4434 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
4435 GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
4436 SetConsoleTextAttribute(out,
4437 FOREGROUND_RED|FOREGROUND_INTENSITY
4439 printf("%s", zText);
4440 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
4443 static void printBold(const char *zText){
4444 printf("\033[1m%s\033[0m", zText);
4449 ** Get the argument to an --option. Throw an error and die if no argument
4452 static char *cmdline_option_value(int argc, char **argv, int i){
4454 fprintf(stderr, "%s: Error: missing argument to %s\n",
4455 argv[0], argv[argc-1]);
4461 int SQLITE_CDECL main(int argc, char **argv){
4464 const char *zInitFile = 0;
4467 int warnInmemoryDb = 0;
4472 #if USE_SYSTEM_SQLITE+0!=1
4473 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
4474 fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
4475 sqlite3_sourceid(), SQLITE_SOURCE_ID);
4479 setBinaryMode(stdin);
4480 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
4483 stdin_is_interactive = isatty(0);
4485 /* Make sure we have a valid signal handler early, before anything
4489 signal(SIGINT, interrupt_handler);
4492 #ifdef SQLITE_SHELL_DBNAME_PROC
4494 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
4495 ** of a C-function that will provide the name of the database file. Use
4496 ** this compile-time option to embed this shell program in larger
4498 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
4499 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
4504 /* Do an initial pass through the command-line argument to locate
4505 ** the name of the database file, the name of the initialization file,
4506 ** the size of the alternative malloc heap,
4507 ** and the first command to execute.
4509 for(i=1; i<argc; i++){
4513 if( data.zDbFilename==0 ){
4514 data.zDbFilename = z;
4516 /* Excesss arguments are interpreted as SQL (or dot-commands) and
4517 ** mean that nothing is read from stdin */
4520 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
4522 fprintf(stderr, "out of memory\n");
4528 if( z[1]=='-' ) z++;
4529 if( strcmp(z,"-separator")==0
4530 || strcmp(z,"-nullvalue")==0
4531 || strcmp(z,"-newline")==0
4532 || strcmp(z,"-cmd")==0
4534 (void)cmdline_option_value(argc, argv, ++i);
4535 }else if( strcmp(z,"-init")==0 ){
4536 zInitFile = cmdline_option_value(argc, argv, ++i);
4537 }else if( strcmp(z,"-batch")==0 ){
4538 /* Need to check for batch mode here to so we can avoid printing
4539 ** informational messages (like from process_sqliterc) before
4540 ** we do the actual processing of arguments later in a second pass.
4542 stdin_is_interactive = 0;
4543 }else if( strcmp(z,"-heap")==0 ){
4544 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4546 sqlite3_int64 szHeap;
4548 zSize = cmdline_option_value(argc, argv, ++i);
4549 szHeap = integerValue(zSize);
4550 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
4551 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
4553 }else if( strcmp(z,"-scratch")==0 ){
4555 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4556 if( sz>400000 ) sz = 400000;
4557 if( sz<2500 ) sz = 2500;
4558 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4561 sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n);
4562 data.shellFlgs |= SHFLG_Scratch;
4563 }else if( strcmp(z,"-pagecache")==0 ){
4565 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4566 if( sz>70000 ) sz = 70000;
4567 if( sz<800 ) sz = 800;
4568 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4570 sqlite3_config(SQLITE_CONFIG_PAGECACHE, malloc(n*sz+1), sz, n);
4571 data.shellFlgs |= SHFLG_Pagecache;
4572 }else if( strcmp(z,"-lookaside")==0 ){
4574 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4576 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4578 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
4579 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
4580 #ifdef SQLITE_ENABLE_VFSTRACE
4581 }else if( strcmp(z,"-vfstrace")==0 ){
4582 extern int vfstrace_register(
4583 const char *zTraceName,
4584 const char *zOldVfsName,
4585 int (*xOut)(const char*,void*),
4589 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
4591 #ifdef SQLITE_ENABLE_MULTIPLEX
4592 }else if( strcmp(z,"-multiplex")==0 ){
4593 extern int sqlite3_multiple_initialize(const char*,int);
4594 sqlite3_multiplex_initialize(0, 1);
4596 }else if( strcmp(z,"-mmap")==0 ){
4597 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
4598 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
4599 }else if( strcmp(z,"-vfs")==0 ){
4600 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
4602 sqlite3_vfs_register(pVfs, 1);
4604 fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
4609 if( data.zDbFilename==0 ){
4610 #ifndef SQLITE_OMIT_MEMORYDB
4611 data.zDbFilename = ":memory:";
4612 warnInmemoryDb = argc==1;
4614 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
4620 /* Go ahead and open the database file if it already exists. If the
4621 ** file does not exist, delay opening it. This prevents empty database
4622 ** files from being created if a user mistypes the database name argument
4623 ** to the sqlite command-line tool.
4625 if( access(data.zDbFilename, 0)==0 ){
4629 /* Process the initialization file if there is one. If no -init option
4630 ** is given on the command line, look for a file named ~/.sqliterc and
4631 ** try to process it.
4633 process_sqliterc(&data,zInitFile);
4635 /* Make a second pass through the command-line argument and set
4636 ** options. This second pass is delayed until after the initialization
4637 ** file is processed so that the command-line arguments will override
4638 ** settings in the initialization file.
4640 for(i=1; i<argc; i++){
4642 if( z[0]!='-' ) continue;
4643 if( z[1]=='-' ){ z++; }
4644 if( strcmp(z,"-init")==0 ){
4646 }else if( strcmp(z,"-html")==0 ){
4647 data.mode = MODE_Html;
4648 }else if( strcmp(z,"-list")==0 ){
4649 data.mode = MODE_List;
4650 }else if( strcmp(z,"-line")==0 ){
4651 data.mode = MODE_Line;
4652 }else if( strcmp(z,"-column")==0 ){
4653 data.mode = MODE_Column;
4654 }else if( strcmp(z,"-csv")==0 ){
4655 data.mode = MODE_Csv;
4656 memcpy(data.colSeparator,",",2);
4657 }else if( strcmp(z,"-ascii")==0 ){
4658 data.mode = MODE_Ascii;
4659 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
4661 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
4663 }else if( strcmp(z,"-separator")==0 ){
4664 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
4665 "%s",cmdline_option_value(argc,argv,++i));
4666 }else if( strcmp(z,"-newline")==0 ){
4667 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
4668 "%s",cmdline_option_value(argc,argv,++i));
4669 }else if( strcmp(z,"-nullvalue")==0 ){
4670 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
4671 "%s",cmdline_option_value(argc,argv,++i));
4672 }else if( strcmp(z,"-header")==0 ){
4673 data.showHeader = 1;
4674 }else if( strcmp(z,"-noheader")==0 ){
4675 data.showHeader = 0;
4676 }else if( strcmp(z,"-echo")==0 ){
4678 }else if( strcmp(z,"-eqp")==0 ){
4680 }else if( strcmp(z,"-stats")==0 ){
4682 }else if( strcmp(z,"-scanstats")==0 ){
4683 data.scanstatsOn = 1;
4684 }else if( strcmp(z,"-backslash")==0 ){
4685 /* Undocumented command-line option: -backslash
4686 ** Causes C-style backslash escapes to be evaluated in SQL statements
4687 ** prior to sending the SQL into SQLite. Useful for injecting
4688 ** crazy bytes in the middle of SQL statements for testing and debugging.
4690 data.backslashOn = 1;
4691 }else if( strcmp(z,"-bail")==0 ){
4693 }else if( strcmp(z,"-version")==0 ){
4694 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
4696 }else if( strcmp(z,"-interactive")==0 ){
4697 stdin_is_interactive = 1;
4698 }else if( strcmp(z,"-batch")==0 ){
4699 stdin_is_interactive = 0;
4700 }else if( strcmp(z,"-heap")==0 ){
4702 }else if( strcmp(z,"-scratch")==0 ){
4704 }else if( strcmp(z,"-pagecache")==0 ){
4706 }else if( strcmp(z,"-lookaside")==0 ){
4708 }else if( strcmp(z,"-mmap")==0 ){
4710 }else if( strcmp(z,"-vfs")==0 ){
4712 #ifdef SQLITE_ENABLE_VFSTRACE
4713 }else if( strcmp(z,"-vfstrace")==0 ){
4716 #ifdef SQLITE_ENABLE_MULTIPLEX
4717 }else if( strcmp(z,"-multiplex")==0 ){
4720 }else if( strcmp(z,"-help")==0 ){
4722 }else if( strcmp(z,"-cmd")==0 ){
4723 /* Run commands that follow -cmd first and separately from commands
4724 ** that simply appear on the command-line. This seems goofy. It would
4725 ** be better if all commands ran in the order that they appear. But
4726 ** we retain the goofy behavior for historical compatibility. */
4727 if( i==argc-1 ) break;
4728 z = cmdline_option_value(argc,argv,++i);
4730 rc = do_meta_command(z, &data);
4731 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
4734 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
4736 fprintf(stderr,"Error: %s\n", zErrMsg);
4737 if( bail_on_error ) return rc!=0 ? rc : 1;
4739 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
4740 if( bail_on_error ) return rc;
4744 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
4745 fprintf(stderr,"Use -help for a list of options.\n");
4751 /* Run all arguments that do not begin with '-' as if they were separate
4752 ** command-line inputs, except for the argToSkip argument which contains
4753 ** the database filename.
4755 for(i=0; i<nCmd; i++){
4756 if( azCmd[i][0]=='.' ){
4757 rc = do_meta_command(azCmd[i], &data);
4758 if( rc ) return rc==2 ? 0 : rc;
4761 rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
4763 fprintf(stderr,"Error: %s\n", zErrMsg);
4764 return rc!=0 ? rc : 1;
4766 fprintf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
4773 /* Run commands received from standard input
4775 if( stdin_is_interactive ){
4780 "SQLite version %s %.19s\n" /*extra-version-info*/
4781 "Enter \".help\" for usage hints.\n",
4782 sqlite3_libversion(), sqlite3_sourceid()
4784 if( warnInmemoryDb ){
4785 printf("Connected to a ");
4786 printBold("transient in-memory database");
4787 printf(".\nUse \".open FILENAME\" to reopen on a "
4788 "persistent database.\n");
4790 zHome = find_home_dir();
4792 nHistory = strlen30(zHome) + 20;
4793 if( (zHistory = malloc(nHistory))!=0 ){
4794 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
4797 if( zHistory ){ shell_read_history(zHistory); }
4798 rc = process_input(&data, 0);
4800 shell_stifle_history(100);
4801 shell_write_history(zHistory);
4805 rc = process_input(&data, stdin);
4808 set_table_name(&data, 0);
4810 sqlite3_close(data.db);
4812 sqlite3_free(data.zFreeOnClose);