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))
111 #define pclose _pclose
113 /* Make sure isatty() has a prototype.
115 extern int isatty(int);
117 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
118 /* popen and pclose are not C89 functions and so are sometimes omitted from
119 ** the <stdio.h> header */
120 extern FILE *popen(const char*,const char*);
121 extern int pclose(FILE*);
123 # define SQLITE_OMIT_POPEN 1
128 #if defined(_WIN32_WCE)
129 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
130 * thus we always assume that we have a console. That can be
131 * overridden with the -batch command line option.
136 /* ctype macros that work with signed characters */
137 #define IsSpace(X) isspace((unsigned char)X)
138 #define IsDigit(X) isdigit((unsigned char)X)
139 #define ToLower(X) (char)tolower((unsigned char)X)
141 /* On Windows, we normally run with output mode of TEXT so that \n characters
142 ** are automatically translated into \r\n. However, this behavior needs
143 ** to be disabled in some cases (ex: when generating CSV output and when
144 ** rendering quoted strings that contain \n characters). The following
145 ** routines take care of that.
147 #if defined(_WIN32) || defined(WIN32)
148 static void setBinaryMode(FILE *out){
150 _setmode(_fileno(out), _O_BINARY);
152 static void setTextMode(FILE *out){
154 _setmode(_fileno(out), _O_TEXT);
157 # define setBinaryMode(X)
158 # define setTextMode(X)
162 /* True if the timer is enabled */
163 static int enableTimer = 0;
165 /* Return the current wall-clock time */
166 static sqlite3_int64 timeOfDay(void){
167 static sqlite3_vfs *clockVfs = 0;
169 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
170 if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
171 clockVfs->xCurrentTimeInt64(clockVfs, &t);
174 clockVfs->xCurrentTime(clockVfs, &r);
175 t = (sqlite3_int64)(r*86400000.0);
180 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
181 #include <sys/time.h>
182 #include <sys/resource.h>
184 /* VxWorks does not support getrusage() as far as we can determine */
185 #if defined(_WRS_KERNEL) || defined(__RTP__)
187 struct timeval ru_utime; /* user CPU time used */
188 struct timeval ru_stime; /* system CPU time used */
190 #define getrusage(A,B) memset(B,0,sizeof(*B))
193 /* Saved resource information for the beginning of an operation */
194 static struct rusage sBegin; /* CPU time at start */
195 static sqlite3_int64 iBegin; /* Wall-clock time at start */
198 ** Begin timing an operation
200 static void beginTimer(void){
202 getrusage(RUSAGE_SELF, &sBegin);
203 iBegin = timeOfDay();
207 /* Return the difference of two time_structs in seconds */
208 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
209 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
210 (double)(pEnd->tv_sec - pStart->tv_sec);
214 ** Print the timing results.
216 static void endTimer(void){
218 sqlite3_int64 iEnd = timeOfDay();
220 getrusage(RUSAGE_SELF, &sEnd);
221 printf("Run Time: real %.3f user %f sys %f\n",
222 (iEnd - iBegin)*0.001,
223 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
224 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
228 #define BEGIN_TIMER beginTimer()
229 #define END_TIMER endTimer()
232 #elif (defined(_WIN32) || defined(WIN32))
236 /* Saved resource information for the beginning of an operation */
237 static HANDLE hProcess;
238 static FILETIME ftKernelBegin;
239 static FILETIME ftUserBegin;
240 static sqlite3_int64 ftWallBegin;
241 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
242 LPFILETIME, LPFILETIME);
243 static GETPROCTIMES getProcessTimesAddr = NULL;
246 ** Check to see if we have timer support. Return 1 if necessary
247 ** support found (or found previously).
249 static int hasTimer(void){
250 if( getProcessTimesAddr ){
253 /* GetProcessTimes() isn't supported in WIN95 and some other Windows
254 ** versions. See if the version we are running on has it, and if it
255 ** does, save off a pointer to it and the current process handle.
257 hProcess = GetCurrentProcess();
259 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
260 if( NULL != hinstLib ){
261 getProcessTimesAddr =
262 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
263 if( NULL != getProcessTimesAddr ){
266 FreeLibrary(hinstLib);
274 ** Begin timing an operation
276 static void beginTimer(void){
277 if( enableTimer && getProcessTimesAddr ){
278 FILETIME ftCreation, ftExit;
279 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
280 &ftKernelBegin,&ftUserBegin);
281 ftWallBegin = timeOfDay();
285 /* Return the difference of two FILETIME structs in seconds */
286 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
287 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
288 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
289 return (double) ((i64End - i64Start) / 10000000.0);
293 ** Print the timing results.
295 static void endTimer(void){
296 if( enableTimer && getProcessTimesAddr){
297 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
298 sqlite3_int64 ftWallEnd = timeOfDay();
299 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
300 printf("Run Time: real %.3f user %f sys %f\n",
301 (ftWallEnd - ftWallBegin)*0.001,
302 timeDiff(&ftUserBegin, &ftUserEnd),
303 timeDiff(&ftKernelBegin, &ftKernelEnd));
307 #define BEGIN_TIMER beginTimer()
308 #define END_TIMER endTimer()
309 #define HAS_TIMER hasTimer()
318 ** Used to prevent warnings about unused parameters
320 #define UNUSED_PARAMETER(x) (void)(x)
323 ** If the following flag is set, then command execution stops
324 ** at an error if we are not interactive.
326 static int bail_on_error = 0;
329 ** Threat stdin as an interactive input if the following variable
330 ** is true. Otherwise, assume stdin is connected to a file or pipe.
332 static int stdin_is_interactive = 1;
335 ** The following is the open SQLite database. We make a pointer
336 ** to this database a static variable so that it can be accessed
337 ** by the SIGINT handler to interrupt database processing.
339 static sqlite3 *db = 0;
342 ** True if an interrupt (Control-C) has been received.
344 static volatile int seenInterrupt = 0;
347 ** This is the name of our program. It is set in main(), used
348 ** in a number of other places, mostly for error messages.
353 ** Prompt strings. Initialized in main. Settable with
354 ** .prompt main continue
356 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
357 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
360 ** Write I/O traces to the following stream.
362 #ifdef SQLITE_ENABLE_IOTRACE
363 static FILE *iotrace = 0;
367 ** This routine works like printf in that its first argument is a
368 ** format string and subsequent arguments are values to be substituted
369 ** in place of % fields. The result of formatting this string
370 ** is written to iotrace.
372 #ifdef SQLITE_ENABLE_IOTRACE
373 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
376 if( iotrace==0 ) return;
377 va_start(ap, zFormat);
378 z = sqlite3_vmprintf(zFormat, ap);
380 fprintf(iotrace, "%s", z);
387 ** Determines if a string is a number of not.
389 static int isNumber(const char *z, int *realnum){
390 if( *z=='-' || *z=='+' ) z++;
395 if( realnum ) *realnum = 0;
396 while( IsDigit(*z) ){ z++; }
399 if( !IsDigit(*z) ) return 0;
400 while( IsDigit(*z) ){ z++; }
401 if( realnum ) *realnum = 1;
403 if( *z=='e' || *z=='E' ){
405 if( *z=='+' || *z=='-' ) z++;
406 if( !IsDigit(*z) ) return 0;
407 while( IsDigit(*z) ){ z++; }
408 if( realnum ) *realnum = 1;
414 ** A global char* and an SQL function to access its current value
415 ** from within an SQL statement. This program used to use the
416 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
417 ** The correct way to do this with sqlite3 is to use the bind API, but
418 ** since the shell is built around the callback paradigm it would be a lot
419 ** of work. Instead just use this hack, which is quite harmless.
421 static const char *zShellStatic = 0;
422 static void shellstaticFunc(
423 sqlite3_context *context,
428 assert( zShellStatic );
429 UNUSED_PARAMETER(argc);
430 UNUSED_PARAMETER(argv);
431 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
436 ** This routine reads a line of text from FILE in, stores
437 ** the text in memory obtained from malloc() and returns a pointer
438 ** to the text. NULL is returned at end of file, or if malloc()
441 ** If zLine is not NULL then it is a malloced buffer returned from
442 ** a previous call to this routine that may be reused.
444 static char *local_getline(char *zLine, FILE *in){
445 int nLine = zLine==0 ? 0 : 100;
450 nLine = nLine*2 + 100;
451 zLine = realloc(zLine, nLine);
452 if( zLine==0 ) return 0;
454 if( fgets(&zLine[n], nLine - n, in)==0 ){
462 while( zLine[n] ) n++;
463 if( n>0 && zLine[n-1]=='\n' ){
465 if( n>0 && zLine[n-1]=='\r' ) n--;
474 ** Retrieve a single line of input text.
476 ** If in==0 then read from standard input and prompt before each line.
477 ** If isContinuation is true, then a continuation prompt is appropriate.
478 ** If isContinuation is zero, then the main prompt should be used.
480 ** If zPrior is not NULL then it is a buffer from a prior call to this
481 ** routine that can be reused.
483 ** The result is stored in space obtained from malloc() and must either
484 ** be freed by the caller or else passed back into this routine via the
485 ** zPrior argument for reuse.
487 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
491 zResult = local_getline(zPrior, in);
493 zPrompt = isContinuation ? continuePrompt : mainPrompt;
494 #if SHELL_USE_LOCAL_GETLINE
495 printf("%s", zPrompt);
497 zResult = local_getline(zPrior, stdin);
500 zResult = shell_readline(zPrompt);
501 if( zResult && *zResult ) shell_add_history(zResult);
508 ** Shell output mode information from before ".explain on",
509 ** saved so that it can be restored by ".explain off"
511 typedef struct SavedModeInfo SavedModeInfo;
512 struct SavedModeInfo {
513 int valid; /* Is there legit data in here? */
514 int mode; /* Mode prior to ".explain on" */
515 int showHeader; /* The ".header" setting prior to ".explain on" */
516 int colWidth[100]; /* Column widths prior to ".explain on" */
520 ** State information about the database connection is contained in an
521 ** instance of the following structure.
523 typedef struct ShellState ShellState;
525 sqlite3 *db; /* The database */
526 int echoOn; /* True to echo input commands */
527 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
528 int statsOn; /* True to display memory stats before each finalize */
529 int scanstatsOn; /* True to display scan stats before each finalize */
530 int outCount; /* Revert to stdout when reaching zero */
531 int cnt; /* Number of records displayed so far */
532 FILE *out; /* Write results here */
533 FILE *traceOut; /* Output for sqlite3_trace() */
534 int nErr; /* Number of errors seen */
535 int mode; /* An output mode setting */
536 int writableSchema; /* True if PRAGMA writable_schema=ON */
537 int showHeader; /* True to show column names in List or Column mode */
538 unsigned shellFlgs; /* Various flags */
539 char *zDestTable; /* Name of destination table when MODE_Insert */
540 char colSeparator[20]; /* Column separator character for several modes */
541 char rowSeparator[20]; /* Row separator character for MODE_Ascii */
542 int colWidth[100]; /* Requested width of each column when in column mode*/
543 int actualWidth[100]; /* Actual width of each column */
544 char nullValue[20]; /* The text to print when a NULL comes back from
546 SavedModeInfo normalMode;/* Holds the mode just before .explain ON */
547 char outfile[FILENAME_MAX]; /* Filename for *out */
548 const char *zDbFilename; /* name of the database file */
549 char *zFreeOnClose; /* Filename to free when closing */
550 const char *zVfs; /* Name of VFS to use */
551 sqlite3_stmt *pStmt; /* Current statement if any. */
552 FILE *pLog; /* Write log output here */
553 int *aiIndent; /* Array of indents used in MODE_Explain */
554 int nIndent; /* Size of array aiIndent[] */
555 int iIndent; /* Index of current op in aiIndent[] */
559 ** These are the allowed shellFlgs values
561 #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
562 #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
563 #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
566 ** These are the allowed modes.
568 #define MODE_Line 0 /* One column per line. Blank line between records */
569 #define MODE_Column 1 /* One record per line in neat columns */
570 #define MODE_List 2 /* One record per line with a separator */
571 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
572 #define MODE_Html 4 /* Generate an XHTML table */
573 #define MODE_Insert 5 /* Generate SQL "insert" statements */
574 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
575 #define MODE_Csv 7 /* Quote strings, numbers are plain */
576 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
577 #define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */
579 static const char *modeDescr[] = {
593 ** These are the column/row/line separators used by the various
594 ** import/export modes.
596 #define SEP_Column "|"
599 #define SEP_Space " "
600 #define SEP_Comma ","
601 #define SEP_CrLf "\r\n"
602 #define SEP_Unit "\x1F"
603 #define SEP_Record "\x1E"
606 ** Number of elements in an array
608 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
611 ** Compute a string length that is limited to what can be stored in
612 ** lower 30 bits of a 32-bit signed integer.
614 static int strlen30(const char *z){
616 while( *z2 ){ z2++; }
617 return 0x3fffffff & (int)(z2 - z);
621 ** A callback for the sqlite3_log() interface.
623 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
624 ShellState *p = (ShellState*)pArg;
625 if( p->pLog==0 ) return;
626 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
631 ** Output the given string as a hex-encoded blob (eg. X'1234' )
633 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
635 char *zBlob = (char *)pBlob;
637 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
642 ** Output the given string as a quoted string using SQL quoting conventions.
644 static void output_quoted_string(FILE *out, const char *z){
649 if( z[i]=='\'' ) nSingle++;
652 fprintf(out,"'%s'",z);
656 for(i=0; z[i] && z[i]!='\''; i++){}
660 }else if( z[i]=='\'' ){
661 fprintf(out,"%.*s''",i,z);
674 ** Output the given string as a quoted according to C or TCL quoting rules.
676 static void output_c_string(FILE *out, const char *z){
679 while( (c = *(z++))!=0 ){
695 }else if( !isprint(c&0xff) ){
696 fprintf(out, "\\%03o", c&0xff);
705 ** Output the given string with characters that are special to
708 static void output_html_string(FILE *out, const char *z){
720 fprintf(out,"%.*s",i,z);
724 }else if( z[i]=='&' ){
725 fprintf(out,"&");
726 }else if( z[i]=='>' ){
728 }else if( z[i]=='\"' ){
729 fprintf(out,""");
730 }else if( z[i]=='\'' ){
731 fprintf(out,"'");
740 ** If a field contains any character identified by a 1 in the following
741 ** array, then the string must be quoted for CSV.
743 static const char needCsvQuote[] = {
744 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
745 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
746 1, 0, 1, 0, 0, 0, 0, 1, 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, 0,
751 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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,
759 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
763 ** Output a single term of CSV. Actually, p->colSeparator is used for
764 ** the separator, which may or may not be a comma. p->nullValue is
765 ** the null value. Strings are quoted if necessary. The separator
766 ** is only issued if bSep is true.
768 static void output_csv(ShellState *p, const char *z, int bSep){
771 fprintf(out,"%s",p->nullValue);
774 int nSep = strlen30(p->colSeparator);
776 if( needCsvQuote[((unsigned char*)z)[i]]
777 || (z[i]==p->colSeparator[0] &&
778 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
786 if( z[i]=='"' ) putc('"', out);
791 fprintf(out, "%s", z);
795 fprintf(p->out, "%s", p->colSeparator);
801 ** This routine runs when the user presses Ctrl-C
803 static void interrupt_handler(int NotUsed){
804 UNUSED_PARAMETER(NotUsed);
806 if( seenInterrupt>2 ) exit(1);
807 if( db ) sqlite3_interrupt(db);
812 ** This is the callback routine that the shell
813 ** invokes for each row of a query result.
815 static int shell_callback(
817 int nArg, /* Number of result columns */
818 char **azArg, /* Text of each result column */
819 char **azCol, /* Column names */
820 int *aiType /* Column types */
823 ShellState *p = (ShellState*)pArg;
828 if( azArg==0 ) break;
829 for(i=0; i<nArg; i++){
830 int len = strlen30(azCol[i] ? azCol[i] : "");
833 if( p->cnt++>0 ) fprintf(p->out, "%s", p->rowSeparator);
834 for(i=0; i<nArg; i++){
835 fprintf(p->out,"%*s = %s%s", w, azCol[i],
836 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
843 for(i=0; i<nArg; i++){
845 if( i<ArraySize(p->colWidth) ){
851 w = strlen30(azCol[i] ? azCol[i] : "");
853 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue);
856 if( i<ArraySize(p->actualWidth) ){
857 p->actualWidth[i] = w;
861 fprintf(p->out,"%*.*s%s",-w,-w,azCol[i],
862 i==nArg-1 ? p->rowSeparator : " ");
864 fprintf(p->out,"%-*.*s%s",w,w,azCol[i],
865 i==nArg-1 ? p->rowSeparator : " ");
870 for(i=0; i<nArg; i++){
872 if( i<ArraySize(p->actualWidth) ){
873 w = p->actualWidth[i];
878 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
879 "----------------------------------------------------------",
880 i==nArg-1 ? p->rowSeparator : " ");
884 if( azArg==0 ) break;
885 for(i=0; i<nArg; i++){
887 if( i<ArraySize(p->actualWidth) ){
888 w = p->actualWidth[i];
892 if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
893 w = strlen30(azArg[i]);
895 if( i==1 && p->aiIndent && p->pStmt ){
896 if( p->iIndent<p->nIndent ){
897 fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
902 fprintf(p->out,"%*.*s%s",-w,-w,
903 azArg[i] ? azArg[i] : p->nullValue,
904 i==nArg-1 ? p->rowSeparator : " ");
906 fprintf(p->out,"%-*.*s%s",w,w,
907 azArg[i] ? azArg[i] : p->nullValue,
908 i==nArg-1 ? p->rowSeparator : " ");
915 if( p->cnt++==0 && p->showHeader ){
916 for(i=0; i<nArg; i++){
917 fprintf(p->out,"%s%s",azCol[i],
918 i==nArg-1 ? p->rowSeparator : p->colSeparator);
921 if( azArg==0 ) break;
922 for(i=0; i<nArg; i++){
924 if( z==0 ) z = p->nullValue;
925 fprintf(p->out, "%s", z);
927 fprintf(p->out, "%s", p->colSeparator);
928 }else if( p->mode==MODE_Semi ){
929 fprintf(p->out, ";%s", p->rowSeparator);
931 fprintf(p->out, "%s", p->rowSeparator);
937 if( p->cnt++==0 && p->showHeader ){
938 fprintf(p->out,"<TR>");
939 for(i=0; i<nArg; i++){
940 fprintf(p->out,"<TH>");
941 output_html_string(p->out, azCol[i]);
942 fprintf(p->out,"</TH>\n");
944 fprintf(p->out,"</TR>\n");
946 if( azArg==0 ) break;
947 fprintf(p->out,"<TR>");
948 for(i=0; i<nArg; i++){
949 fprintf(p->out,"<TD>");
950 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
951 fprintf(p->out,"</TD>\n");
953 fprintf(p->out,"</TR>\n");
957 if( p->cnt++==0 && p->showHeader ){
958 for(i=0; i<nArg; i++){
959 output_c_string(p->out,azCol[i] ? azCol[i] : "");
960 if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
962 fprintf(p->out, "%s", p->rowSeparator);
964 if( azArg==0 ) break;
965 for(i=0; i<nArg; i++){
966 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
967 if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
969 fprintf(p->out, "%s", p->rowSeparator);
973 setBinaryMode(p->out);
974 if( p->cnt++==0 && p->showHeader ){
975 for(i=0; i<nArg; i++){
976 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
978 fprintf(p->out, "%s", p->rowSeparator);
981 for(i=0; i<nArg; i++){
982 output_csv(p, azArg[i], i<nArg-1);
984 fprintf(p->out, "%s", p->rowSeparator);
991 if( azArg==0 ) break;
992 fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
993 for(i=0; i<nArg; i++){
994 char *zSep = i>0 ? ",": "";
995 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
996 fprintf(p->out,"%sNULL",zSep);
997 }else if( aiType && aiType[i]==SQLITE_TEXT ){
998 if( zSep[0] ) fprintf(p->out,"%s",zSep);
999 output_quoted_string(p->out, azArg[i]);
1000 }else if( aiType && (aiType[i]==SQLITE_INTEGER
1001 || aiType[i]==SQLITE_FLOAT) ){
1002 fprintf(p->out,"%s%s",zSep, azArg[i]);
1003 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
1004 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
1005 int nBlob = sqlite3_column_bytes(p->pStmt, i);
1006 if( zSep[0] ) fprintf(p->out,"%s",zSep);
1007 output_hex_blob(p->out, pBlob, nBlob);
1008 }else if( isNumber(azArg[i], 0) ){
1009 fprintf(p->out,"%s%s",zSep, azArg[i]);
1011 if( zSep[0] ) fprintf(p->out,"%s",zSep);
1012 output_quoted_string(p->out, azArg[i]);
1015 fprintf(p->out,");\n");
1019 if( p->cnt++==0 && p->showHeader ){
1020 for(i=0; i<nArg; i++){
1021 if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1022 fprintf(p->out,"%s",azCol[i] ? azCol[i] : "");
1024 fprintf(p->out, "%s", p->rowSeparator);
1026 if( azArg==0 ) break;
1027 for(i=0; i<nArg; i++){
1028 if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1029 fprintf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
1031 fprintf(p->out, "%s", p->rowSeparator);
1039 ** This is the callback routine that the SQLite library
1040 ** invokes for each row of a query result.
1042 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1043 /* since we don't have type info, call the shell_callback with a NULL value */
1044 return shell_callback(pArg, nArg, azArg, azCol, NULL);
1048 ** Set the destination table field of the ShellState structure to
1049 ** the name of the table given. Escape any quote characters in the
1052 static void set_table_name(ShellState *p, const char *zName){
1057 if( p->zDestTable ){
1058 free(p->zDestTable);
1061 if( zName==0 ) return;
1062 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1063 for(i=n=0; zName[i]; i++, n++){
1064 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1066 if( zName[i]=='\'' ) n++;
1069 if( needQuote ) n += 2;
1070 z = p->zDestTable = malloc( n+1 );
1072 fprintf(stderr,"Error: out of memory\n");
1076 if( needQuote ) z[n++] = '\'';
1077 for(i=0; zName[i]; i++){
1079 if( zName[i]=='\'' ) z[n++] = '\'';
1081 if( needQuote ) z[n++] = '\'';
1085 /* zIn is either a pointer to a NULL-terminated string in memory obtained
1086 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1087 ** added to zIn, and the result returned in memory obtained from malloc().
1088 ** zIn, if it was not NULL, is freed.
1090 ** If the third argument, quote, is not '\0', then it is used as a
1091 ** quote character for zAppend.
1093 static char *appendText(char *zIn, char const *zAppend, char quote){
1096 int nAppend = strlen30(zAppend);
1097 int nIn = (zIn?strlen30(zIn):0);
1099 len = nAppend+nIn+1;
1102 for(i=0; i<nAppend; i++){
1103 if( zAppend[i]==quote ) len++;
1107 zIn = (char *)realloc(zIn, len);
1113 char *zCsr = &zIn[nIn];
1115 for(i=0; i<nAppend; i++){
1116 *zCsr++ = zAppend[i];
1117 if( zAppend[i]==quote ) *zCsr++ = quote;
1121 assert( (zCsr-zIn)==len );
1123 memcpy(&zIn[nIn], zAppend, nAppend);
1132 ** Execute a query statement that will generate SQL output. Print
1133 ** the result columns, comma-separated, on a line and then add a
1134 ** semicolon terminator to the end of that line.
1136 ** If the number of columns is 1 and that column contains text "--"
1137 ** then write the semicolon on a separate line. That way, if a
1138 ** "--" comment occurs at the end of the statement, the comment
1139 ** won't consume the semicolon terminator.
1141 static int run_table_dump_query(
1142 ShellState *p, /* Query context */
1143 const char *zSelect, /* SELECT statement to extract content */
1144 const char *zFirstRow /* Print before first row, if not NULL */
1146 sqlite3_stmt *pSelect;
1151 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
1152 if( rc!=SQLITE_OK || !pSelect ){
1153 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1154 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1157 rc = sqlite3_step(pSelect);
1158 nResult = sqlite3_column_count(pSelect);
1159 while( rc==SQLITE_ROW ){
1161 fprintf(p->out, "%s", zFirstRow);
1164 z = (const char*)sqlite3_column_text(pSelect, 0);
1165 fprintf(p->out, "%s", z);
1166 for(i=1; i<nResult; i++){
1167 fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
1170 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
1172 fprintf(p->out, "\n;\n");
1174 fprintf(p->out, ";\n");
1176 rc = sqlite3_step(pSelect);
1178 rc = sqlite3_finalize(pSelect);
1179 if( rc!=SQLITE_OK ){
1180 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1181 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1187 ** Allocate space and save off current error string.
1189 static char *save_err_msg(
1190 sqlite3 *db /* Database to query */
1192 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1193 char *zErrMsg = sqlite3_malloc(nErrMsg);
1195 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1201 ** Display memory stats.
1203 static int display_stats(
1204 sqlite3 *db, /* Database to query */
1205 ShellState *pArg, /* Pointer to ShellState */
1206 int bReset /* True to reset the stats */
1211 if( pArg && pArg->out ){
1214 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1216 "Memory Used: %d (max %d) bytes\n",
1219 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1220 fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1222 if( pArg->shellFlgs & SHFLG_Pagecache ){
1224 sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1226 "Number of Pcache Pages Used: %d (max %d) pages\n",
1230 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1232 "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1234 if( pArg->shellFlgs & SHFLG_Scratch ){
1236 sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1237 fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n",
1241 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1243 "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1246 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1247 fprintf(pArg->out, "Largest Allocation: %d bytes\n",
1250 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1251 fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1254 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1255 fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1257 #ifdef YYTRACKMAXSTACKDEPTH
1259 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1260 fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1265 if( pArg && pArg->out && db ){
1266 if( pArg->shellFlgs & SHFLG_Lookaside ){
1268 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
1269 &iCur, &iHiwtr, bReset);
1270 fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n",
1272 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
1273 &iCur, &iHiwtr, bReset);
1274 fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr);
1275 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
1276 &iCur, &iHiwtr, bReset);
1277 fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr);
1278 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
1279 &iCur, &iHiwtr, bReset);
1280 fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr);
1283 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1284 fprintf(pArg->out, "Pager Heap Usage: %d bytes\n",iCur);
1286 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1287 fprintf(pArg->out, "Page cache hits: %d\n", iCur);
1289 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1290 fprintf(pArg->out, "Page cache misses: %d\n", iCur);
1292 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1293 fprintf(pArg->out, "Page cache writes: %d\n", iCur);
1295 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1296 fprintf(pArg->out, "Schema Heap Usage: %d bytes\n",iCur);
1298 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1299 fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",iCur);
1302 if( pArg && pArg->out && db && pArg->pStmt ){
1303 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
1305 fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1306 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1307 fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1308 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
1309 fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1310 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
1311 fprintf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
1318 ** Display scan stats.
1320 static void display_scanstats(
1321 sqlite3 *db, /* Database to query */
1322 ShellState *pArg /* Pointer to ShellState */
1324 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1326 fprintf(pArg->out, "-------- scanstats --------\n");
1328 for(k=0; k<=mx; k++){
1329 double rEstLoop = 1.0;
1331 sqlite3_stmt *p = pArg->pStmt;
1332 sqlite3_int64 nLoop, nVisit;
1335 const char *zExplain;
1336 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
1339 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
1340 if( iSid>mx ) mx = iSid;
1341 if( iSid!=k ) continue;
1343 rEstLoop = (double)nLoop;
1344 if( k>0 ) fprintf(pArg->out, "-------- subquery %d -------\n", k);
1347 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
1348 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
1349 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
1350 fprintf(pArg->out, "Loop %2d: %s\n", n, zExplain);
1353 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
1354 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
1358 fprintf(pArg->out, "---------------------------\n");
1363 ** Parameter azArray points to a zero-terminated array of strings. zStr
1364 ** points to a single nul-terminated string. Return non-zero if zStr
1365 ** is equal, according to strcmp(), to any of the strings in the array.
1366 ** Otherwise, return zero.
1368 static int str_in_array(const char *zStr, const char **azArray){
1370 for(i=0; azArray[i]; i++){
1371 if( 0==strcmp(zStr, azArray[i]) ) return 1;
1377 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1378 ** and populate the ShellState.aiIndent[] array with the number of
1379 ** spaces each opcode should be indented before it is output.
1381 ** The indenting rules are:
1383 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1384 ** all opcodes that occur between the p2 jump destination and the opcode
1385 ** itself by 2 spaces.
1387 ** * For each "Goto", if the jump destination is earlier in the program
1388 ** and ends on one of:
1389 ** Yield SeekGt SeekLt RowSetRead Rewind
1390 ** or if the P1 parameter is one instead of zero,
1391 ** then indent all opcodes between the earlier instruction
1392 ** and "Goto" by 2 spaces.
1394 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
1395 const char *zSql; /* The text of the SQL statement */
1396 const char *z; /* Used to check if this is an EXPLAIN */
1397 int *abYield = 0; /* True if op is an OP_Yield */
1398 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
1399 int iOp; /* Index of operation in p->aiIndent[] */
1401 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
1402 "NextIfOpen", "PrevIfOpen", 0 };
1403 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
1405 const char *azGoto[] = { "Goto", 0 };
1407 /* Try to figure out if this is really an EXPLAIN statement. If this
1408 ** cannot be verified, return early. */
1409 zSql = sqlite3_sql(pSql);
1410 if( zSql==0 ) return;
1411 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
1412 if( sqlite3_strnicmp(z, "explain", 7) ) return;
1414 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
1416 int iAddr = sqlite3_column_int(pSql, 0);
1417 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
1419 /* Set p2 to the P2 field of the current opcode. Then, assuming that
1420 ** p2 is an instruction address, set variable p2op to the index of that
1421 ** instruction in the aiIndent[] array. p2 and p2op may be different if
1422 ** the current instruction is part of a sub-program generated by an
1423 ** SQL trigger or foreign key. */
1424 int p2 = sqlite3_column_int(pSql, 3);
1425 int p2op = (p2 + (iOp-iAddr));
1427 /* Grow the p->aiIndent array as required */
1430 p->aiIndent = (int*)sqlite3_realloc(p->aiIndent, nAlloc*sizeof(int));
1431 abYield = (int*)sqlite3_realloc(abYield, nAlloc*sizeof(int));
1433 abYield[iOp] = str_in_array(zOp, azYield);
1434 p->aiIndent[iOp] = 0;
1437 if( str_in_array(zOp, azNext) ){
1438 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
1440 if( str_in_array(zOp, azGoto) && p2op<p->nIndent
1441 && (abYield[p2op] || sqlite3_column_int(pSql, 2))
1443 for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
1448 sqlite3_free(abYield);
1449 sqlite3_reset(pSql);
1453 ** Free the array allocated by explain_data_prepare().
1455 static void explain_data_delete(ShellState *p){
1456 sqlite3_free(p->aiIndent);
1463 ** Execute a statement or set of statements. Print
1464 ** any result rows/columns depending on the current mode
1465 ** set via the supplied callback.
1467 ** This is very similar to SQLite's built-in sqlite3_exec()
1468 ** function except it takes a slightly different callback
1469 ** and callback data argument.
1471 static int shell_exec(
1472 sqlite3 *db, /* An open database */
1473 const char *zSql, /* SQL to be evaluated */
1474 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1475 /* (not the same as sqlite3_exec) */
1476 ShellState *pArg, /* Pointer to ShellState */
1477 char **pzErrMsg /* Error msg written here */
1479 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1480 int rc = SQLITE_OK; /* Return Code */
1482 const char *zLeftover; /* Tail of unprocessed SQL */
1488 while( zSql[0] && (SQLITE_OK == rc) ){
1489 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1490 if( SQLITE_OK != rc ){
1492 *pzErrMsg = save_err_msg(db);
1496 /* this happens for a comment or white-space */
1498 while( IsSpace(zSql[0]) ) zSql++;
1502 /* save off the prepared statment handle and reset row count */
1504 pArg->pStmt = pStmt;
1508 /* echo the sql statement if echo on */
1509 if( pArg && pArg->echoOn ){
1510 const char *zStmtSql = sqlite3_sql(pStmt);
1511 fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1514 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1515 if( pArg && pArg->autoEQP ){
1516 sqlite3_stmt *pExplain;
1517 char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
1518 sqlite3_sql(pStmt));
1519 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
1520 if( rc==SQLITE_OK ){
1521 while( sqlite3_step(pExplain)==SQLITE_ROW ){
1522 fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0));
1523 fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
1524 fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
1525 fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
1528 sqlite3_finalize(pExplain);
1532 /* If the shell is currently in ".explain" mode, gather the extra
1533 ** data required to add indents to the output.*/
1534 if( pArg && pArg->mode==MODE_Explain ){
1535 explain_data_prepare(pArg, pStmt);
1538 /* perform the first step. this will tell us if we
1539 ** have a result set or not and how wide it is.
1541 rc = sqlite3_step(pStmt);
1542 /* if we have a result set... */
1543 if( SQLITE_ROW == rc ){
1544 /* if we have a callback... */
1546 /* allocate space for col name ptr, value ptr, and type */
1547 int nCol = sqlite3_column_count(pStmt);
1548 void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1552 char **azCols = (char **)pData; /* Names of result columns */
1553 char **azVals = &azCols[nCol]; /* Results */
1554 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1556 assert(sizeof(int) <= sizeof(char *));
1557 /* save off ptrs to column names */
1558 for(i=0; i<nCol; i++){
1559 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1562 /* extract the data and data types */
1563 for(i=0; i<nCol; i++){
1564 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
1565 if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
1568 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
1570 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1572 break; /* from for */
1576 /* if data and types extracted successfully... */
1577 if( SQLITE_ROW == rc ){
1578 /* call the supplied callback with the result row data */
1579 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1582 rc = sqlite3_step(pStmt);
1585 } while( SQLITE_ROW == rc );
1586 sqlite3_free(pData);
1590 rc = sqlite3_step(pStmt);
1591 } while( rc == SQLITE_ROW );
1595 explain_data_delete(pArg);
1597 /* print usage stats if stats on */
1598 if( pArg && pArg->statsOn ){
1599 display_stats(db, pArg, 0);
1602 /* print loop-counters if required */
1603 if( pArg && pArg->scanstatsOn ){
1604 display_scanstats(db, pArg);
1607 /* Finalize the statement just executed. If this fails, save a
1608 ** copy of the error message. Otherwise, set zSql to point to the
1609 ** next statement to execute. */
1610 rc2 = sqlite3_finalize(pStmt);
1611 if( rc!=SQLITE_NOMEM ) rc = rc2;
1612 if( rc==SQLITE_OK ){
1614 while( IsSpace(zSql[0]) ) zSql++;
1615 }else if( pzErrMsg ){
1616 *pzErrMsg = save_err_msg(db);
1619 /* clear saved stmt handle */
1631 ** This is a different callback routine used for dumping the database.
1632 ** Each row received by this callback consists of a table name,
1633 ** the table type ("index" or "table") and SQL to create the table.
1634 ** This routine should print text sufficient to recreate the table.
1636 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1641 const char *zPrepStmt = 0;
1642 ShellState *p = (ShellState *)pArg;
1644 UNUSED_PARAMETER(azCol);
1645 if( nArg!=3 ) return 1;
1650 if( strcmp(zTable, "sqlite_sequence")==0 ){
1651 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1652 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
1653 fprintf(p->out, "ANALYZE sqlite_master;\n");
1654 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1656 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1658 if( !p->writableSchema ){
1659 fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1660 p->writableSchema = 1;
1662 zIns = sqlite3_mprintf(
1663 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1664 "VALUES('table','%q','%q',0,'%q');",
1665 zTable, zTable, zSql);
1666 fprintf(p->out, "%s\n", zIns);
1670 fprintf(p->out, "%s;\n", zSql);
1673 if( strcmp(zType, "table")==0 ){
1674 sqlite3_stmt *pTableInfo = 0;
1676 char *zTableInfo = 0;
1680 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1681 zTableInfo = appendText(zTableInfo, zTable, '"');
1682 zTableInfo = appendText(zTableInfo, ");", 0);
1684 rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
1686 if( rc!=SQLITE_OK || !pTableInfo ){
1690 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1691 /* Always quote the table name, even if it appears to be pure ascii,
1692 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1693 zTmp = appendText(zTmp, zTable, '"');
1695 zSelect = appendText(zSelect, zTmp, '\'');
1698 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1699 rc = sqlite3_step(pTableInfo);
1700 while( rc==SQLITE_ROW ){
1701 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1702 zSelect = appendText(zSelect, "quote(", 0);
1703 zSelect = appendText(zSelect, zText, '"');
1704 rc = sqlite3_step(pTableInfo);
1705 if( rc==SQLITE_ROW ){
1706 zSelect = appendText(zSelect, "), ", 0);
1708 zSelect = appendText(zSelect, ") ", 0);
1712 rc = sqlite3_finalize(pTableInfo);
1713 if( rc!=SQLITE_OK || nRow==0 ){
1717 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1718 zSelect = appendText(zSelect, zTable, '"');
1720 rc = run_table_dump_query(p, zSelect, zPrepStmt);
1721 if( rc==SQLITE_CORRUPT ){
1722 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1723 run_table_dump_query(p, zSelect, 0);
1731 ** Run zQuery. Use dump_callback() as the callback routine so that
1732 ** the contents of the query are output as SQL statements.
1734 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1735 ** "ORDER BY rowid DESC" to the end.
1737 static int run_schema_dump_query(
1743 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1744 if( rc==SQLITE_CORRUPT ){
1746 int len = strlen30(zQuery);
1747 fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1749 fprintf(p->out, "/****** %s ******/\n", zErr);
1753 zQ2 = malloc( len+100 );
1754 if( zQ2==0 ) return rc;
1755 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1756 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1758 fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1760 rc = SQLITE_CORRUPT;
1769 ** Text of a help message
1771 static char zHelp[] =
1772 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1773 ".bail on|off Stop after hitting an error. Default OFF\n"
1774 ".clone NEWDB Clone data into NEWDB from the existing database\n"
1775 ".databases List names and files of attached databases\n"
1776 ".dbinfo ?DB? Show status information about the database\n"
1777 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1778 " If TABLE specified, only dump tables matching\n"
1779 " LIKE pattern TABLE.\n"
1780 ".echo on|off Turn command echo on or off\n"
1781 ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n"
1782 ".exit Exit this program\n"
1783 ".explain ?on|off? Turn output mode suitable for EXPLAIN on or off.\n"
1784 " With no args, it turns EXPLAIN on.\n"
1785 ".fullschema Show schema and the content of sqlite_stat tables\n"
1786 ".headers on|off Turn display of headers on or off\n"
1787 ".help Show this message\n"
1788 ".import FILE TABLE Import data from FILE into TABLE\n"
1789 ".indexes ?TABLE? Show names of all indexes\n"
1790 " If TABLE specified, only show indexes for tables\n"
1791 " matching LIKE pattern TABLE.\n"
1792 #ifdef SQLITE_ENABLE_IOTRACE
1793 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1795 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1796 ".load FILE ?ENTRY? Load an extension library\n"
1798 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1799 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1800 " ascii Columns/rows delimited by 0x1F and 0x1E\n"
1801 " csv Comma-separated values\n"
1802 " column Left-aligned columns. (See .width)\n"
1803 " html HTML <table> code\n"
1804 " insert SQL insert statements for TABLE\n"
1805 " line One value per line\n"
1806 " list Values delimited by .separator strings\n"
1807 " tabs Tab-separated values\n"
1808 " tcl TCL list elements\n"
1809 ".nullvalue STRING Use STRING in place of NULL values\n"
1810 ".once FILENAME Output for the next SQL command only to FILENAME\n"
1811 ".open ?FILENAME? Close existing database and reopen FILENAME\n"
1812 ".output ?FILENAME? Send output to FILENAME or stdout\n"
1813 ".print STRING... Print literal STRING\n"
1814 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1815 ".quit Exit this program\n"
1816 ".read FILENAME Execute SQL in FILENAME\n"
1817 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1818 ".save FILE Write in-memory database into FILE\n"
1819 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
1820 ".schema ?TABLE? Show the CREATE statements\n"
1821 " If TABLE specified, only show tables matching\n"
1822 " LIKE pattern TABLE.\n"
1823 ".separator COL ?ROW? Change the column separator and optionally the row\n"
1824 " separator for both the output mode and .import\n"
1825 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
1826 ".show Show the current values for various settings\n"
1827 ".stats on|off Turn stats on or off\n"
1828 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
1829 ".tables ?TABLE? List names of tables\n"
1830 " If TABLE specified, only list tables matching\n"
1831 " LIKE pattern TABLE.\n"
1832 ".timeout MS Try opening locked tables for MS milliseconds\n"
1833 ".timer on|off Turn SQL timer on or off\n"
1834 ".trace FILE|off Output each SQL statement as it is run\n"
1835 ".vfsname ?AUX? Print the name of the VFS stack\n"
1836 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1837 " Negative values right-justify\n"
1840 /* Forward reference */
1841 static int process_input(ShellState *p, FILE *in);
1843 ** Implementation of the "readfile(X)" SQL function. The entire content
1844 ** of the file named X is read and returned as a BLOB. NULL is returned
1845 ** if the file does not exist or is unreadable.
1847 static void readfileFunc(
1848 sqlite3_context *context,
1850 sqlite3_value **argv
1857 zName = (const char*)sqlite3_value_text(argv[0]);
1858 if( zName==0 ) return;
1859 in = fopen(zName, "rb");
1861 fseek(in, 0, SEEK_END);
1864 pBuf = sqlite3_malloc( nIn );
1865 if( pBuf && 1==fread(pBuf, nIn, 1, in) ){
1866 sqlite3_result_blob(context, pBuf, nIn, sqlite3_free);
1874 ** Implementation of the "writefile(X,Y)" SQL function. The argument Y
1875 ** is written into file X. The number of bytes written is returned. Or
1876 ** NULL is returned if something goes wrong, such as being unable to open
1877 ** file X for writing.
1879 static void writefileFunc(
1880 sqlite3_context *context,
1882 sqlite3_value **argv
1889 zFile = (const char*)sqlite3_value_text(argv[0]);
1890 if( zFile==0 ) return;
1891 out = fopen(zFile, "wb");
1892 if( out==0 ) return;
1893 z = (const char*)sqlite3_value_blob(argv[1]);
1897 rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
1900 sqlite3_result_int64(context, rc);
1904 ** Make sure the database is open. If it is not, then open it. If
1905 ** the database fails to open, print an error message and exit.
1907 static void open_db(ShellState *p, int keepAlive){
1909 sqlite3_initialize();
1910 sqlite3_open(p->zDbFilename, &p->db);
1912 if( db && sqlite3_errcode(db)==SQLITE_OK ){
1913 sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1914 shellstaticFunc, 0, 0);
1916 if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1917 fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1918 p->zDbFilename, sqlite3_errmsg(db));
1919 if( keepAlive ) return;
1922 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1923 sqlite3_enable_load_extension(p->db, 1);
1925 sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
1926 readfileFunc, 0, 0);
1927 sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
1928 writefileFunc, 0, 0);
1933 ** Do C-language style dequoting.
1937 ** \r -> carriage return
1939 ** \NNN -> ascii character NNN in octal
1942 static void resolve_backslashes(char *z){
1945 while( *z && *z!='\\' ) z++;
1946 for(i=j=0; (c = z[i])!=0; i++, j++){
1955 }else if( c=='\\' ){
1957 }else if( c>='0' && c<='7' ){
1959 if( z[i+1]>='0' && z[i+1]<='7' ){
1961 c = (c<<3) + z[i] - '0';
1962 if( z[i+1]>='0' && z[i+1]<='7' ){
1964 c = (c<<3) + z[i] - '0';
1975 ** Return the value of a hexadecimal digit. Return -1 if the input
1976 ** is not a hex digit.
1978 static int hexDigitValue(char c){
1979 if( c>='0' && c<='9' ) return c - '0';
1980 if( c>='a' && c<='f' ) return c - 'a' + 10;
1981 if( c>='A' && c<='F' ) return c - 'A' + 10;
1986 ** Interpret zArg as an integer value, possibly with suffixes.
1988 static sqlite3_int64 integerValue(const char *zArg){
1989 sqlite3_int64 v = 0;
1990 static const struct { char *zSuffix; int iMult; } aMult[] = {
1992 { "MiB", 1024*1024 },
1993 { "GiB", 1024*1024*1024 },
1996 { "GB", 1000000000 },
1999 { "G", 1000000000 },
2006 }else if( zArg[0]=='+' ){
2009 if( zArg[0]=='0' && zArg[1]=='x' ){
2012 while( (x = hexDigitValue(zArg[0]))>=0 ){
2017 while( IsDigit(zArg[0]) ){
2018 v = v*10 + zArg[0] - '0';
2022 for(i=0; i<ArraySize(aMult); i++){
2023 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
2024 v *= aMult[i].iMult;
2028 return isNeg? -v : v;
2032 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2033 ** for TRUE and FALSE. Return the integer value if appropriate.
2035 static int booleanValue(char *zArg){
2037 if( zArg[0]=='0' && zArg[1]=='x' ){
2038 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2040 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
2042 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
2043 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
2046 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
2049 fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2055 ** Close an output file, assuming it is not stderr or stdout
2057 static void output_file_close(FILE *f){
2058 if( f && f!=stdout && f!=stderr ) fclose(f);
2062 ** Try to open an output file. The names "stdout" and "stderr" are
2063 ** recognized and do the right thing. NULL is returned if the output
2064 ** filename is "off".
2066 static FILE *output_file_open(const char *zFile){
2068 if( strcmp(zFile,"stdout")==0 ){
2070 }else if( strcmp(zFile, "stderr")==0 ){
2072 }else if( strcmp(zFile, "off")==0 ){
2075 f = fopen(zFile, "wb");
2077 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2084 ** A routine for handling output from sqlite3_trace().
2086 static void sql_trace_callback(void *pArg, const char *z){
2087 FILE *f = (FILE*)pArg;
2089 int i = (int)strlen(z);
2090 while( i>0 && z[i-1]==';' ){ i--; }
2091 fprintf(f, "%.*s;\n", i, z);
2096 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
2097 ** a useful spot to set a debugger breakpoint.
2099 static void test_breakpoint(void){
2100 static int nCall = 0;
2105 ** An object used to read a CSV and other files for import.
2107 typedef struct ImportCtx ImportCtx;
2109 const char *zFile; /* Name of the input file */
2110 FILE *in; /* Read the CSV text from this input stream */
2111 char *z; /* Accumulated text for a field */
2112 int n; /* Number of bytes in z */
2113 int nAlloc; /* Space allocated for z[] */
2114 int nLine; /* Current line number */
2115 int cTerm; /* Character that terminated the most recent field */
2116 int cColSep; /* The column separator character. (Usually ",") */
2117 int cRowSep; /* The row separator character. (Usually "\n") */
2120 /* Append a single byte to z[] */
2121 static void import_append_char(ImportCtx *p, int c){
2122 if( p->n+1>=p->nAlloc ){
2123 p->nAlloc += p->nAlloc + 100;
2124 p->z = sqlite3_realloc(p->z, p->nAlloc);
2126 fprintf(stderr, "out of memory\n");
2130 p->z[p->n++] = (char)c;
2133 /* Read a single field of CSV text. Compatible with rfc4180 and extended
2134 ** with the option of having a separator other than ",".
2136 ** + Input comes from p->in.
2137 ** + Store results in p->z of length p->n. Space to hold p->z comes
2138 ** from sqlite3_malloc().
2139 ** + Use p->cSep as the column separator. The default is ",".
2140 ** + Use p->rSep as the row separator. The default is "\n".
2141 ** + Keep track of the line number in p->nLine.
2142 ** + Store the character that terminates the field in p->cTerm. Store
2143 ** EOF on end-of-file.
2144 ** + Report syntax errors on stderr
2146 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
2148 int cSep = p->cColSep;
2149 int rSep = p->cRowSep;
2152 if( c==EOF || seenInterrupt ){
2158 int startLine = p->nLine;
2163 if( c==rSep ) p->nLine++;
2170 if( (c==cSep && pc==cQuote)
2171 || (c==rSep && pc==cQuote)
2172 || (c==rSep && pc=='\r' && ppc==cQuote)
2173 || (c==EOF && pc==cQuote)
2175 do{ p->n--; }while( p->z[p->n]!=cQuote );
2179 if( pc==cQuote && c!='\r' ){
2180 fprintf(stderr, "%s:%d: unescaped %c character\n",
2181 p->zFile, p->nLine, cQuote);
2184 fprintf(stderr, "%s:%d: unterminated %c-quoted field\n",
2185 p->zFile, startLine, cQuote);
2189 import_append_char(p, c);
2194 while( c!=EOF && c!=cSep && c!=rSep ){
2195 import_append_char(p, c);
2200 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
2204 if( p->z ) p->z[p->n] = 0;
2208 /* Read a single field of ASCII delimited text.
2210 ** + Input comes from p->in.
2211 ** + Store results in p->z of length p->n. Space to hold p->z comes
2212 ** from sqlite3_malloc().
2213 ** + Use p->cSep as the column separator. The default is "\x1F".
2214 ** + Use p->rSep as the row separator. The default is "\x1E".
2215 ** + Keep track of the row number in p->nLine.
2216 ** + Store the character that terminates the field in p->cTerm. Store
2217 ** EOF on end-of-file.
2218 ** + Report syntax errors on stderr
2220 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
2222 int cSep = p->cColSep;
2223 int rSep = p->cRowSep;
2226 if( c==EOF || seenInterrupt ){
2230 while( c!=EOF && c!=cSep && c!=rSep ){
2231 import_append_char(p, c);
2238 if( p->z ) p->z[p->n] = 0;
2243 ** Try to transfer data for table zTable. If an error is seen while
2244 ** moving forward, try to go backwards. The backwards movement won't
2245 ** work for WITHOUT ROWID tables.
2247 static void tryToCloneData(
2252 sqlite3_stmt *pQuery = 0;
2253 sqlite3_stmt *pInsert = 0;
2258 int nTable = (int)strlen(zTable);
2261 const int spinRate = 10000;
2263 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
2264 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2266 fprintf(stderr, "Error %d: %s on [%s]\n",
2267 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2271 n = sqlite3_column_count(pQuery);
2272 zInsert = sqlite3_malloc(200 + nTable + n*3);
2274 fprintf(stderr, "out of memory\n");
2277 sqlite3_snprintf(200+nTable,zInsert,
2278 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
2279 i = (int)strlen(zInsert);
2281 memcpy(zInsert+i, ",?", 2);
2284 memcpy(zInsert+i, ");", 3);
2285 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
2287 fprintf(stderr, "Error %d: %s on [%s]\n",
2288 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
2293 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2295 switch( sqlite3_column_type(pQuery, i) ){
2297 sqlite3_bind_null(pInsert, i+1);
2300 case SQLITE_INTEGER: {
2301 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
2304 case SQLITE_FLOAT: {
2305 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
2309 sqlite3_bind_text(pInsert, i+1,
2310 (const char*)sqlite3_column_text(pQuery,i),
2315 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
2316 sqlite3_column_bytes(pQuery,i),
2322 rc = sqlite3_step(pInsert);
2323 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
2324 fprintf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
2325 sqlite3_errmsg(newDb));
2327 sqlite3_reset(pInsert);
2329 if( (cnt%spinRate)==0 ){
2330 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
2334 if( rc==SQLITE_DONE ) break;
2335 sqlite3_finalize(pQuery);
2336 sqlite3_free(zQuery);
2337 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
2339 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2341 fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
2344 } /* End for(k=0...) */
2347 sqlite3_finalize(pQuery);
2348 sqlite3_finalize(pInsert);
2349 sqlite3_free(zQuery);
2350 sqlite3_free(zInsert);
2355 ** Try to transfer all rows of the schema that match zWhere. For
2356 ** each row, invoke xForEach() on the object defined by that row.
2357 ** If an error is encountered while moving forward through the
2358 ** sqlite_master table, try again moving backwards.
2360 static void tryToCloneSchema(
2364 void (*xForEach)(ShellState*,sqlite3*,const char*)
2366 sqlite3_stmt *pQuery = 0;
2369 const unsigned char *zName;
2370 const unsigned char *zSql;
2373 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2374 " WHERE %s", zWhere);
2375 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2377 fprintf(stderr, "Error: (%d) %s on [%s]\n",
2378 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2380 goto end_schema_xfer;
2382 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2383 zName = sqlite3_column_text(pQuery, 0);
2384 zSql = sqlite3_column_text(pQuery, 1);
2385 printf("%s... ", zName); fflush(stdout);
2386 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2388 fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2389 sqlite3_free(zErrMsg);
2393 xForEach(p, newDb, (const char*)zName);
2397 if( rc!=SQLITE_DONE ){
2398 sqlite3_finalize(pQuery);
2399 sqlite3_free(zQuery);
2400 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2401 " WHERE %s ORDER BY rowid DESC", zWhere);
2402 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2404 fprintf(stderr, "Error: (%d) %s on [%s]\n",
2405 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2407 goto end_schema_xfer;
2409 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2410 zName = sqlite3_column_text(pQuery, 0);
2411 zSql = sqlite3_column_text(pQuery, 1);
2412 printf("%s... ", zName); fflush(stdout);
2413 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2415 fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2416 sqlite3_free(zErrMsg);
2420 xForEach(p, newDb, (const char*)zName);
2426 sqlite3_finalize(pQuery);
2427 sqlite3_free(zQuery);
2431 ** Open a new database file named "zNewDb". Try to recover as much information
2432 ** as possible out of the main database (which might be corrupt) and write it
2435 static void tryToClone(ShellState *p, const char *zNewDb){
2438 if( access(zNewDb,0)==0 ){
2439 fprintf(stderr, "File \"%s\" already exists.\n", zNewDb);
2442 rc = sqlite3_open(zNewDb, &newDb);
2444 fprintf(stderr, "Cannot create output database: %s\n",
2445 sqlite3_errmsg(newDb));
2447 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
2448 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
2449 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
2450 tryToCloneSchema(p, newDb, "type!='table'", 0);
2451 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
2452 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2454 sqlite3_close(newDb);
2458 ** Change the output file back to stdout
2460 static void output_reset(ShellState *p){
2461 if( p->outfile[0]=='|' ){
2462 #ifndef SQLITE_OMIT_POPEN
2466 output_file_close(p->out);
2473 ** Run an SQL command and return the single integer result.
2475 static int db_int(ShellState *p, const char *zSql){
2476 sqlite3_stmt *pStmt;
2478 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2479 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
2480 res = sqlite3_column_int(pStmt,0);
2482 sqlite3_finalize(pStmt);
2487 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
2489 unsigned int get2byteInt(unsigned char *a){
2490 return (a[0]<<8) + a[1];
2492 unsigned int get4byteInt(unsigned char *a){
2493 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
2497 ** Implementation of the ".info" command.
2499 ** Return 1 on error, 2 to exit, and 0 otherwise.
2501 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
2502 static const struct { const char *zName; int ofst; } aField[] = {
2503 { "file change counter:", 24 },
2504 { "database page count:", 28 },
2505 { "freelist page count:", 36 },
2506 { "schema cookie:", 40 },
2507 { "schema format:", 44 },
2508 { "default cache size:", 48 },
2509 { "autovacuum top root:", 52 },
2510 { "incremental vacuum:", 64 },
2511 { "text encoding:", 56 },
2512 { "user version:", 60 },
2513 { "application id:", 68 },
2514 { "software version:", 96 },
2516 static const struct { const char *zName; const char *zSql; } aQuery[] = {
2517 { "number of tables:",
2518 "SELECT count(*) FROM %s WHERE type='table'" },
2519 { "number of indexes:",
2520 "SELECT count(*) FROM %s WHERE type='index'" },
2521 { "number of triggers:",
2522 "SELECT count(*) FROM %s WHERE type='trigger'" },
2523 { "number of views:",
2524 "SELECT count(*) FROM %s WHERE type='view'" },
2526 "SELECT total(length(sql)) FROM %s" },
2528 sqlite3_file *pFile;
2531 char *zDb = nArg>=2 ? azArg[1] : "main";
2532 unsigned char aHdr[100];
2534 if( p->db==0 ) return 1;
2535 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile);
2536 if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){
2539 i = pFile->pMethods->xRead(pFile, aHdr, 100, 0);
2541 fprintf(stderr, "unable to read database header\n");
2544 i = get2byteInt(aHdr+16);
2545 if( i==1 ) i = 65536;
2546 fprintf(p->out, "%-20s %d\n", "database page size:", i);
2547 fprintf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
2548 fprintf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
2549 fprintf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
2550 for(i=0; i<sizeof(aField)/sizeof(aField[0]); i++){
2551 int ofst = aField[i].ofst;
2552 unsigned int val = get4byteInt(aHdr + ofst);
2553 fprintf(p->out, "%-20s %u", aField[i].zName, val);
2556 if( val==1 ) fprintf(p->out, " (utf8)");
2557 if( val==2 ) fprintf(p->out, " (utf16le)");
2558 if( val==3 ) fprintf(p->out, " (utf16be)");
2561 fprintf(p->out, "\n");
2564 zSchemaTab = sqlite3_mprintf("main.sqlite_master");
2565 }else if( strcmp(zDb,"temp")==0 ){
2566 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
2568 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
2570 for(i=0; i<sizeof(aQuery)/sizeof(aQuery[0]); i++){
2571 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
2572 int val = db_int(p, zSql);
2574 fprintf(p->out, "%-20s %d\n", aQuery[i].zName, val);
2576 sqlite3_free(zSchemaTab);
2582 ** If an input line begins with "." then invoke this routine to
2583 ** process that line.
2585 ** Return 1 on error, 2 to exit, and 0 otherwise.
2587 static int do_meta_command(char *zLine, ShellState *p){
2594 /* Parse the input line into tokens.
2596 while( zLine[i] && nArg<ArraySize(azArg) ){
2597 while( IsSpace(zLine[i]) ){ i++; }
2598 if( zLine[i]==0 ) break;
2599 if( zLine[i]=='\'' || zLine[i]=='"' ){
2600 int delim = zLine[i++];
2601 azArg[nArg++] = &zLine[i];
2602 while( zLine[i] && zLine[i]!=delim ){
2603 if( zLine[i]=='\\' && delim=='"' && zLine[i+1]!=0 ) i++;
2606 if( zLine[i]==delim ){
2609 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
2611 azArg[nArg++] = &zLine[i];
2612 while( zLine[i] && !IsSpace(zLine[i]) ){ i++; }
2613 if( zLine[i] ) zLine[i++] = 0;
2614 resolve_backslashes(azArg[nArg-1]);
2618 /* Process the input line.
2620 if( nArg==0 ) return 0; /* no tokens, no error */
2621 n = strlen30(azArg[0]);
2623 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
2624 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
2626 const char *zDestFile = 0;
2627 const char *zDb = 0;
2629 sqlite3_backup *pBackup;
2631 for(j=1; j<nArg; j++){
2632 const char *z = azArg[j];
2634 while( z[0]=='-' ) z++;
2635 /* No options to process at this time */
2637 fprintf(stderr, "unknown option: %s\n", azArg[j]);
2640 }else if( zDestFile==0 ){
2641 zDestFile = azArg[j];
2644 zDestFile = azArg[j];
2646 fprintf(stderr, "too many arguments to .backup\n");
2651 fprintf(stderr, "missing FILENAME argument on .backup\n");
2654 if( zDb==0 ) zDb = "main";
2655 rc = sqlite3_open(zDestFile, &pDest);
2656 if( rc!=SQLITE_OK ){
2657 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
2658 sqlite3_close(pDest);
2662 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
2664 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2665 sqlite3_close(pDest);
2668 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
2669 sqlite3_backup_finish(pBackup);
2670 if( rc==SQLITE_DONE ){
2673 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2676 sqlite3_close(pDest);
2679 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
2681 bail_on_error = booleanValue(azArg[1]);
2683 fprintf(stderr, "Usage: .bail on|off\n");
2688 /* The undocumented ".breakpoint" command causes a call to the no-op
2689 ** routine named test_breakpoint().
2691 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
2695 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
2697 tryToClone(p, azArg[1]);
2699 fprintf(stderr, "Usage: .clone FILENAME\n");
2704 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
2708 memcpy(&data, p, sizeof(data));
2709 data.showHeader = 1;
2710 data.mode = MODE_Column;
2711 data.colWidth[0] = 3;
2712 data.colWidth[1] = 15;
2713 data.colWidth[2] = 58;
2715 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
2717 fprintf(stderr,"Error: %s\n", zErrMsg);
2718 sqlite3_free(zErrMsg);
2723 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
2724 rc = shell_dbinfo_command(p, nArg, azArg);
2727 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
2729 /* When playing back a "dump", the content might appear in an order
2730 ** which causes immediate foreign key constraints to be violated.
2731 ** So disable foreign-key constraint enforcement to prevent problems. */
2732 if( nArg!=1 && nArg!=2 ){
2733 fprintf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
2735 goto meta_command_exit;
2737 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
2738 fprintf(p->out, "BEGIN TRANSACTION;\n");
2739 p->writableSchema = 0;
2740 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2743 run_schema_dump_query(p,
2744 "SELECT name, type, sql FROM sqlite_master "
2745 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2747 run_schema_dump_query(p,
2748 "SELECT name, type, sql FROM sqlite_master "
2749 "WHERE name=='sqlite_sequence'"
2751 run_table_dump_query(p,
2752 "SELECT sql FROM sqlite_master "
2753 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2757 for(i=1; i<nArg; i++){
2758 zShellStatic = azArg[i];
2759 run_schema_dump_query(p,
2760 "SELECT name, type, sql FROM sqlite_master "
2761 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2762 " AND sql NOT NULL");
2763 run_table_dump_query(p,
2764 "SELECT sql FROM sqlite_master "
2765 "WHERE sql NOT NULL"
2766 " AND type IN ('index','trigger','view')"
2767 " AND tbl_name LIKE shellstatic()", 0
2772 if( p->writableSchema ){
2773 fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
2774 p->writableSchema = 0;
2776 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2777 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
2778 fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
2781 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
2783 p->echoOn = booleanValue(azArg[1]);
2785 fprintf(stderr, "Usage: .echo on|off\n");
2790 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
2792 p->autoEQP = booleanValue(azArg[1]);
2794 fprintf(stderr, "Usage: .eqp on|off\n");
2799 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
2800 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
2804 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
2805 int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
2807 if(!p->normalMode.valid) {
2808 p->normalMode.valid = 1;
2809 p->normalMode.mode = p->mode;
2810 p->normalMode.showHeader = p->showHeader;
2811 memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth));
2813 /* We could put this code under the !p->explainValid
2814 ** condition so that it does not execute if we are already in
2815 ** explain mode. However, always executing it allows us an easy
2816 ** was to reset to explain mode in case the user previously
2817 ** did an .explain followed by a .width, .mode or .header
2820 p->mode = MODE_Explain;
2822 memset(p->colWidth,0,sizeof(p->colWidth));
2823 p->colWidth[0] = 4; /* addr */
2824 p->colWidth[1] = 13; /* opcode */
2825 p->colWidth[2] = 4; /* P1 */
2826 p->colWidth[3] = 4; /* P2 */
2827 p->colWidth[4] = 4; /* P3 */
2828 p->colWidth[5] = 13; /* P4 */
2829 p->colWidth[6] = 2; /* P5 */
2830 p->colWidth[7] = 13; /* Comment */
2831 }else if (p->normalMode.valid) {
2832 p->normalMode.valid = 0;
2833 p->mode = p->normalMode.mode;
2834 p->showHeader = p->normalMode.showHeader;
2835 memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth));
2839 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
2844 fprintf(stderr, "Usage: .fullschema\n");
2846 goto meta_command_exit;
2849 memcpy(&data, p, sizeof(data));
2850 data.showHeader = 0;
2851 data.mode = MODE_Semi;
2852 rc = sqlite3_exec(p->db,
2854 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2855 " FROM sqlite_master UNION ALL"
2856 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2857 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
2859 callback, &data, &zErrMsg
2861 if( rc==SQLITE_OK ){
2862 sqlite3_stmt *pStmt;
2863 rc = sqlite3_prepare_v2(p->db,
2864 "SELECT rowid FROM sqlite_master"
2865 " WHERE name GLOB 'sqlite_stat[134]'",
2867 doStats = sqlite3_step(pStmt)==SQLITE_ROW;
2868 sqlite3_finalize(pStmt);
2871 fprintf(p->out, "/* No STAT tables available */\n");
2873 fprintf(p->out, "ANALYZE sqlite_master;\n");
2874 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
2875 callback, &data, &zErrMsg);
2876 data.mode = MODE_Insert;
2877 data.zDestTable = "sqlite_stat1";
2878 shell_exec(p->db, "SELECT * FROM sqlite_stat1",
2879 shell_callback, &data,&zErrMsg);
2880 data.zDestTable = "sqlite_stat3";
2881 shell_exec(p->db, "SELECT * FROM sqlite_stat3",
2882 shell_callback, &data,&zErrMsg);
2883 data.zDestTable = "sqlite_stat4";
2884 shell_exec(p->db, "SELECT * FROM sqlite_stat4",
2885 shell_callback, &data, &zErrMsg);
2886 fprintf(p->out, "ANALYZE sqlite_master;\n");
2890 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
2892 p->showHeader = booleanValue(azArg[1]);
2894 fprintf(stderr, "Usage: .headers on|off\n");
2899 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
2900 fprintf(p->out, "%s", zHelp);
2903 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
2904 char *zTable; /* Insert data into this table */
2905 char *zFile; /* Name of file to extra content from */
2906 sqlite3_stmt *pStmt = NULL; /* A statement */
2907 int nCol; /* Number of columns in the table */
2908 int nByte; /* Number of bytes in an SQL string */
2909 int i, j; /* Loop counters */
2910 int needCommit; /* True to COMMIT or ROLLBACK at end */
2911 int nSep; /* Number of bytes in p->colSeparator[] */
2912 char *zSql; /* An SQL statement */
2913 ImportCtx sCtx; /* Reader context */
2914 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
2915 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
2918 fprintf(stderr, "Usage: .import FILE TABLE\n");
2919 goto meta_command_exit;
2924 memset(&sCtx, 0, sizeof(sCtx));
2926 nSep = strlen30(p->colSeparator);
2928 fprintf(stderr, "Error: non-null column separator required for import\n");
2932 fprintf(stderr, "Error: multi-character column separators not allowed"
2936 nSep = strlen30(p->rowSeparator);
2938 fprintf(stderr, "Error: non-null row separator required for import\n");
2941 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
2942 /* When importing CSV (only), if the row separator is set to the
2943 ** default output row separator, change it to the default input
2944 ** row separator. This avoids having to maintain different input
2945 ** and output row separators. */
2946 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
2947 nSep = strlen30(p->rowSeparator);
2950 fprintf(stderr, "Error: multi-character row separators not allowed"
2956 if( sCtx.zFile[0]=='|' ){
2957 #ifdef SQLITE_OMIT_POPEN
2958 fprintf(stderr, "Error: pipes are not supported in this OS\n");
2961 sCtx.in = popen(sCtx.zFile+1, "r");
2962 sCtx.zFile = "<pipe>";
2966 sCtx.in = fopen(sCtx.zFile, "rb");
2969 if( p->mode==MODE_Ascii ){
2970 xRead = ascii_read_one_field;
2972 xRead = csv_read_one_field;
2975 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2978 sCtx.cColSep = p->colSeparator[0];
2979 sCtx.cRowSep = p->rowSeparator[0];
2980 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
2982 fprintf(stderr, "Error: out of memory\n");
2986 nByte = strlen30(zSql);
2987 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2988 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
2989 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
2990 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
2992 while( xRead(&sCtx) ){
2993 zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCtx.z);
2995 if( sCtx.cTerm!=sCtx.cColSep ) break;
2998 sqlite3_free(zCreate);
2999 sqlite3_free(sCtx.z);
3001 fprintf(stderr,"%s: empty file\n", sCtx.zFile);
3004 zCreate = sqlite3_mprintf("%z\n)", zCreate);
3005 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
3006 sqlite3_free(zCreate);
3008 fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
3009 sqlite3_errmsg(db));
3010 sqlite3_free(sCtx.z);
3014 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3018 if (pStmt) sqlite3_finalize(pStmt);
3019 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
3023 nCol = sqlite3_column_count(pStmt);
3024 sqlite3_finalize(pStmt);
3026 if( nCol==0 ) return 0; /* no columns, no error */
3027 zSql = sqlite3_malloc( nByte*2 + 20 + nCol*2 );
3029 fprintf(stderr, "Error: out of memory\n");
3033 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
3035 for(i=1; i<nCol; i++){
3041 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3044 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
3045 if (pStmt) sqlite3_finalize(pStmt);
3049 needCommit = sqlite3_get_autocommit(db);
3050 if( needCommit ) sqlite3_exec(db, "BEGIN", 0, 0, 0);
3052 int startLine = sCtx.nLine;
3053 for(i=0; i<nCol; i++){
3054 char *z = xRead(&sCtx);
3056 ** Did we reach end-of-file before finding any columns?
3057 ** If so, stop instead of NULL filling the remaining columns.
3059 if( z==0 && i==0 ) break;
3061 ** Did we reach end-of-file OR end-of-line before finding any
3062 ** columns in ASCII mode? If so, stop instead of NULL filling
3063 ** the remaining columns.
3065 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
3066 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
3067 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
3068 fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3069 "filling the rest with NULL\n",
3070 sCtx.zFile, startLine, nCol, i+1);
3072 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
3075 if( sCtx.cTerm==sCtx.cColSep ){
3079 }while( sCtx.cTerm==sCtx.cColSep );
3080 fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3082 sCtx.zFile, startLine, nCol, i);
3085 sqlite3_step(pStmt);
3086 rc = sqlite3_reset(pStmt);
3087 if( rc!=SQLITE_OK ){
3088 fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, startLine,
3089 sqlite3_errmsg(db));
3092 }while( sCtx.cTerm!=EOF );
3095 sqlite3_free(sCtx.z);
3096 sqlite3_finalize(pStmt);
3097 if( needCommit ) sqlite3_exec(db, "COMMIT", 0, 0, 0);
3100 if( c=='i' && (strncmp(azArg[0], "indices", n)==0
3101 || strncmp(azArg[0], "indexes", n)==0) ){
3105 memcpy(&data, p, sizeof(data));
3106 data.showHeader = 0;
3107 data.mode = MODE_List;
3109 rc = sqlite3_exec(p->db,
3110 "SELECT name FROM sqlite_master "
3111 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
3113 "SELECT name FROM sqlite_temp_master "
3114 "WHERE type='index' "
3116 callback, &data, &zErrMsg
3118 }else if( nArg==2 ){
3119 zShellStatic = azArg[1];
3120 rc = sqlite3_exec(p->db,
3121 "SELECT name FROM sqlite_master "
3122 "WHERE type='index' AND tbl_name LIKE shellstatic() "
3124 "SELECT name FROM sqlite_temp_master "
3125 "WHERE type='index' AND tbl_name LIKE shellstatic() "
3127 callback, &data, &zErrMsg
3131 fprintf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
3133 goto meta_command_exit;
3136 fprintf(stderr,"Error: %s\n", zErrMsg);
3137 sqlite3_free(zErrMsg);
3139 }else if( rc != SQLITE_OK ){
3140 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
3145 #ifdef SQLITE_ENABLE_IOTRACE
3146 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
3147 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
3148 if( iotrace && iotrace!=stdout ) fclose(iotrace);
3152 }else if( strcmp(azArg[1], "-")==0 ){
3153 sqlite3IoTrace = iotracePrintf;
3156 iotrace = fopen(azArg[1], "w");
3158 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
3162 sqlite3IoTrace = iotracePrintf;
3168 #ifndef SQLITE_OMIT_LOAD_EXTENSION
3169 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
3170 const char *zFile, *zProc;
3173 fprintf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
3175 goto meta_command_exit;
3178 zProc = nArg>=3 ? azArg[2] : 0;
3180 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
3181 if( rc!=SQLITE_OK ){
3182 fprintf(stderr, "Error: %s\n", zErrMsg);
3183 sqlite3_free(zErrMsg);
3189 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
3191 fprintf(stderr, "Usage: .log FILENAME\n");
3194 const char *zFile = azArg[1];
3195 output_file_close(p->pLog);
3196 p->pLog = output_file_open(zFile);
3200 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
3201 const char *zMode = nArg>=2 ? azArg[1] : "";
3202 int n2 = (int)strlen(zMode);
3204 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
3205 p->mode = MODE_Line;
3206 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
3207 p->mode = MODE_Column;
3208 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
3209 p->mode = MODE_List;
3210 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
3211 p->mode = MODE_Html;
3212 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
3214 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
3215 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
3217 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
3218 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
3219 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
3220 p->mode = MODE_List;
3221 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
3222 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
3223 p->mode = MODE_Insert;
3224 set_table_name(p, nArg>=3 ? azArg[2] : "table");
3225 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
3226 p->mode = MODE_Ascii;
3227 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
3228 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
3230 fprintf(stderr,"Error: mode should be one of: "
3231 "ascii column csv html insert line list tabs tcl\n");
3236 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
3238 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
3239 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
3241 fprintf(stderr, "Usage: .nullvalue STRING\n");
3246 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
3247 sqlite3 *savedDb = p->db;
3248 const char *zSavedFilename = p->zDbFilename;
3249 char *zNewFilename = 0;
3252 p->zDbFilename = zNewFilename = sqlite3_mprintf("%s", azArg[1]);
3256 sqlite3_close(savedDb);
3257 sqlite3_free(p->zFreeOnClose);
3258 p->zFreeOnClose = zNewFilename;
3260 sqlite3_free(zNewFilename);
3262 p->zDbFilename = zSavedFilename;
3267 && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
3269 const char *zFile = nArg>=2 ? azArg[1] : "stdout";
3271 fprintf(stderr, "Usage: .%s FILE\n", azArg[0]);
3273 goto meta_command_exit;
3275 if( n>1 && strncmp(azArg[0], "once", n)==0 ){
3277 fprintf(stderr, "Usage: .once FILE\n");
3279 goto meta_command_exit;
3286 if( zFile[0]=='|' ){
3287 #ifdef SQLITE_OMIT_POPEN
3288 fprintf(stderr,"Error: pipes are not supported in this OS\n");
3292 p->out = popen(zFile + 1, "w");
3294 fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
3298 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
3302 p->out = output_file_open(zFile);
3304 if( strcmp(zFile,"off")!=0 ){
3305 fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile);
3310 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
3315 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
3317 for(i=1; i<nArg; i++){
3318 if( i>1 ) fprintf(p->out, " ");
3319 fprintf(p->out, "%s", azArg[i]);
3321 fprintf(p->out, "\n");
3324 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
3326 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
3329 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
3333 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
3337 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
3340 fprintf(stderr, "Usage: .read FILE\n");
3342 goto meta_command_exit;
3344 alt = fopen(azArg[1], "rb");
3346 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
3349 rc = process_input(p, alt);
3354 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
3355 const char *zSrcFile;
3358 sqlite3_backup *pBackup;
3362 zSrcFile = azArg[1];
3364 }else if( nArg==3 ){
3365 zSrcFile = azArg[2];
3368 fprintf(stderr, "Usage: .restore ?DB? FILE\n");
3370 goto meta_command_exit;
3372 rc = sqlite3_open(zSrcFile, &pSrc);
3373 if( rc!=SQLITE_OK ){
3374 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
3375 sqlite3_close(pSrc);
3379 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
3381 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3382 sqlite3_close(pSrc);
3385 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
3386 || rc==SQLITE_BUSY ){
3387 if( rc==SQLITE_BUSY ){
3388 if( nTimeout++ >= 3 ) break;
3392 sqlite3_backup_finish(pBackup);
3393 if( rc==SQLITE_DONE ){
3395 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
3396 fprintf(stderr, "Error: source database is busy\n");
3399 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3402 sqlite3_close(pSrc);
3406 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
3408 p->scanstatsOn = booleanValue(azArg[1]);
3409 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
3410 fprintf(stderr, "Warning: .scanstats not available in this build.\n");
3413 fprintf(stderr, "Usage: .scanstats on|off\n");
3418 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
3422 memcpy(&data, p, sizeof(data));
3423 data.showHeader = 0;
3424 data.mode = MODE_Semi;
3427 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
3428 if( strcmp(azArg[1],"sqlite_master")==0 ){
3429 char *new_argv[2], *new_colv[2];
3430 new_argv[0] = "CREATE TABLE sqlite_master (\n"
3434 " rootpage integer,\n"
3438 new_colv[0] = "sql";
3440 callback(&data, 1, new_argv, new_colv);
3442 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
3443 char *new_argv[2], *new_colv[2];
3444 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
3448 " rootpage integer,\n"
3452 new_colv[0] = "sql";
3454 callback(&data, 1, new_argv, new_colv);
3457 zShellStatic = azArg[1];
3458 rc = sqlite3_exec(p->db,
3460 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3461 " FROM sqlite_master UNION ALL"
3462 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3463 "WHERE lower(tbl_name) LIKE shellstatic()"
3464 " AND type!='meta' AND sql NOTNULL "
3466 callback, &data, &zErrMsg);
3469 }else if( nArg==1 ){
3470 rc = sqlite3_exec(p->db,
3472 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3473 " FROM sqlite_master UNION ALL"
3474 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3475 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
3477 callback, &data, &zErrMsg
3480 fprintf(stderr, "Usage: .schema ?LIKE-PATTERN?\n");
3482 goto meta_command_exit;
3485 fprintf(stderr,"Error: %s\n", zErrMsg);
3486 sqlite3_free(zErrMsg);
3488 }else if( rc != SQLITE_OK ){
3489 fprintf(stderr,"Error: querying schema information\n");
3497 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3498 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
3499 extern int sqlite3SelectTrace;
3500 sqlite3SelectTrace = integerValue(azArg[1]);
3506 /* Undocumented commands for internal testing. Subject to change
3507 ** without notice. */
3508 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
3509 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
3511 for(i=1; i<nArg; i++){
3512 v = booleanValue(azArg[i]);
3513 fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
3516 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
3517 int i; sqlite3_int64 v;
3518 for(i=1; i<nArg; i++){
3520 v = integerValue(azArg[i]);
3521 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
3522 fprintf(p->out, "%s", zBuf);
3528 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
3529 if( nArg<2 || nArg>3 ){
3530 fprintf(stderr, "Usage: .separator COL ?ROW?\n");
3534 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
3535 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
3538 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
3539 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
3544 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
3549 fprintf(stderr, "Usage: .system COMMAND\n");
3551 goto meta_command_exit;
3553 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
3554 for(i=2; i<nArg; i++){
3555 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
3560 if( x ) fprintf(stderr, "System command returns %d\n", x);
3563 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
3566 fprintf(stderr, "Usage: .show\n");
3568 goto meta_command_exit;
3570 fprintf(p->out,"%12.12s: %s\n","echo", p->echoOn ? "on" : "off");
3571 fprintf(p->out,"%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off");
3572 fprintf(p->out,"%9.9s: %s\n","explain", p->normalMode.valid ? "on" :"off");
3573 fprintf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off");
3574 fprintf(p->out,"%12.12s: %s\n","mode", modeDescr[p->mode]);
3575 fprintf(p->out,"%12.12s: ", "nullvalue");
3576 output_c_string(p->out, p->nullValue);
3577 fprintf(p->out, "\n");
3578 fprintf(p->out,"%12.12s: %s\n","output",
3579 strlen30(p->outfile) ? p->outfile : "stdout");
3580 fprintf(p->out,"%12.12s: ", "colseparator");
3581 output_c_string(p->out, p->colSeparator);
3582 fprintf(p->out, "\n");
3583 fprintf(p->out,"%12.12s: ", "rowseparator");
3584 output_c_string(p->out, p->rowSeparator);
3585 fprintf(p->out, "\n");
3586 fprintf(p->out,"%12.12s: %s\n","stats", p->statsOn ? "on" : "off");
3587 fprintf(p->out,"%12.12s: ","width");
3588 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
3589 fprintf(p->out,"%d ",p->colWidth[i]);
3591 fprintf(p->out,"\n");
3594 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
3596 p->statsOn = booleanValue(azArg[1]);
3598 fprintf(stderr, "Usage: .stats on|off\n");
3603 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
3604 sqlite3_stmt *pStmt;
3610 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
3612 zSql = sqlite3_mprintf(
3613 "SELECT name FROM sqlite_master"
3614 " WHERE type IN ('table','view')"
3615 " AND name NOT LIKE 'sqlite_%%'"
3616 " AND name LIKE ?1");
3617 while( sqlite3_step(pStmt)==SQLITE_ROW ){
3618 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
3619 if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
3620 if( strcmp(zDbName,"temp")==0 ){
3621 zSql = sqlite3_mprintf(
3623 "SELECT 'temp.' || name FROM sqlite_temp_master"
3624 " WHERE type IN ('table','view')"
3625 " AND name NOT LIKE 'sqlite_%%'"
3626 " AND name LIKE ?1", zSql);
3628 zSql = sqlite3_mprintf(
3630 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
3631 " WHERE type IN ('table','view')"
3632 " AND name NOT LIKE 'sqlite_%%'"
3633 " AND name LIKE ?1", zSql, zDbName, zDbName);
3636 sqlite3_finalize(pStmt);
3637 zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
3638 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3644 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
3646 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
3648 while( sqlite3_step(pStmt)==SQLITE_ROW ){
3651 int n = nAlloc*2 + 10;
3652 azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n);
3654 fprintf(stderr, "Error: out of memory\n");
3660 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
3661 if( azResult[nRow] ) nRow++;
3663 sqlite3_finalize(pStmt);
3665 int len, maxlen = 0;
3667 int nPrintCol, nPrintRow;
3668 for(i=0; i<nRow; i++){
3669 len = strlen30(azResult[i]);
3670 if( len>maxlen ) maxlen = len;
3672 nPrintCol = 80/(maxlen+2);
3673 if( nPrintCol<1 ) nPrintCol = 1;
3674 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
3675 for(i=0; i<nPrintRow; i++){
3676 for(j=i; j<nRow; j+=nPrintRow){
3677 char *zSp = j<nPrintRow ? "" : " ";
3678 fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");
3680 fprintf(p->out, "\n");
3683 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
3684 sqlite3_free(azResult);
3687 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
3688 static const struct {
3689 const char *zCtrlName; /* Name of a test-control option */
3690 int ctrlCode; /* Integer code for that option */
3692 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
3693 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
3694 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
3695 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
3696 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
3697 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
3698 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
3699 { "assert", SQLITE_TESTCTRL_ASSERT },
3700 { "always", SQLITE_TESTCTRL_ALWAYS },
3701 { "reserve", SQLITE_TESTCTRL_RESERVE },
3702 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
3703 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
3704 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
3705 { "byteorder", SQLITE_TESTCTRL_BYTEORDER },
3706 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT },
3707 { "imposter", SQLITE_TESTCTRL_IMPOSTER },
3714 /* convert testctrl text option to value. allow any unique prefix
3715 ** of the option name, or a numerical value. */
3716 n = strlen30(azArg[1]);
3717 for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){
3718 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){
3720 testctrl = aCtrl[i].ctrlCode;
3722 fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
3728 if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
3729 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
3730 fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
3734 /* sqlite3_test_control(int, db, int) */
3735 case SQLITE_TESTCTRL_OPTIMIZATIONS:
3736 case SQLITE_TESTCTRL_RESERVE:
3738 int opt = (int)strtol(azArg[2], 0, 0);
3739 rc = sqlite3_test_control(testctrl, p->db, opt);
3740 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3742 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3747 /* sqlite3_test_control(int) */
3748 case SQLITE_TESTCTRL_PRNG_SAVE:
3749 case SQLITE_TESTCTRL_PRNG_RESTORE:
3750 case SQLITE_TESTCTRL_PRNG_RESET:
3751 case SQLITE_TESTCTRL_BYTEORDER:
3753 rc = sqlite3_test_control(testctrl);
3754 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3756 fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
3760 /* sqlite3_test_control(int, uint) */
3761 case SQLITE_TESTCTRL_PENDING_BYTE:
3763 unsigned int opt = (unsigned int)integerValue(azArg[2]);
3764 rc = sqlite3_test_control(testctrl, opt);
3765 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3767 fprintf(stderr,"Error: testctrl %s takes a single unsigned"
3768 " int option\n", azArg[1]);
3772 /* sqlite3_test_control(int, int) */
3773 case SQLITE_TESTCTRL_ASSERT:
3774 case SQLITE_TESTCTRL_ALWAYS:
3775 case SQLITE_TESTCTRL_NEVER_CORRUPT:
3777 int opt = booleanValue(azArg[2]);
3778 rc = sqlite3_test_control(testctrl, opt);
3779 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3781 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3786 /* sqlite3_test_control(int, char *) */
3787 #ifdef SQLITE_N_KEYWORD
3788 case SQLITE_TESTCTRL_ISKEYWORD:
3790 const char *opt = azArg[2];
3791 rc = sqlite3_test_control(testctrl, opt);
3792 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3794 fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
3800 case SQLITE_TESTCTRL_IMPOSTER:
3802 rc = sqlite3_test_control(testctrl, p->db,
3804 integerValue(azArg[3]),
3805 integerValue(azArg[4]));
3806 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3808 fprintf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
3812 case SQLITE_TESTCTRL_BITVEC_TEST:
3813 case SQLITE_TESTCTRL_FAULT_INSTALL:
3814 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
3815 case SQLITE_TESTCTRL_SCRATCHMALLOC:
3817 fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
3824 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
3826 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
3829 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
3831 enableTimer = booleanValue(azArg[1]);
3832 if( enableTimer && !HAS_TIMER ){
3833 fprintf(stderr, "Error: timer not available on this system.\n");
3837 fprintf(stderr, "Usage: .timer on|off\n");
3842 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
3845 fprintf(stderr, "Usage: .trace FILE|off\n");
3847 goto meta_command_exit;
3849 output_file_close(p->traceOut);
3850 p->traceOut = output_file_open(azArg[1]);
3851 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
3852 if( p->traceOut==0 ){
3853 sqlite3_trace(p->db, 0, 0);
3855 sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
3860 #if SQLITE_USER_AUTHENTICATION
3861 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
3863 fprintf(stderr, "Usage: .user SUBCOMMAND ...\n");
3865 goto meta_command_exit;
3868 if( strcmp(azArg[1],"login")==0 ){
3870 fprintf(stderr, "Usage: .user login USER PASSWORD\n");
3872 goto meta_command_exit;
3874 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
3875 (int)strlen(azArg[3]));
3877 fprintf(stderr, "Authentication failed for user %s\n", azArg[2]);
3880 }else if( strcmp(azArg[1],"add")==0 ){
3882 fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
3884 goto meta_command_exit;
3886 rc = sqlite3_user_add(p->db, azArg[2],
3887 azArg[3], (int)strlen(azArg[3]),
3888 booleanValue(azArg[4]));
3890 fprintf(stderr, "User-Add failed: %d\n", rc);
3893 }else if( strcmp(azArg[1],"edit")==0 ){
3895 fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
3897 goto meta_command_exit;
3899 rc = sqlite3_user_change(p->db, azArg[2],
3900 azArg[3], (int)strlen(azArg[3]),
3901 booleanValue(azArg[4]));
3903 fprintf(stderr, "User-Edit failed: %d\n", rc);
3906 }else if( strcmp(azArg[1],"delete")==0 ){
3908 fprintf(stderr, "Usage: .user delete USER\n");
3910 goto meta_command_exit;
3912 rc = sqlite3_user_delete(p->db, azArg[2]);
3914 fprintf(stderr, "User-Delete failed: %d\n", rc);
3918 fprintf(stderr, "Usage: .user login|add|edit|delete ...\n");
3920 goto meta_command_exit;
3923 #endif /* SQLITE_USER_AUTHENTICATION */
3925 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
3926 fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
3927 sqlite3_libversion(), sqlite3_sourceid());
3930 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
3931 const char *zDbName = nArg==2 ? azArg[1] : "main";
3934 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
3936 fprintf(p->out, "%s\n", zVfsName);
3937 sqlite3_free(zVfsName);
3942 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
3943 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
3944 extern int sqlite3WhereTrace;
3945 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
3949 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
3951 assert( nArg<=ArraySize(azArg) );
3952 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
3953 p->colWidth[j-1] = (int)integerValue(azArg[j]);
3958 fprintf(stderr, "Error: unknown command or invalid arguments: "
3959 " \"%s\". Enter \".help\" for help\n", azArg[0]);
3966 if( p->outCount==0 ) output_reset(p);
3972 ** Return TRUE if a semicolon occurs anywhere in the first N characters
3975 static int line_contains_semicolon(const char *z, int N){
3977 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
3982 ** Test to see if a line consists entirely of whitespace.
3984 static int _all_whitespace(const char *z){
3986 if( IsSpace(z[0]) ) continue;
3987 if( *z=='/' && z[1]=='*' ){
3989 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
3990 if( *z==0 ) return 0;
3994 if( *z=='-' && z[1]=='-' ){
3996 while( *z && *z!='\n' ){ z++; }
3997 if( *z==0 ) return 1;
4006 ** Return TRUE if the line typed in is an SQL command terminator other
4007 ** than a semi-colon. The SQL Server style "go" command is understood
4008 ** as is the Oracle "/".
4010 static int line_is_command_terminator(const char *zLine){
4011 while( IsSpace(zLine[0]) ){ zLine++; };
4012 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
4013 return 1; /* Oracle */
4015 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
4016 && _all_whitespace(&zLine[2]) ){
4017 return 1; /* SQL Server */
4023 ** Return true if zSql is a complete SQL statement. Return false if it
4024 ** ends in the middle of a string literal or C-style comment.
4026 static int line_is_complete(char *zSql, int nSql){
4028 if( zSql==0 ) return 1;
4031 rc = sqlite3_complete(zSql);
4037 ** Read input from *in and process it. If *in==0 then input
4038 ** is interactive - the user is typing it it. Otherwise, input
4039 ** is coming from a file or device. A prompt is issued and history
4040 ** is saved only if input is interactive. An interrupt signal will
4041 ** cause this routine to exit immediately, unless input is interactive.
4043 ** Return the number of errors.
4045 static int process_input(ShellState *p, FILE *in){
4046 char *zLine = 0; /* A single input line */
4047 char *zSql = 0; /* Accumulated SQL text */
4048 int nLine; /* Length of current line */
4049 int nSql = 0; /* Bytes of zSql[] used */
4050 int nAlloc = 0; /* Allocated zSql[] space */
4051 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
4052 char *zErrMsg; /* Error message returned */
4053 int rc; /* Error code */
4054 int errCnt = 0; /* Number of errors seen */
4055 int lineno = 0; /* Current line number */
4056 int startline = 0; /* Line number for start of current input */
4058 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
4060 zLine = one_input_line(in, zLine, nSql>0);
4063 if( stdin_is_interactive ) printf("\n");
4066 if( seenInterrupt ){
4071 if( nSql==0 && _all_whitespace(zLine) ){
4072 if( p->echoOn ) printf("%s\n", zLine);
4075 if( zLine && zLine[0]=='.' && nSql==0 ){
4076 if( p->echoOn ) printf("%s\n", zLine);
4077 rc = do_meta_command(zLine, p);
4078 if( rc==2 ){ /* exit requested */
4085 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
4086 memcpy(zLine,";",2);
4088 nLine = strlen30(zLine);
4089 if( nSql+nLine+2>=nAlloc ){
4090 nAlloc = nSql+nLine+100;
4091 zSql = realloc(zSql, nAlloc);
4093 fprintf(stderr, "Error: out of memory\n");
4100 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
4101 assert( nAlloc>0 && zSql!=0 );
4102 memcpy(zSql, zLine+i, nLine+1-i);
4106 zSql[nSql++] = '\n';
4107 memcpy(zSql+nSql, zLine, nLine+1);
4110 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
4111 && sqlite3_complete(zSql) ){
4115 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
4117 if( rc || zErrMsg ){
4119 if( in!=0 || !stdin_is_interactive ){
4120 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
4121 "Error: near line %d:", startline);
4123 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
4126 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
4127 sqlite3_free(zErrMsg);
4130 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
4139 }else if( nSql && _all_whitespace(zSql) ){
4140 if( p->echoOn ) printf("%s\n", zSql);
4145 if( !_all_whitespace(zSql) ){
4146 fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
4156 ** Return a pathname which is the user's home directory. A
4157 ** 0 return indicates an error of some kind.
4159 static char *find_home_dir(void){
4160 static char *home_dir = NULL;
4161 if( home_dir ) return home_dir;
4163 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
4164 && !defined(__RTP__) && !defined(_WRS_KERNEL)
4166 struct passwd *pwent;
4167 uid_t uid = getuid();
4168 if( (pwent=getpwuid(uid)) != NULL) {
4169 home_dir = pwent->pw_dir;
4174 #if defined(_WIN32_WCE)
4175 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
4180 #if defined(_WIN32) || defined(WIN32)
4182 home_dir = getenv("USERPROFILE");
4187 home_dir = getenv("HOME");
4190 #if defined(_WIN32) || defined(WIN32)
4192 char *zDrive, *zPath;
4194 zDrive = getenv("HOMEDRIVE");
4195 zPath = getenv("HOMEPATH");
4196 if( zDrive && zPath ){
4197 n = strlen30(zDrive) + strlen30(zPath) + 1;
4198 home_dir = malloc( n );
4199 if( home_dir==0 ) return 0;
4200 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
4207 #endif /* !_WIN32_WCE */
4210 int n = strlen30(home_dir) + 1;
4211 char *z = malloc( n );
4212 if( z ) memcpy(z, home_dir, n);
4220 ** Read input from the file given by sqliterc_override. Or if that
4221 ** parameter is NULL, take input from ~/.sqliterc
4223 ** Returns the number of errors.
4225 static void process_sqliterc(
4226 ShellState *p, /* Configuration data */
4227 const char *sqliterc_override /* Name of config file. NULL to use default */
4229 char *home_dir = NULL;
4230 const char *sqliterc = sqliterc_override;
4234 if (sqliterc == NULL) {
4235 home_dir = find_home_dir();
4237 fprintf(stderr, "-- warning: cannot find home directory;"
4238 " cannot read ~/.sqliterc\n");
4241 sqlite3_initialize();
4242 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
4245 in = fopen(sqliterc,"rb");
4247 if( stdin_is_interactive ){
4248 fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
4250 process_input(p,in);
4257 ** Show available command line options
4259 static const char zOptions[] =
4260 " -ascii set output mode to 'ascii'\n"
4261 " -bail stop after hitting an error\n"
4262 " -batch force batch I/O\n"
4263 " -column set output mode to 'column'\n"
4264 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
4265 " -csv set output mode to 'csv'\n"
4266 " -echo print commands before execution\n"
4267 " -init FILENAME read/process named file\n"
4268 " -[no]header turn headers on or off\n"
4269 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4270 " -heap SIZE Size of heap for memsys3 or memsys5\n"
4272 " -help show this message\n"
4273 " -html set output mode to HTML\n"
4274 " -interactive force interactive I/O\n"
4275 " -line set output mode to 'line'\n"
4276 " -list set output mode to 'list'\n"
4277 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
4278 " -mmap N default mmap size set to N\n"
4279 #ifdef SQLITE_ENABLE_MULTIPLEX
4280 " -multiplex enable the multiplexor VFS\n"
4282 " -newline SEP set output row separator. Default: '\\n'\n"
4283 " -nullvalue TEXT set text string for NULL values. Default ''\n"
4284 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
4285 " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n"
4286 " -separator SEP set output column separator. Default: '|'\n"
4287 " -stats print memory stats before each finalize\n"
4288 " -version show SQLite version\n"
4289 " -vfs NAME use NAME as the default VFS\n"
4290 #ifdef SQLITE_ENABLE_VFSTRACE
4291 " -vfstrace enable tracing of all VFS calls\n"
4294 static void usage(int showDetail){
4296 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
4297 "FILENAME is the name of an SQLite database. A new database is created\n"
4298 "if the file does not previously exist.\n", Argv0);
4300 fprintf(stderr, "OPTIONS include:\n%s", zOptions);
4302 fprintf(stderr, "Use the -help option for additional information\n");
4308 ** Initialize the state information in data
4310 static void main_init(ShellState *data) {
4311 memset(data, 0, sizeof(*data));
4312 data->mode = MODE_List;
4313 memcpy(data->colSeparator,SEP_Column, 2);
4314 memcpy(data->rowSeparator,SEP_Row, 2);
4315 data->showHeader = 0;
4316 data->shellFlgs = SHFLG_Lookaside;
4317 sqlite3_config(SQLITE_CONFIG_URI, 1);
4318 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
4319 sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
4320 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
4321 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
4325 ** Output text to the console in a font that attracts extra attention.
4328 static void printBold(const char *zText){
4329 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
4330 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
4331 GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
4332 SetConsoleTextAttribute(out,
4333 FOREGROUND_RED|FOREGROUND_INTENSITY
4335 printf("%s", zText);
4336 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
4339 static void printBold(const char *zText){
4340 printf("\033[1m%s\033[0m", zText);
4345 ** Get the argument to an --option. Throw an error and die if no argument
4348 static char *cmdline_option_value(int argc, char **argv, int i){
4350 fprintf(stderr, "%s: Error: missing argument to %s\n",
4351 argv[0], argv[argc-1]);
4357 int SQLITE_CDECL main(int argc, char **argv){
4360 const char *zInitFile = 0;
4363 int warnInmemoryDb = 0;
4368 #if USE_SYSTEM_SQLITE+0!=1
4369 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
4370 fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
4371 sqlite3_sourceid(), SQLITE_SOURCE_ID);
4375 setBinaryMode(stdin);
4376 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
4379 stdin_is_interactive = isatty(0);
4381 /* Make sure we have a valid signal handler early, before anything
4385 signal(SIGINT, interrupt_handler);
4388 #ifdef SQLITE_SHELL_DBNAME_PROC
4390 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
4391 ** of a C-function that will provide the name of the database file. Use
4392 ** this compile-time option to embed this shell program in larger
4394 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
4395 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
4400 /* Do an initial pass through the command-line argument to locate
4401 ** the name of the database file, the name of the initialization file,
4402 ** the size of the alternative malloc heap,
4403 ** and the first command to execute.
4405 for(i=1; i<argc; i++){
4409 if( data.zDbFilename==0 ){
4410 data.zDbFilename = z;
4412 /* Excesss arguments are interpreted as SQL (or dot-commands) and
4413 ** mean that nothing is read from stdin */
4416 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
4418 fprintf(stderr, "out of memory\n");
4424 if( z[1]=='-' ) z++;
4425 if( strcmp(z,"-separator")==0
4426 || strcmp(z,"-nullvalue")==0
4427 || strcmp(z,"-newline")==0
4428 || strcmp(z,"-cmd")==0
4430 (void)cmdline_option_value(argc, argv, ++i);
4431 }else if( strcmp(z,"-init")==0 ){
4432 zInitFile = cmdline_option_value(argc, argv, ++i);
4433 }else if( strcmp(z,"-batch")==0 ){
4434 /* Need to check for batch mode here to so we can avoid printing
4435 ** informational messages (like from process_sqliterc) before
4436 ** we do the actual processing of arguments later in a second pass.
4438 stdin_is_interactive = 0;
4439 }else if( strcmp(z,"-heap")==0 ){
4440 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4442 sqlite3_int64 szHeap;
4444 zSize = cmdline_option_value(argc, argv, ++i);
4445 szHeap = integerValue(zSize);
4446 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
4447 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
4449 }else if( strcmp(z,"-scratch")==0 ){
4451 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4452 if( sz>400000 ) sz = 400000;
4453 if( sz<2500 ) sz = 2500;
4454 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4457 sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n);
4458 data.shellFlgs |= SHFLG_Scratch;
4459 }else if( strcmp(z,"-pagecache")==0 ){
4461 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4462 if( sz>70000 ) sz = 70000;
4463 if( sz<800 ) sz = 800;
4464 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4466 sqlite3_config(SQLITE_CONFIG_PAGECACHE, malloc(n*sz+1), sz, n);
4467 data.shellFlgs |= SHFLG_Pagecache;
4468 }else if( strcmp(z,"-lookaside")==0 ){
4470 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4472 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4474 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
4475 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
4476 #ifdef SQLITE_ENABLE_VFSTRACE
4477 }else if( strcmp(z,"-vfstrace")==0 ){
4478 extern int vfstrace_register(
4479 const char *zTraceName,
4480 const char *zOldVfsName,
4481 int (*xOut)(const char*,void*),
4485 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
4487 #ifdef SQLITE_ENABLE_MULTIPLEX
4488 }else if( strcmp(z,"-multiplex")==0 ){
4489 extern int sqlite3_multiple_initialize(const char*,int);
4490 sqlite3_multiplex_initialize(0, 1);
4492 }else if( strcmp(z,"-mmap")==0 ){
4493 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
4494 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
4495 }else if( strcmp(z,"-vfs")==0 ){
4496 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
4498 sqlite3_vfs_register(pVfs, 1);
4500 fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
4505 if( data.zDbFilename==0 ){
4506 #ifndef SQLITE_OMIT_MEMORYDB
4507 data.zDbFilename = ":memory:";
4508 warnInmemoryDb = argc==1;
4510 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
4516 /* Go ahead and open the database file if it already exists. If the
4517 ** file does not exist, delay opening it. This prevents empty database
4518 ** files from being created if a user mistypes the database name argument
4519 ** to the sqlite command-line tool.
4521 if( access(data.zDbFilename, 0)==0 ){
4525 /* Process the initialization file if there is one. If no -init option
4526 ** is given on the command line, look for a file named ~/.sqliterc and
4527 ** try to process it.
4529 process_sqliterc(&data,zInitFile);
4531 /* Make a second pass through the command-line argument and set
4532 ** options. This second pass is delayed until after the initialization
4533 ** file is processed so that the command-line arguments will override
4534 ** settings in the initialization file.
4536 for(i=1; i<argc; i++){
4538 if( z[0]!='-' ) continue;
4539 if( z[1]=='-' ){ z++; }
4540 if( strcmp(z,"-init")==0 ){
4542 }else if( strcmp(z,"-html")==0 ){
4543 data.mode = MODE_Html;
4544 }else if( strcmp(z,"-list")==0 ){
4545 data.mode = MODE_List;
4546 }else if( strcmp(z,"-line")==0 ){
4547 data.mode = MODE_Line;
4548 }else if( strcmp(z,"-column")==0 ){
4549 data.mode = MODE_Column;
4550 }else if( strcmp(z,"-csv")==0 ){
4551 data.mode = MODE_Csv;
4552 memcpy(data.colSeparator,",",2);
4553 }else if( strcmp(z,"-ascii")==0 ){
4554 data.mode = MODE_Ascii;
4555 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
4557 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
4559 }else if( strcmp(z,"-separator")==0 ){
4560 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
4561 "%s",cmdline_option_value(argc,argv,++i));
4562 }else if( strcmp(z,"-newline")==0 ){
4563 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
4564 "%s",cmdline_option_value(argc,argv,++i));
4565 }else if( strcmp(z,"-nullvalue")==0 ){
4566 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
4567 "%s",cmdline_option_value(argc,argv,++i));
4568 }else if( strcmp(z,"-header")==0 ){
4569 data.showHeader = 1;
4570 }else if( strcmp(z,"-noheader")==0 ){
4571 data.showHeader = 0;
4572 }else if( strcmp(z,"-echo")==0 ){
4574 }else if( strcmp(z,"-eqp")==0 ){
4576 }else if( strcmp(z,"-stats")==0 ){
4578 }else if( strcmp(z,"-scanstats")==0 ){
4579 data.scanstatsOn = 1;
4580 }else if( strcmp(z,"-bail")==0 ){
4582 }else if( strcmp(z,"-version")==0 ){
4583 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
4585 }else if( strcmp(z,"-interactive")==0 ){
4586 stdin_is_interactive = 1;
4587 }else if( strcmp(z,"-batch")==0 ){
4588 stdin_is_interactive = 0;
4589 }else if( strcmp(z,"-heap")==0 ){
4591 }else if( strcmp(z,"-scratch")==0 ){
4593 }else if( strcmp(z,"-pagecache")==0 ){
4595 }else if( strcmp(z,"-lookaside")==0 ){
4597 }else if( strcmp(z,"-mmap")==0 ){
4599 }else if( strcmp(z,"-vfs")==0 ){
4601 #ifdef SQLITE_ENABLE_VFSTRACE
4602 }else if( strcmp(z,"-vfstrace")==0 ){
4605 #ifdef SQLITE_ENABLE_MULTIPLEX
4606 }else if( strcmp(z,"-multiplex")==0 ){
4609 }else if( strcmp(z,"-help")==0 ){
4611 }else if( strcmp(z,"-cmd")==0 ){
4612 /* Run commands that follow -cmd first and separately from commands
4613 ** that simply appear on the command-line. This seems goofy. It would
4614 ** be better if all commands ran in the order that they appear. But
4615 ** we retain the goofy behavior for historical compatibility. */
4616 if( i==argc-1 ) break;
4617 z = cmdline_option_value(argc,argv,++i);
4619 rc = do_meta_command(z, &data);
4620 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
4623 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
4625 fprintf(stderr,"Error: %s\n", zErrMsg);
4626 if( bail_on_error ) return rc!=0 ? rc : 1;
4628 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
4629 if( bail_on_error ) return rc;
4633 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
4634 fprintf(stderr,"Use -help for a list of options.\n");
4640 /* Run all arguments that do not begin with '-' as if they were separate
4641 ** command-line inputs, except for the argToSkip argument which contains
4642 ** the database filename.
4644 for(i=0; i<nCmd; i++){
4645 if( azCmd[i][0]=='.' ){
4646 rc = do_meta_command(azCmd[i], &data);
4647 if( rc ) return rc==2 ? 0 : rc;
4650 rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
4652 fprintf(stderr,"Error: %s\n", zErrMsg);
4653 return rc!=0 ? rc : 1;
4655 fprintf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
4662 /* Run commands received from standard input
4664 if( stdin_is_interactive ){
4669 "SQLite version %s %.19s\n" /*extra-version-info*/
4670 "Enter \".help\" for usage hints.\n",
4671 sqlite3_libversion(), sqlite3_sourceid()
4673 if( warnInmemoryDb ){
4674 printf("Connected to a ");
4675 printBold("transient in-memory database");
4676 printf(".\nUse \".open FILENAME\" to reopen on a "
4677 "persistent database.\n");
4679 zHome = find_home_dir();
4681 nHistory = strlen30(zHome) + 20;
4682 if( (zHistory = malloc(nHistory))!=0 ){
4683 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
4686 if( zHistory ) shell_read_history(zHistory);
4687 rc = process_input(&data, 0);
4689 shell_stifle_history(100);
4690 shell_write_history(zHistory);
4694 rc = process_input(&data, stdin);
4697 set_table_name(&data, 0);
4699 sqlite3_close(data.db);
4701 sqlite3_free(data.zFreeOnClose);