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 ** Enable large-file support for fopen() and friends on unix.
23 #ifndef SQLITE_DISABLE_LFS
24 # define _LARGE_FILE 1
25 # ifndef _FILE_OFFSET_BITS
26 # define _FILE_OFFSET_BITS 64
28 # define _LARGEFILE_SOURCE 1
39 #if !defined(_WIN32) && !defined(WIN32)
41 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
45 # include <sys/types.h>
49 # include <editline/editline.h>
51 #if defined(HAVE_READLINE) && HAVE_READLINE==1
52 # include <readline/readline.h>
53 # include <readline/history.h>
55 #if !defined(HAVE_EDITLINE) && (!defined(HAVE_READLINE) || HAVE_READLINE!=1)
56 # define add_history(X)
57 # define read_history(X)
58 # define write_history(X)
59 # define stifle_history(X)
62 #if defined(_WIN32) || defined(WIN32)
64 #define isatty(h) _isatty(h)
65 #define access(f,m) _access((f),(m))
69 #define pclose _pclose
71 /* Make sure isatty() has a prototype.
73 extern int isatty(int);
75 /* popen and pclose are not C89 functions and so are sometimes omitted from
76 ** the <stdio.h> header */
77 extern FILE *popen(const char*,const char*);
78 extern int pclose(FILE*);
81 #if defined(_WIN32_WCE)
82 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
83 * thus we always assume that we have a console. That can be
84 * overridden with the -batch command line option.
89 /* ctype macros that work with signed characters */
90 #define IsSpace(X) isspace((unsigned char)X)
91 #define IsDigit(X) isdigit((unsigned char)X)
92 #define ToLower(X) (char)tolower((unsigned char)X)
95 /* True if the timer is enabled */
96 static int enableTimer = 0;
98 /* Return the current wall-clock time */
99 static sqlite3_int64 timeOfDay(void){
100 static sqlite3_vfs *clockVfs = 0;
102 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
103 if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
104 clockVfs->xCurrentTimeInt64(clockVfs, &t);
107 clockVfs->xCurrentTime(clockVfs, &r);
108 t = (sqlite3_int64)(r*86400000.0);
113 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL) \
115 #include <sys/time.h>
116 #include <sys/resource.h>
118 /* Saved resource information for the beginning of an operation */
119 static struct rusage sBegin; /* CPU time at start */
120 static sqlite3_int64 iBegin; /* Wall-clock time at start */
123 ** Begin timing an operation
125 static void beginTimer(void){
127 getrusage(RUSAGE_SELF, &sBegin);
128 iBegin = timeOfDay();
132 /* Return the difference of two time_structs in seconds */
133 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
134 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
135 (double)(pEnd->tv_sec - pStart->tv_sec);
139 ** Print the timing results.
141 static void endTimer(void){
144 sqlite3_int64 iEnd = timeOfDay();
145 getrusage(RUSAGE_SELF, &sEnd);
146 printf("Run Time: real %.3f user %f sys %f\n",
147 (iEnd - iBegin)*0.001,
148 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
149 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
153 #define BEGIN_TIMER beginTimer()
154 #define END_TIMER endTimer()
157 #elif (defined(_WIN32) || defined(WIN32))
161 /* Saved resource information for the beginning of an operation */
162 static HANDLE hProcess;
163 static FILETIME ftKernelBegin;
164 static FILETIME ftUserBegin;
165 static sqlite3_int64 ftWallBegin;
166 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
167 static GETPROCTIMES getProcessTimesAddr = NULL;
170 ** Check to see if we have timer support. Return 1 if necessary
171 ** support found (or found previously).
173 static int hasTimer(void){
174 if( getProcessTimesAddr ){
177 /* GetProcessTimes() isn't supported in WIN95 and some other Windows versions.
178 ** See if the version we are running on has it, and if it does, save off
179 ** a pointer to it and the current process handle.
181 hProcess = GetCurrentProcess();
183 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
184 if( NULL != hinstLib ){
185 getProcessTimesAddr = (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
186 if( NULL != getProcessTimesAddr ){
189 FreeLibrary(hinstLib);
197 ** Begin timing an operation
199 static void beginTimer(void){
200 if( enableTimer && getProcessTimesAddr ){
201 FILETIME ftCreation, ftExit;
202 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin);
203 ftWallBegin = timeOfDay();
207 /* Return the difference of two FILETIME structs in seconds */
208 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
209 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
210 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
211 return (double) ((i64End - i64Start) / 10000000.0);
215 ** Print the timing results.
217 static void endTimer(void){
218 if( enableTimer && getProcessTimesAddr){
219 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
220 sqlite3_int64 ftWallEnd = timeOfDay();
221 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd);
222 printf("Run Time: real %.3f user %f sys %f\n",
223 (ftWallEnd - ftWallBegin)*0.001,
224 timeDiff(&ftUserBegin, &ftUserEnd),
225 timeDiff(&ftKernelBegin, &ftKernelEnd));
229 #define BEGIN_TIMER beginTimer()
230 #define END_TIMER endTimer()
231 #define HAS_TIMER hasTimer()
240 ** Used to prevent warnings about unused parameters
242 #define UNUSED_PARAMETER(x) (void)(x)
245 ** If the following flag is set, then command execution stops
246 ** at an error if we are not interactive.
248 static int bail_on_error = 0;
251 ** Threat stdin as an interactive input if the following variable
252 ** is true. Otherwise, assume stdin is connected to a file or pipe.
254 static int stdin_is_interactive = 1;
257 ** The following is the open SQLite database. We make a pointer
258 ** to this database a static variable so that it can be accessed
259 ** by the SIGINT handler to interrupt database processing.
261 static sqlite3 *db = 0;
264 ** True if an interrupt (Control-C) has been received.
266 static volatile int seenInterrupt = 0;
269 ** This is the name of our program. It is set in main(), used
270 ** in a number of other places, mostly for error messages.
275 ** Prompt strings. Initialized in main. Settable with
276 ** .prompt main continue
278 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
279 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
282 ** Write I/O traces to the following stream.
284 #ifdef SQLITE_ENABLE_IOTRACE
285 static FILE *iotrace = 0;
289 ** This routine works like printf in that its first argument is a
290 ** format string and subsequent arguments are values to be substituted
291 ** in place of % fields. The result of formatting this string
292 ** is written to iotrace.
294 #ifdef SQLITE_ENABLE_IOTRACE
295 static void iotracePrintf(const char *zFormat, ...){
298 if( iotrace==0 ) return;
299 va_start(ap, zFormat);
300 z = sqlite3_vmprintf(zFormat, ap);
302 fprintf(iotrace, "%s", z);
309 ** Determines if a string is a number of not.
311 static int isNumber(const char *z, int *realnum){
312 if( *z=='-' || *z=='+' ) z++;
317 if( realnum ) *realnum = 0;
318 while( IsDigit(*z) ){ z++; }
321 if( !IsDigit(*z) ) return 0;
322 while( IsDigit(*z) ){ z++; }
323 if( realnum ) *realnum = 1;
325 if( *z=='e' || *z=='E' ){
327 if( *z=='+' || *z=='-' ) z++;
328 if( !IsDigit(*z) ) return 0;
329 while( IsDigit(*z) ){ z++; }
330 if( realnum ) *realnum = 1;
336 ** A global char* and an SQL function to access its current value
337 ** from within an SQL statement. This program used to use the
338 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
339 ** The correct way to do this with sqlite3 is to use the bind API, but
340 ** since the shell is built around the callback paradigm it would be a lot
341 ** of work. Instead just use this hack, which is quite harmless.
343 static const char *zShellStatic = 0;
344 static void shellstaticFunc(
345 sqlite3_context *context,
350 assert( zShellStatic );
351 UNUSED_PARAMETER(argc);
352 UNUSED_PARAMETER(argv);
353 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
358 ** This routine reads a line of text from FILE in, stores
359 ** the text in memory obtained from malloc() and returns a pointer
360 ** to the text. NULL is returned at end of file, or if malloc()
363 ** If zLine is not NULL then it is a malloced buffer returned from
364 ** a previous call to this routine that may be reused.
366 static char *local_getline(char *zLine, FILE *in){
367 int nLine = zLine==0 ? 0 : 100;
372 nLine = nLine*2 + 100;
373 zLine = realloc(zLine, nLine);
374 if( zLine==0 ) return 0;
376 if( fgets(&zLine[n], nLine - n, in)==0 ){
384 while( zLine[n] ) n++;
385 if( n>0 && zLine[n-1]=='\n' ){
387 if( n>0 && zLine[n-1]=='\r' ) n--;
396 ** Retrieve a single line of input text.
398 ** If in==0 then read from standard input and prompt before each line.
399 ** If isContinuation is true, then a continuation prompt is appropriate.
400 ** If isContinuation is zero, then the main prompt should be used.
402 ** If zPrior is not NULL then it is a buffer from a prior call to this
403 ** routine that can be reused.
405 ** The result is stored in space obtained from malloc() and must either
406 ** be freed by the caller or else passed back into this routine via the
407 ** zPrior argument for reuse.
409 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
413 zResult = local_getline(zPrior, in);
415 zPrompt = isContinuation ? continuePrompt : mainPrompt;
416 #if defined(HAVE_READLINE) && HAVE_READLINE==1
418 zResult = readline(zPrompt);
419 if( zResult && *zResult ) add_history(zResult);
421 printf("%s", zPrompt);
423 zResult = local_getline(zPrior, stdin);
429 struct previous_mode_data {
430 int valid; /* Is there legit data in here? */
437 ** An pointer to an instance of this structure is passed from
438 ** the main program to the callback. This is used to communicate
439 ** state and mode information.
441 struct callback_data {
442 sqlite3 *db; /* The database */
443 int echoOn; /* True to echo input commands */
444 int statsOn; /* True to display memory stats before each finalize */
445 int cnt; /* Number of records displayed so far */
446 FILE *out; /* Write results here */
447 FILE *traceOut; /* Output for sqlite3_trace() */
448 int nErr; /* Number of errors seen */
449 int mode; /* An output mode setting */
450 int writableSchema; /* True if PRAGMA writable_schema=ON */
451 int showHeader; /* True to show column names in List or Column mode */
452 char *zDestTable; /* Name of destination table when MODE_Insert */
453 char separator[20]; /* Separator character for MODE_List */
454 int colWidth[100]; /* Requested width of each column when in column mode*/
455 int actualWidth[100]; /* Actual width of each column */
456 char nullvalue[20]; /* The text to print when a NULL comes back from
458 struct previous_mode_data explainPrev;
459 /* Holds the mode information just before
461 char outfile[FILENAME_MAX]; /* Filename for *out */
462 const char *zDbFilename; /* name of the database file */
463 char *zFreeOnClose; /* Filename to free when closing */
464 const char *zVfs; /* Name of VFS to use */
465 sqlite3_stmt *pStmt; /* Current statement if any. */
466 FILE *pLog; /* Write log output here */
467 int *aiIndent; /* Array of indents used in MODE_Explain */
468 int nIndent; /* Size of array aiIndent[] */
469 int iIndent; /* Index of current op in aiIndent[] */
473 ** These are the allowed modes.
475 #define MODE_Line 0 /* One column per line. Blank line between records */
476 #define MODE_Column 1 /* One record per line in neat columns */
477 #define MODE_List 2 /* One record per line with a separator */
478 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
479 #define MODE_Html 4 /* Generate an XHTML table */
480 #define MODE_Insert 5 /* Generate SQL "insert" statements */
481 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
482 #define MODE_Csv 7 /* Quote strings, numbers are plain */
483 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
485 static const char *modeDescr[] = {
498 ** Number of elements in an array
500 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
503 ** Compute a string length that is limited to what can be stored in
504 ** lower 30 bits of a 32-bit signed integer.
506 static int strlen30(const char *z){
508 while( *z2 ){ z2++; }
509 return 0x3fffffff & (int)(z2 - z);
513 ** A callback for the sqlite3_log() interface.
515 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
516 struct callback_data *p = (struct callback_data*)pArg;
517 if( p->pLog==0 ) return;
518 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
523 ** Output the given string as a hex-encoded blob (eg. X'1234' )
525 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
527 char *zBlob = (char *)pBlob;
529 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
534 ** Output the given string as a quoted string using SQL quoting conventions.
536 static void output_quoted_string(FILE *out, const char *z){
540 if( z[i]=='\'' ) nSingle++;
543 fprintf(out,"'%s'",z);
547 for(i=0; z[i] && z[i]!='\''; i++){}
551 }else if( z[i]=='\'' ){
552 fprintf(out,"%.*s''",i,z);
564 ** Output the given string as a quoted according to C or TCL quoting rules.
566 static void output_c_string(FILE *out, const char *z){
569 while( (c = *(z++))!=0 ){
585 }else if( !isprint(c&0xff) ){
586 fprintf(out, "\\%03o", c&0xff);
595 ** Output the given string with characters that are special to
598 static void output_html_string(FILE *out, const char *z){
609 fprintf(out,"%.*s",i,z);
613 }else if( z[i]=='&' ){
614 fprintf(out,"&");
615 }else if( z[i]=='>' ){
617 }else if( z[i]=='\"' ){
618 fprintf(out,""");
619 }else if( z[i]=='\'' ){
620 fprintf(out,"'");
629 ** If a field contains any character identified by a 1 in the following
630 ** array, then the string must be quoted for CSV.
632 static const char needCsvQuote[] = {
633 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
634 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
635 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
637 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
639 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
640 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
641 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
642 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
643 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
644 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
645 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
646 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
647 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
648 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
652 ** Output a single term of CSV. Actually, p->separator is used for
653 ** the separator, which may or may not be a comma. p->nullvalue is
654 ** the null value. Strings are quoted if necessary.
656 static void output_csv(struct callback_data *p, const char *z, int bSep){
659 fprintf(out,"%s",p->nullvalue);
662 int nSep = strlen30(p->separator);
664 if( needCsvQuote[((unsigned char*)z)[i]]
665 || (z[i]==p->separator[0] &&
666 (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
674 if( z[i]=='"' ) putc('"', out);
679 fprintf(out, "%s", z);
683 fprintf(p->out, "%s", p->separator);
689 ** This routine runs when the user presses Ctrl-C
691 static void interrupt_handler(int NotUsed){
692 UNUSED_PARAMETER(NotUsed);
694 if( db ) sqlite3_interrupt(db);
699 ** This is the callback routine that the shell
700 ** invokes for each row of a query result.
702 static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){
704 struct callback_data *p = (struct callback_data*)pArg;
709 if( azArg==0 ) break;
710 for(i=0; i<nArg; i++){
711 int len = strlen30(azCol[i] ? azCol[i] : "");
714 if( p->cnt++>0 ) fprintf(p->out,"\n");
715 for(i=0; i<nArg; i++){
716 fprintf(p->out,"%*s = %s\n", w, azCol[i],
717 azArg[i] ? azArg[i] : p->nullvalue);
724 for(i=0; i<nArg; i++){
726 if( i<ArraySize(p->colWidth) ){
732 w = strlen30(azCol[i] ? azCol[i] : "");
734 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);
737 if( i<ArraySize(p->actualWidth) ){
738 p->actualWidth[i] = w;
742 fprintf(p->out,"%*.*s%s",-w,-w,azCol[i], i==nArg-1 ? "\n": " ");
744 fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " ");
749 for(i=0; i<nArg; i++){
751 if( i<ArraySize(p->actualWidth) ){
752 w = p->actualWidth[i];
757 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
758 "----------------------------------------------------------",
759 i==nArg-1 ? "\n": " ");
763 if( azArg==0 ) break;
764 for(i=0; i<nArg; i++){
766 if( i<ArraySize(p->actualWidth) ){
767 w = p->actualWidth[i];
771 if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
772 w = strlen30(azArg[i]);
774 if( i==1 && p->aiIndent && p->pStmt ){
775 if( p->iIndent<p->nIndent ){
776 fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
781 fprintf(p->out,"%*.*s%s",-w,-w,
782 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
784 fprintf(p->out,"%-*.*s%s",w,w,
785 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
792 if( p->cnt++==0 && p->showHeader ){
793 for(i=0; i<nArg; i++){
794 fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
797 if( azArg==0 ) break;
798 for(i=0; i<nArg; i++){
800 if( z==0 ) z = p->nullvalue;
801 fprintf(p->out, "%s", z);
803 fprintf(p->out, "%s", p->separator);
804 }else if( p->mode==MODE_Semi ){
805 fprintf(p->out, ";\n");
807 fprintf(p->out, "\n");
813 if( p->cnt++==0 && p->showHeader ){
814 fprintf(p->out,"<TR>");
815 for(i=0; i<nArg; i++){
816 fprintf(p->out,"<TH>");
817 output_html_string(p->out, azCol[i]);
818 fprintf(p->out,"</TH>\n");
820 fprintf(p->out,"</TR>\n");
822 if( azArg==0 ) break;
823 fprintf(p->out,"<TR>");
824 for(i=0; i<nArg; i++){
825 fprintf(p->out,"<TD>");
826 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
827 fprintf(p->out,"</TD>\n");
829 fprintf(p->out,"</TR>\n");
833 if( p->cnt++==0 && p->showHeader ){
834 for(i=0; i<nArg; i++){
835 output_c_string(p->out,azCol[i] ? azCol[i] : "");
836 if(i<nArg-1) fprintf(p->out, "%s", p->separator);
838 fprintf(p->out,"\n");
840 if( azArg==0 ) break;
841 for(i=0; i<nArg; i++){
842 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
843 if(i<nArg-1) fprintf(p->out, "%s", p->separator);
845 fprintf(p->out,"\n");
849 if( p->cnt++==0 && p->showHeader ){
850 for(i=0; i<nArg; i++){
851 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
853 fprintf(p->out,"\n");
855 if( azArg==0 ) break;
856 for(i=0; i<nArg; i++){
857 output_csv(p, azArg[i], i<nArg-1);
859 fprintf(p->out,"\n");
864 if( azArg==0 ) break;
865 fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
866 for(i=0; i<nArg; i++){
867 char *zSep = i>0 ? ",": "";
868 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
869 fprintf(p->out,"%sNULL",zSep);
870 }else if( aiType && aiType[i]==SQLITE_TEXT ){
871 if( zSep[0] ) fprintf(p->out,"%s",zSep);
872 output_quoted_string(p->out, azArg[i]);
873 }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){
874 fprintf(p->out,"%s%s",zSep, azArg[i]);
875 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
876 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
877 int nBlob = sqlite3_column_bytes(p->pStmt, i);
878 if( zSep[0] ) fprintf(p->out,"%s",zSep);
879 output_hex_blob(p->out, pBlob, nBlob);
880 }else if( isNumber(azArg[i], 0) ){
881 fprintf(p->out,"%s%s",zSep, azArg[i]);
883 if( zSep[0] ) fprintf(p->out,"%s",zSep);
884 output_quoted_string(p->out, azArg[i]);
887 fprintf(p->out,");\n");
895 ** This is the callback routine that the SQLite library
896 ** invokes for each row of a query result.
898 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
899 /* since we don't have type info, call the shell_callback with a NULL value */
900 return shell_callback(pArg, nArg, azArg, azCol, NULL);
904 ** Set the destination table field of the callback_data structure to
905 ** the name of the table given. Escape any quote characters in the
908 static void set_table_name(struct callback_data *p, const char *zName){
917 if( zName==0 ) return;
918 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
919 for(i=n=0; zName[i]; i++, n++){
920 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
922 if( zName[i]=='\'' ) n++;
925 if( needQuote ) n += 2;
926 z = p->zDestTable = malloc( n+1 );
928 fprintf(stderr,"Error: out of memory\n");
932 if( needQuote ) z[n++] = '\'';
933 for(i=0; zName[i]; i++){
935 if( zName[i]=='\'' ) z[n++] = '\'';
937 if( needQuote ) z[n++] = '\'';
941 /* zIn is either a pointer to a NULL-terminated string in memory obtained
942 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
943 ** added to zIn, and the result returned in memory obtained from malloc().
944 ** zIn, if it was not NULL, is freed.
946 ** If the third argument, quote, is not '\0', then it is used as a
947 ** quote character for zAppend.
949 static char *appendText(char *zIn, char const *zAppend, char quote){
952 int nAppend = strlen30(zAppend);
953 int nIn = (zIn?strlen30(zIn):0);
958 for(i=0; i<nAppend; i++){
959 if( zAppend[i]==quote ) len++;
963 zIn = (char *)realloc(zIn, len);
969 char *zCsr = &zIn[nIn];
971 for(i=0; i<nAppend; i++){
972 *zCsr++ = zAppend[i];
973 if( zAppend[i]==quote ) *zCsr++ = quote;
977 assert( (zCsr-zIn)==len );
979 memcpy(&zIn[nIn], zAppend, nAppend);
988 ** Execute a query statement that will generate SQL output. Print
989 ** the result columns, comma-separated, on a line and then add a
990 ** semicolon terminator to the end of that line.
992 ** If the number of columns is 1 and that column contains text "--"
993 ** then write the semicolon on a separate line. That way, if a
994 ** "--" comment occurs at the end of the statement, the comment
995 ** won't consume the semicolon terminator.
997 static int run_table_dump_query(
998 struct callback_data *p, /* Query context */
999 const char *zSelect, /* SELECT statement to extract content */
1000 const char *zFirstRow /* Print before first row, if not NULL */
1002 sqlite3_stmt *pSelect;
1007 rc = sqlite3_prepare(p->db, zSelect, -1, &pSelect, 0);
1008 if( rc!=SQLITE_OK || !pSelect ){
1009 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1010 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1013 rc = sqlite3_step(pSelect);
1014 nResult = sqlite3_column_count(pSelect);
1015 while( rc==SQLITE_ROW ){
1017 fprintf(p->out, "%s", zFirstRow);
1020 z = (const char*)sqlite3_column_text(pSelect, 0);
1021 fprintf(p->out, "%s", z);
1022 for(i=1; i<nResult; i++){
1023 fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
1026 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
1028 fprintf(p->out, "\n;\n");
1030 fprintf(p->out, ";\n");
1032 rc = sqlite3_step(pSelect);
1034 rc = sqlite3_finalize(pSelect);
1035 if( rc!=SQLITE_OK ){
1036 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1037 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1043 ** Allocate space and save off current error string.
1045 static char *save_err_msg(
1046 sqlite3 *db /* Database to query */
1048 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1049 char *zErrMsg = sqlite3_malloc(nErrMsg);
1051 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1057 ** Display memory stats.
1059 static int display_stats(
1060 sqlite3 *db, /* Database to query */
1061 struct callback_data *pArg, /* Pointer to struct callback_data */
1062 int bReset /* True to reset the stats */
1067 if( pArg && pArg->out ){
1070 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1071 fprintf(pArg->out, "Memory Used: %d (max %d) bytes\n", iCur, iHiwtr);
1073 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1074 fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n", iCur, iHiwtr);
1076 ** Not currently used by the CLI.
1077 ** iHiwtr = iCur = -1;
1078 ** sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1079 ** fprintf(pArg->out, "Number of Pcache Pages Used: %d (max %d) pages\n", iCur, iHiwtr);
1082 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1083 fprintf(pArg->out, "Number of Pcache Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
1085 ** Not currently used by the CLI.
1086 ** iHiwtr = iCur = -1;
1087 ** sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1088 ** fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n", iCur, iHiwtr);
1091 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1092 fprintf(pArg->out, "Number of Scratch Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
1094 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1095 fprintf(pArg->out, "Largest Allocation: %d bytes\n", iHiwtr);
1097 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1098 fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n", iHiwtr);
1100 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1101 fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n", iHiwtr);
1102 #ifdef YYTRACKMAXSTACKDEPTH
1104 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1105 fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n", iCur, iHiwtr);
1109 if( pArg && pArg->out && db ){
1111 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHiwtr, bReset);
1112 fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n", iCur, iHiwtr);
1113 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, &iCur, &iHiwtr, bReset);
1114 fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr);
1115 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, &iCur, &iHiwtr, bReset);
1116 fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr);
1117 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, &iCur, &iHiwtr, bReset);
1118 fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr);
1120 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1121 fprintf(pArg->out, "Pager Heap Usage: %d bytes\n", iCur); iHiwtr = iCur = -1;
1122 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1123 fprintf(pArg->out, "Page cache hits: %d\n", iCur);
1125 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1126 fprintf(pArg->out, "Page cache misses: %d\n", iCur);
1128 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1129 fprintf(pArg->out, "Page cache writes: %d\n", iCur);
1131 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1132 fprintf(pArg->out, "Schema Heap Usage: %d bytes\n", iCur);
1134 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1135 fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", iCur);
1138 if( pArg && pArg->out && db && pArg->pStmt ){
1139 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, bReset);
1140 fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1141 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1142 fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1143 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX, bReset);
1144 fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1145 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
1146 fprintf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
1153 ** Parameter azArray points to a zero-terminated array of strings. zStr
1154 ** points to a single nul-terminated string. Return non-zero if zStr
1155 ** is equal, according to strcmp(), to any of the strings in the array.
1156 ** Otherwise, return zero.
1158 static int str_in_array(const char *zStr, const char **azArray){
1160 for(i=0; azArray[i]; i++){
1161 if( 0==strcmp(zStr, azArray[i]) ) return 1;
1167 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1168 ** and populate the callback_data.aiIndent[] array with the number of
1169 ** spaces each opcode should be indented before it is output.
1171 ** The indenting rules are:
1173 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1174 ** all opcodes that occur between the p2 jump destination and the opcode
1175 ** itself by 2 spaces.
1177 ** * For each "Goto", if the jump destination is earlier in the program
1178 ** and ends on one of:
1179 ** Yield SeekGt SeekLt RowSetRead
1180 ** then indent all opcodes between the earlier instruction
1181 ** and "Goto" by 2 spaces.
1183 static void explain_data_prepare(struct callback_data *p, sqlite3_stmt *pSql){
1184 const char *zSql; /* The text of the SQL statement */
1185 const char *z; /* Used to check if this is an EXPLAIN */
1186 int *abYield = 0; /* True if op is an OP_Yield */
1187 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
1188 int iOp; /* Index of operation in p->aiIndent[] */
1190 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 };
1191 const char *azYield[] = { "Yield", "SeekLt", "SeekGt", "RowSetRead", 0 };
1192 const char *azGoto[] = { "Goto", 0 };
1194 /* Try to figure out if this is really an EXPLAIN statement. If this
1195 ** cannot be verified, return early. */
1196 zSql = sqlite3_sql(pSql);
1197 if( zSql==0 ) return;
1198 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
1199 if( sqlite3_strnicmp(z, "explain", 7) ) return;
1201 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
1203 int iAddr = sqlite3_column_int(pSql, 0);
1204 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
1206 /* Set p2 to the P2 field of the current opcode. Then, assuming that
1207 ** p2 is an instruction address, set variable p2op to the index of that
1208 ** instruction in the aiIndent[] array. p2 and p2op may be different if
1209 ** the current instruction is part of a sub-program generated by an
1210 ** SQL trigger or foreign key. */
1211 int p2 = sqlite3_column_int(pSql, 3);
1212 int p2op = (p2 + (iOp-iAddr));
1214 /* Grow the p->aiIndent array as required */
1217 p->aiIndent = (int*)sqlite3_realloc(p->aiIndent, nAlloc*sizeof(int));
1218 abYield = (int*)sqlite3_realloc(abYield, nAlloc*sizeof(int));
1220 abYield[iOp] = str_in_array(zOp, azYield);
1221 p->aiIndent[iOp] = 0;
1224 if( str_in_array(zOp, azNext) ){
1225 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
1227 if( str_in_array(zOp, azGoto) && p2op<p->nIndent && abYield[p2op] ){
1228 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
1233 sqlite3_free(abYield);
1234 sqlite3_reset(pSql);
1238 ** Free the array allocated by explain_data_prepare().
1240 static void explain_data_delete(struct callback_data *p){
1241 sqlite3_free(p->aiIndent);
1248 ** Execute a statement or set of statements. Print
1249 ** any result rows/columns depending on the current mode
1250 ** set via the supplied callback.
1252 ** This is very similar to SQLite's built-in sqlite3_exec()
1253 ** function except it takes a slightly different callback
1254 ** and callback data argument.
1256 static int shell_exec(
1257 sqlite3 *db, /* An open database */
1258 const char *zSql, /* SQL to be evaluated */
1259 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1260 /* (not the same as sqlite3_exec) */
1261 struct callback_data *pArg, /* Pointer to struct callback_data */
1262 char **pzErrMsg /* Error msg written here */
1264 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1265 int rc = SQLITE_OK; /* Return Code */
1267 const char *zLeftover; /* Tail of unprocessed SQL */
1273 while( zSql[0] && (SQLITE_OK == rc) ){
1274 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1275 if( SQLITE_OK != rc ){
1277 *pzErrMsg = save_err_msg(db);
1281 /* this happens for a comment or white-space */
1283 while( IsSpace(zSql[0]) ) zSql++;
1287 /* save off the prepared statment handle and reset row count */
1289 pArg->pStmt = pStmt;
1293 /* echo the sql statement if echo on */
1294 if( pArg && pArg->echoOn ){
1295 const char *zStmtSql = sqlite3_sql(pStmt);
1296 fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1299 /* Output TESTCTRL_EXPLAIN text of requested */
1300 if( pArg && pArg->mode==MODE_Explain ){
1301 const char *zExplain = 0;
1302 sqlite3_test_control(SQLITE_TESTCTRL_EXPLAIN_STMT, pStmt, &zExplain);
1303 if( zExplain && zExplain[0] ){
1304 fprintf(pArg->out, "%s", zExplain);
1308 /* If the shell is currently in ".explain" mode, gather the extra
1309 ** data required to add indents to the output.*/
1310 if( pArg && pArg->mode==MODE_Explain ){
1311 explain_data_prepare(pArg, pStmt);
1314 /* perform the first step. this will tell us if we
1315 ** have a result set or not and how wide it is.
1317 rc = sqlite3_step(pStmt);
1318 /* if we have a result set... */
1319 if( SQLITE_ROW == rc ){
1320 /* if we have a callback... */
1322 /* allocate space for col name ptr, value ptr, and type */
1323 int nCol = sqlite3_column_count(pStmt);
1324 void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1328 char **azCols = (char **)pData; /* Names of result columns */
1329 char **azVals = &azCols[nCol]; /* Results */
1330 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1332 assert(sizeof(int) <= sizeof(char *));
1333 /* save off ptrs to column names */
1334 for(i=0; i<nCol; i++){
1335 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1338 /* extract the data and data types */
1339 for(i=0; i<nCol; i++){
1340 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
1341 if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
1344 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
1346 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1348 break; /* from for */
1352 /* if data and types extracted successfully... */
1353 if( SQLITE_ROW == rc ){
1354 /* call the supplied callback with the result row data */
1355 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1358 rc = sqlite3_step(pStmt);
1361 } while( SQLITE_ROW == rc );
1362 sqlite3_free(pData);
1366 rc = sqlite3_step(pStmt);
1367 } while( rc == SQLITE_ROW );
1371 explain_data_delete(pArg);
1373 /* print usage stats if stats on */
1374 if( pArg && pArg->statsOn ){
1375 display_stats(db, pArg, 0);
1378 /* Finalize the statement just executed. If this fails, save a
1379 ** copy of the error message. Otherwise, set zSql to point to the
1380 ** next statement to execute. */
1381 rc2 = sqlite3_finalize(pStmt);
1382 if( rc!=SQLITE_NOMEM ) rc = rc2;
1383 if( rc==SQLITE_OK ){
1385 while( IsSpace(zSql[0]) ) zSql++;
1386 }else if( pzErrMsg ){
1387 *pzErrMsg = save_err_msg(db);
1390 /* clear saved stmt handle */
1402 ** This is a different callback routine used for dumping the database.
1403 ** Each row received by this callback consists of a table name,
1404 ** the table type ("index" or "table") and SQL to create the table.
1405 ** This routine should print text sufficient to recreate the table.
1407 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1412 const char *zPrepStmt = 0;
1413 struct callback_data *p = (struct callback_data *)pArg;
1415 UNUSED_PARAMETER(azCol);
1416 if( nArg!=3 ) return 1;
1421 if( strcmp(zTable, "sqlite_sequence")==0 ){
1422 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1423 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
1424 fprintf(p->out, "ANALYZE sqlite_master;\n");
1425 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1427 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1429 if( !p->writableSchema ){
1430 fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1431 p->writableSchema = 1;
1433 zIns = sqlite3_mprintf(
1434 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1435 "VALUES('table','%q','%q',0,'%q');",
1436 zTable, zTable, zSql);
1437 fprintf(p->out, "%s\n", zIns);
1441 fprintf(p->out, "%s;\n", zSql);
1444 if( strcmp(zType, "table")==0 ){
1445 sqlite3_stmt *pTableInfo = 0;
1447 char *zTableInfo = 0;
1451 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1452 zTableInfo = appendText(zTableInfo, zTable, '"');
1453 zTableInfo = appendText(zTableInfo, ");", 0);
1455 rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1457 if( rc!=SQLITE_OK || !pTableInfo ){
1461 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1462 /* Always quote the table name, even if it appears to be pure ascii,
1463 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1464 zTmp = appendText(zTmp, zTable, '"');
1466 zSelect = appendText(zSelect, zTmp, '\'');
1469 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1470 rc = sqlite3_step(pTableInfo);
1471 while( rc==SQLITE_ROW ){
1472 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1473 zSelect = appendText(zSelect, "quote(", 0);
1474 zSelect = appendText(zSelect, zText, '"');
1475 rc = sqlite3_step(pTableInfo);
1476 if( rc==SQLITE_ROW ){
1477 zSelect = appendText(zSelect, "), ", 0);
1479 zSelect = appendText(zSelect, ") ", 0);
1483 rc = sqlite3_finalize(pTableInfo);
1484 if( rc!=SQLITE_OK || nRow==0 ){
1488 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1489 zSelect = appendText(zSelect, zTable, '"');
1491 rc = run_table_dump_query(p, zSelect, zPrepStmt);
1492 if( rc==SQLITE_CORRUPT ){
1493 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1494 run_table_dump_query(p, zSelect, 0);
1502 ** Run zQuery. Use dump_callback() as the callback routine so that
1503 ** the contents of the query are output as SQL statements.
1505 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1506 ** "ORDER BY rowid DESC" to the end.
1508 static int run_schema_dump_query(
1509 struct callback_data *p,
1514 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1515 if( rc==SQLITE_CORRUPT ){
1517 int len = strlen30(zQuery);
1518 fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1520 fprintf(p->out, "/****** %s ******/\n", zErr);
1524 zQ2 = malloc( len+100 );
1525 if( zQ2==0 ) return rc;
1526 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1527 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1529 fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1531 rc = SQLITE_CORRUPT;
1540 ** Text of a help message
1542 static char zHelp[] =
1543 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1544 ".bail ON|OFF Stop after hitting an error. Default OFF\n"
1545 ".databases List names and files of attached databases\n"
1546 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1547 " If TABLE specified, only dump tables matching\n"
1548 " LIKE pattern TABLE.\n"
1549 ".echo ON|OFF Turn command echo on or off\n"
1550 ".exit Exit this program\n"
1551 ".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.\n"
1552 " With no args, it turns EXPLAIN on.\n"
1553 ".header(s) ON|OFF Turn display of headers on or off\n"
1554 ".help Show this message\n"
1555 ".import FILE TABLE Import data from FILE into TABLE\n"
1556 ".indices ?TABLE? Show names of all indices\n"
1557 " If TABLE specified, only show indices for tables\n"
1558 " matching LIKE pattern TABLE.\n"
1559 #ifdef SQLITE_ENABLE_IOTRACE
1560 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1562 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1563 ".load FILE ?ENTRY? Load an extension library\n"
1565 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1566 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1567 " csv Comma-separated values\n"
1568 " column Left-aligned columns. (See .width)\n"
1569 " html HTML <table> code\n"
1570 " insert SQL insert statements for TABLE\n"
1571 " line One value per line\n"
1572 " list Values delimited by .separator string\n"
1573 " tabs Tab-separated values\n"
1574 " tcl TCL list elements\n"
1575 ".nullvalue STRING Use STRING in place of NULL values\n"
1576 ".open ?FILENAME? Close existing database and reopen FILENAME\n"
1577 ".output FILENAME Send output to FILENAME\n"
1578 ".output stdout Send output to the screen\n"
1579 ".print STRING... Print literal STRING\n"
1580 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1581 ".quit Exit this program\n"
1582 ".read FILENAME Execute SQL in FILENAME\n"
1583 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1584 ".schema ?TABLE? Show the CREATE statements\n"
1585 " If TABLE specified, only show tables matching\n"
1586 " LIKE pattern TABLE.\n"
1587 ".separator STRING Change separator used by output mode and .import\n"
1588 ".show Show the current values for various settings\n"
1589 ".stats ON|OFF Turn stats on or off\n"
1590 ".tables ?TABLE? List names of tables\n"
1591 " If TABLE specified, only list tables matching\n"
1592 " LIKE pattern TABLE.\n"
1593 ".timeout MS Try opening locked tables for MS milliseconds\n"
1594 ".trace FILE|off Output each SQL statement as it is run\n"
1595 ".vfsname ?AUX? Print the name of the VFS stack\n"
1596 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1599 static char zTimerHelp[] =
1600 ".timer ON|OFF Turn the CPU timer measurement on or off\n"
1603 /* Forward reference */
1604 static int process_input(struct callback_data *p, FILE *in);
1607 ** Make sure the database is open. If it is not, then open it. If
1608 ** the database fails to open, print an error message and exit.
1610 static void open_db(struct callback_data *p, int keepAlive){
1612 sqlite3_initialize();
1613 sqlite3_open(p->zDbFilename, &p->db);
1615 if( db && sqlite3_errcode(db)==SQLITE_OK ){
1616 sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1617 shellstaticFunc, 0, 0);
1619 if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1620 fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1621 p->zDbFilename, sqlite3_errmsg(db));
1622 if( keepAlive ) return;
1625 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1626 sqlite3_enable_load_extension(p->db, 1);
1632 ** Do C-language style dequoting.
1636 ** \r -> carriage return
1638 ** \NNN -> ascii character NNN in octal
1641 static void resolve_backslashes(char *z){
1644 for(i=j=0; (c = z[i])!=0; i++, j++){
1653 }else if( c=='\\' ){
1655 }else if( c>='0' && c<='7' ){
1657 if( z[i+1]>='0' && z[i+1]<='7' ){
1659 c = (c<<3) + z[i] - '0';
1660 if( z[i+1]>='0' && z[i+1]<='7' ){
1662 c = (c<<3) + z[i] - '0';
1673 ** Return the value of a hexadecimal digit. Return -1 if the input
1674 ** is not a hex digit.
1676 static int hexDigitValue(char c){
1677 if( c>='0' && c<='9' ) return c - '0';
1678 if( c>='a' && c<='f' ) return c - 'a' + 10;
1679 if( c>='A' && c<='F' ) return c - 'A' + 10;
1684 ** Interpret zArg as an integer value, possibly with suffixes.
1686 static sqlite3_int64 integerValue(const char *zArg){
1687 sqlite3_int64 v = 0;
1688 static const struct { char *zSuffix; int iMult; } aMult[] = {
1690 { "MiB", 1024*1024 },
1691 { "GiB", 1024*1024*1024 },
1694 { "GB", 1000000000 },
1697 { "G", 1000000000 },
1704 }else if( zArg[0]=='+' ){
1707 if( zArg[0]=='0' && zArg[1]=='x' ){
1710 while( (x = hexDigitValue(zArg[0]))>=0 ){
1715 while( IsDigit(zArg[0]) ){
1716 v = v*10 + zArg[0] - '0';
1720 for(i=0; i<ArraySize(aMult); i++){
1721 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
1722 v *= aMult[i].iMult;
1726 return isNeg? -v : v;
1730 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
1731 ** for TRUE and FALSE. Return the integer value if appropriate.
1733 static int booleanValue(char *zArg){
1735 if( zArg[0]=='0' && zArg[1]=='x' ){
1736 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
1738 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
1740 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
1741 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
1744 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
1747 fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
1753 ** Close an output file, assuming it is not stderr or stdout
1755 static void output_file_close(FILE *f){
1756 if( f && f!=stdout && f!=stderr ) fclose(f);
1760 ** Try to open an output file. The names "stdout" and "stderr" are
1761 ** recognized and do the right thing. NULL is returned if the output
1762 ** filename is "off".
1764 static FILE *output_file_open(const char *zFile){
1766 if( strcmp(zFile,"stdout")==0 ){
1768 }else if( strcmp(zFile, "stderr")==0 ){
1770 }else if( strcmp(zFile, "off")==0 ){
1773 f = fopen(zFile, "wb");
1775 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1782 ** A routine for handling output from sqlite3_trace().
1784 static void sql_trace_callback(void *pArg, const char *z){
1785 FILE *f = (FILE*)pArg;
1786 if( f ) fprintf(f, "%s\n", z);
1790 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
1791 ** a useful spot to set a debugger breakpoint.
1793 static void test_breakpoint(void){
1794 static int nCall = 0;
1799 ** An object used to read a CSV file
1801 typedef struct CSVReader CSVReader;
1803 const char *zFile; /* Name of the input file */
1804 FILE *in; /* Read the CSV text from this input stream */
1805 char *z; /* Accumulated text for a field */
1806 int n; /* Number of bytes in z */
1807 int nAlloc; /* Space allocated for z[] */
1808 int nLine; /* Current line number */
1809 int cTerm; /* Character that terminated the most recent field */
1810 int cSeparator; /* The separator character. (Usually ",") */
1813 /* Append a single byte to z[] */
1814 static void csv_append_char(CSVReader *p, int c){
1815 if( p->n+1>=p->nAlloc ){
1816 p->nAlloc += p->nAlloc + 100;
1817 p->z = sqlite3_realloc(p->z, p->nAlloc);
1819 fprintf(stderr, "out of memory\n");
1823 p->z[p->n++] = (char)c;
1826 /* Read a single field of CSV text. Compatible with rfc4180 and extended
1827 ** with the option of having a separator other than ",".
1829 ** + Input comes from p->in.
1830 ** + Store results in p->z of length p->n. Space to hold p->z comes
1831 ** from sqlite3_malloc().
1832 ** + Use p->cSep as the separator. The default is ",".
1833 ** + Keep track of the line number in p->nLine.
1834 ** + Store the character that terminates the field in p->cTerm. Store
1835 ** EOF on end-of-file.
1836 ** + Report syntax errors on stderr
1838 static char *csv_read_one_field(CSVReader *p){
1840 int cSep = p->cSeparator;
1843 if( c==EOF || seenInterrupt ){
1848 int startLine = p->nLine;
1853 if( c=='\n' ) p->nLine++;
1860 if( (c==cSep && pc==cQuote)
1861 || (c=='\n' && pc==cQuote)
1862 || (c=='\n' && pc=='\r' && p->n>=2 && p->z[p->n-2]==cQuote)
1863 || (c==EOF && pc==cQuote)
1865 do{ p->n--; }while( p->z[p->n]!=cQuote );
1869 if( pc==cQuote && c!='\r' ){
1870 fprintf(stderr, "%s:%d: unescaped %c character\n",
1871 p->zFile, p->nLine, cQuote);
1874 fprintf(stderr, "%s:%d: unterminated %c-quoted field\n",
1875 p->zFile, startLine, cQuote);
1879 csv_append_char(p, c);
1883 while( c!=EOF && c!=cSep && c!='\n' ){
1884 csv_append_char(p, c);
1889 if( p->n>1 && p->z[p->n-1]=='\r' ) p->n--;
1893 if( p->z ) p->z[p->n] = 0;
1898 ** If an input line begins with "." then invoke this routine to
1899 ** process that line.
1901 ** Return 1 on error, 2 to exit, and 0 otherwise.
1903 static int do_meta_command(char *zLine, struct callback_data *p){
1910 /* Parse the input line into tokens.
1912 while( zLine[i] && nArg<ArraySize(azArg) ){
1913 while( IsSpace(zLine[i]) ){ i++; }
1914 if( zLine[i]==0 ) break;
1915 if( zLine[i]=='\'' || zLine[i]=='"' ){
1916 int delim = zLine[i++];
1917 azArg[nArg++] = &zLine[i];
1918 while( zLine[i] && zLine[i]!=delim ){
1919 if( zLine[i]=='\\' && delim=='"' && zLine[i+1]!=0 ) i++;
1922 if( zLine[i]==delim ){
1925 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1927 azArg[nArg++] = &zLine[i];
1928 while( zLine[i] && !IsSpace(zLine[i]) ){ i++; }
1929 if( zLine[i] ) zLine[i++] = 0;
1930 resolve_backslashes(azArg[nArg-1]);
1934 /* Process the input line.
1936 if( nArg==0 ) return 0; /* no tokens, no error */
1937 n = strlen30(azArg[0]);
1939 if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 ){
1940 const char *zDestFile = 0;
1941 const char *zDb = 0;
1943 sqlite3_backup *pBackup;
1945 for(j=1; j<nArg; j++){
1946 const char *z = azArg[j];
1948 while( z[0]=='-' ) z++;
1949 /* No options to process at this time */
1951 fprintf(stderr, "unknown option: %s\n", azArg[j]);
1954 }else if( zDestFile==0 ){
1955 zDestFile = azArg[j];
1958 zDestFile = azArg[j];
1960 fprintf(stderr, "too many arguments to .backup\n");
1965 fprintf(stderr, "missing FILENAME argument on .backup\n");
1968 if( zDb==0 ) zDb = "main";
1969 rc = sqlite3_open(zDestFile, &pDest);
1970 if( rc!=SQLITE_OK ){
1971 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
1972 sqlite3_close(pDest);
1976 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
1978 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1979 sqlite3_close(pDest);
1982 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
1983 sqlite3_backup_finish(pBackup);
1984 if( rc==SQLITE_DONE ){
1987 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1990 sqlite3_close(pDest);
1993 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){
1994 bail_on_error = booleanValue(azArg[1]);
1997 /* The undocumented ".breakpoint" command causes a call to the no-op
1998 ** routine named test_breakpoint().
2000 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
2004 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
2005 struct callback_data data;
2008 memcpy(&data, p, sizeof(data));
2009 data.showHeader = 1;
2010 data.mode = MODE_Column;
2011 data.colWidth[0] = 3;
2012 data.colWidth[1] = 15;
2013 data.colWidth[2] = 58;
2015 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
2017 fprintf(stderr,"Error: %s\n", zErrMsg);
2018 sqlite3_free(zErrMsg);
2023 if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
2025 /* When playing back a "dump", the content might appear in an order
2026 ** which causes immediate foreign key constraints to be violated.
2027 ** So disable foreign-key constraint enforcement to prevent problems. */
2028 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
2029 fprintf(p->out, "BEGIN TRANSACTION;\n");
2030 p->writableSchema = 0;
2031 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2034 run_schema_dump_query(p,
2035 "SELECT name, type, sql FROM sqlite_master "
2036 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2038 run_schema_dump_query(p,
2039 "SELECT name, type, sql FROM sqlite_master "
2040 "WHERE name=='sqlite_sequence'"
2042 run_table_dump_query(p,
2043 "SELECT sql FROM sqlite_master "
2044 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2048 for(i=1; i<nArg; i++){
2049 zShellStatic = azArg[i];
2050 run_schema_dump_query(p,
2051 "SELECT name, type, sql FROM sqlite_master "
2052 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2053 " AND sql NOT NULL");
2054 run_table_dump_query(p,
2055 "SELECT sql FROM sqlite_master "
2056 "WHERE sql NOT NULL"
2057 " AND type IN ('index','trigger','view')"
2058 " AND tbl_name LIKE shellstatic()", 0
2063 if( p->writableSchema ){
2064 fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
2065 p->writableSchema = 0;
2067 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2068 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
2069 fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
2072 if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){
2073 p->echoOn = booleanValue(azArg[1]);
2076 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
2077 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
2081 if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){
2082 int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
2084 if(!p->explainPrev.valid) {
2085 p->explainPrev.valid = 1;
2086 p->explainPrev.mode = p->mode;
2087 p->explainPrev.showHeader = p->showHeader;
2088 memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
2090 /* We could put this code under the !p->explainValid
2091 ** condition so that it does not execute if we are already in
2092 ** explain mode. However, always executing it allows us an easy
2093 ** was to reset to explain mode in case the user previously
2094 ** did an .explain followed by a .width, .mode or .header
2097 p->mode = MODE_Explain;
2099 memset(p->colWidth,0,sizeof(p->colWidth));
2100 p->colWidth[0] = 4; /* addr */
2101 p->colWidth[1] = 13; /* opcode */
2102 p->colWidth[2] = 4; /* P1 */
2103 p->colWidth[3] = 4; /* P2 */
2104 p->colWidth[4] = 4; /* P3 */
2105 p->colWidth[5] = 13; /* P4 */
2106 p->colWidth[6] = 2; /* P5 */
2107 p->colWidth[7] = 13; /* Comment */
2108 }else if (p->explainPrev.valid) {
2109 p->explainPrev.valid = 0;
2110 p->mode = p->explainPrev.mode;
2111 p->showHeader = p->explainPrev.showHeader;
2112 memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
2116 if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
2117 strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){
2118 p->showHeader = booleanValue(azArg[1]);
2121 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
2122 fprintf(stderr,"%s",zHelp);
2124 fprintf(stderr,"%s",zTimerHelp);
2128 if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
2129 char *zTable = azArg[2]; /* Insert data into this table */
2130 char *zFile = azArg[1]; /* Name of file to extra content from */
2131 sqlite3_stmt *pStmt = NULL; /* A statement */
2132 int nCol; /* Number of columns in the table */
2133 int nByte; /* Number of bytes in an SQL string */
2134 int i, j; /* Loop counters */
2135 int needCommit; /* True to COMMIT or ROLLBACK at end */
2136 int nSep; /* Number of bytes in p->separator[] */
2137 char *zSql; /* An SQL statement */
2138 CSVReader sCsv; /* Reader context */
2139 int (*xCloser)(FILE*); /* Procedure to close th3 connection */
2142 memset(&sCsv, 0, sizeof(sCsv));
2144 nSep = strlen30(p->separator);
2146 fprintf(stderr, "Error: non-null separator required for import\n");
2150 fprintf(stderr, "Error: multi-character separators not allowed"
2156 if( sCsv.zFile[0]=='|' ){
2157 sCsv.in = popen(sCsv.zFile+1, "r");
2158 sCsv.zFile = "<pipe>";
2161 sCsv.in = fopen(sCsv.zFile, "rb");
2165 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2168 sCsv.cSeparator = p->separator[0];
2169 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
2171 fprintf(stderr, "Error: out of memory\n");
2175 nByte = strlen30(zSql);
2176 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2177 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
2178 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
2180 while( csv_read_one_field(&sCsv) ){
2181 zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCsv.z);
2183 if( sCsv.cTerm!=sCsv.cSeparator ) break;
2186 sqlite3_free(zCreate);
2187 sqlite3_free(sCsv.z);
2189 fprintf(stderr,"%s: empty file\n", sCsv.zFile);
2192 zCreate = sqlite3_mprintf("%z\n)", zCreate);
2193 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
2194 sqlite3_free(zCreate);
2196 fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
2197 sqlite3_errmsg(db));
2198 sqlite3_free(sCsv.z);
2202 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2206 if (pStmt) sqlite3_finalize(pStmt);
2207 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
2211 nCol = sqlite3_column_count(pStmt);
2212 sqlite3_finalize(pStmt);
2214 if( nCol==0 ) return 0; /* no columns, no error */
2215 zSql = sqlite3_malloc( nByte*2 + 20 + nCol*2 );
2217 fprintf(stderr, "Error: out of memory\n");
2221 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
2223 for(i=1; i<nCol; i++){
2229 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2232 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
2233 if (pStmt) sqlite3_finalize(pStmt);
2237 needCommit = sqlite3_get_autocommit(db);
2238 if( needCommit ) sqlite3_exec(db, "BEGIN", 0, 0, 0);
2240 int startLine = sCsv.nLine;
2241 for(i=0; i<nCol; i++){
2242 char *z = csv_read_one_field(&sCsv);
2243 if( z==0 && i==0 ) break;
2244 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
2245 if( i<nCol-1 && sCsv.cTerm!=sCsv.cSeparator ){
2246 fprintf(stderr, "%s:%d: expected %d columns but found %d - "
2247 "filling the rest with NULL\n",
2248 sCsv.zFile, startLine, nCol, i+1);
2250 while( i<nCol ){ sqlite3_bind_null(pStmt, i); i++; }
2253 if( sCsv.cTerm==sCsv.cSeparator ){
2255 csv_read_one_field(&sCsv);
2257 }while( sCsv.cTerm==sCsv.cSeparator );
2258 fprintf(stderr, "%s:%d: expected %d columns but found %d - "
2260 sCsv.zFile, startLine, nCol, i);
2263 sqlite3_step(pStmt);
2264 rc = sqlite3_reset(pStmt);
2265 if( rc!=SQLITE_OK ){
2266 fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCsv.zFile, startLine,
2267 sqlite3_errmsg(db));
2270 }while( sCsv.cTerm!=EOF );
2273 sqlite3_free(sCsv.z);
2274 sqlite3_finalize(pStmt);
2275 if( needCommit ) sqlite3_exec(db, "COMMIT", 0, 0, 0);
2278 if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){
2279 struct callback_data data;
2282 memcpy(&data, p, sizeof(data));
2283 data.showHeader = 0;
2284 data.mode = MODE_List;
2286 rc = sqlite3_exec(p->db,
2287 "SELECT name FROM sqlite_master "
2288 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
2290 "SELECT name FROM sqlite_temp_master "
2291 "WHERE type='index' "
2293 callback, &data, &zErrMsg
2296 zShellStatic = azArg[1];
2297 rc = sqlite3_exec(p->db,
2298 "SELECT name FROM sqlite_master "
2299 "WHERE type='index' AND tbl_name LIKE shellstatic() "
2301 "SELECT name FROM sqlite_temp_master "
2302 "WHERE type='index' AND tbl_name LIKE shellstatic() "
2304 callback, &data, &zErrMsg
2309 fprintf(stderr,"Error: %s\n", zErrMsg);
2310 sqlite3_free(zErrMsg);
2312 }else if( rc != SQLITE_OK ){
2313 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
2318 #ifdef SQLITE_ENABLE_IOTRACE
2319 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
2320 extern void (*sqlite3IoTrace)(const char*, ...);
2321 if( iotrace && iotrace!=stdout ) fclose(iotrace);
2325 }else if( strcmp(azArg[1], "-")==0 ){
2326 sqlite3IoTrace = iotracePrintf;
2329 iotrace = fopen(azArg[1], "w");
2331 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
2335 sqlite3IoTrace = iotracePrintf;
2341 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2342 if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
2343 const char *zFile, *zProc;
2346 zProc = nArg>=3 ? azArg[2] : 0;
2348 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
2349 if( rc!=SQLITE_OK ){
2350 fprintf(stderr, "Error: %s\n", zErrMsg);
2351 sqlite3_free(zErrMsg);
2357 if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=2 ){
2358 const char *zFile = azArg[1];
2359 output_file_close(p->pLog);
2360 p->pLog = output_file_open(zFile);
2363 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){
2364 int n2 = strlen30(azArg[1]);
2365 if( (n2==4 && strncmp(azArg[1],"line",n2)==0)
2367 (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){
2368 p->mode = MODE_Line;
2369 }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0)
2371 (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){
2372 p->mode = MODE_Column;
2373 }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){
2374 p->mode = MODE_List;
2375 }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){
2376 p->mode = MODE_Html;
2377 }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){
2379 sqlite3_snprintf(sizeof(p->separator), p->separator, " ");
2380 }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){
2382 sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
2383 }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){
2384 p->mode = MODE_List;
2385 sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
2386 }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2387 p->mode = MODE_Insert;
2388 set_table_name(p, "table");
2390 fprintf(stderr,"Error: mode should be one of: "
2391 "column csv html insert line list tabs tcl\n");
2396 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){
2397 int n2 = strlen30(azArg[1]);
2398 if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2399 p->mode = MODE_Insert;
2400 set_table_name(p, azArg[2]);
2402 fprintf(stderr, "Error: invalid arguments: "
2403 " \"%s\". Enter \".help\" for help\n", azArg[2]);
2408 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
2409 sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
2410 "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
2413 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
2414 sqlite3 *savedDb = p->db;
2415 const char *zSavedFilename = p->zDbFilename;
2416 char *zNewFilename = 0;
2419 p->zDbFilename = zNewFilename = sqlite3_mprintf("%s", azArg[1]);
2423 sqlite3_close(savedDb);
2424 sqlite3_free(p->zFreeOnClose);
2425 p->zFreeOnClose = zNewFilename;
2427 sqlite3_free(zNewFilename);
2429 p->zDbFilename = zSavedFilename;
2433 if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
2434 if( p->outfile[0]=='|' ){
2437 output_file_close(p->out);
2440 if( azArg[1][0]=='|' ){
2441 p->out = popen(&azArg[1][1], "w");
2443 fprintf(stderr,"Error: cannot open pipe \"%s\"\n", &azArg[1][1]);
2447 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2450 p->out = output_file_open(azArg[1]);
2452 if( strcmp(azArg[1],"off")!=0 ){
2453 fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]);
2458 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2463 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
2465 for(i=1; i<nArg; i++){
2466 if( i>1 ) fprintf(p->out, " ");
2467 fprintf(p->out, "%s", azArg[i]);
2469 fprintf(p->out, "\n");
2472 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
2474 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
2477 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
2481 if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){
2485 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
2486 FILE *alt = fopen(azArg[1], "rb");
2488 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
2491 rc = process_input(p, alt);
2496 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){
2497 const char *zSrcFile;
2500 sqlite3_backup *pBackup;
2504 zSrcFile = azArg[1];
2507 zSrcFile = azArg[2];
2510 rc = sqlite3_open(zSrcFile, &pSrc);
2511 if( rc!=SQLITE_OK ){
2512 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
2513 sqlite3_close(pSrc);
2517 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
2519 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2520 sqlite3_close(pSrc);
2523 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
2524 || rc==SQLITE_BUSY ){
2525 if( rc==SQLITE_BUSY ){
2526 if( nTimeout++ >= 3 ) break;
2530 sqlite3_backup_finish(pBackup);
2531 if( rc==SQLITE_DONE ){
2533 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
2534 fprintf(stderr, "Error: source database is busy\n");
2537 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2540 sqlite3_close(pSrc);
2543 if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){
2544 struct callback_data data;
2547 memcpy(&data, p, sizeof(data));
2548 data.showHeader = 0;
2549 data.mode = MODE_Semi;
2552 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
2553 if( strcmp(azArg[1],"sqlite_master")==0 ){
2554 char *new_argv[2], *new_colv[2];
2555 new_argv[0] = "CREATE TABLE sqlite_master (\n"
2559 " rootpage integer,\n"
2563 new_colv[0] = "sql";
2565 callback(&data, 1, new_argv, new_colv);
2567 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
2568 char *new_argv[2], *new_colv[2];
2569 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
2573 " rootpage integer,\n"
2577 new_colv[0] = "sql";
2579 callback(&data, 1, new_argv, new_colv);
2582 zShellStatic = azArg[1];
2583 rc = sqlite3_exec(p->db,
2585 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2586 " FROM sqlite_master UNION ALL"
2587 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2588 "WHERE lower(tbl_name) LIKE shellstatic()"
2589 " AND type!='meta' AND sql NOTNULL "
2591 callback, &data, &zErrMsg);
2595 rc = sqlite3_exec(p->db,
2597 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2598 " FROM sqlite_master UNION ALL"
2599 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2600 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
2602 callback, &data, &zErrMsg
2606 fprintf(stderr,"Error: %s\n", zErrMsg);
2607 sqlite3_free(zErrMsg);
2609 }else if( rc != SQLITE_OK ){
2610 fprintf(stderr,"Error: querying schema information\n");
2618 /* Undocumented commands for internal testing. Subject to change
2619 ** without notice. */
2620 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
2621 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
2623 for(i=1; i<nArg; i++){
2624 v = booleanValue(azArg[i]);
2625 fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
2628 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
2629 int i; sqlite3_int64 v;
2630 for(i=1; i<nArg; i++){
2632 v = integerValue(azArg[i]);
2633 sqlite3_snprintf(sizeof(zBuf), zBuf, "%s: %lld 0x%llx\n", azArg[i], v, v);
2634 fprintf(p->out, "%s", zBuf);
2640 if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2641 sqlite3_snprintf(sizeof(p->separator), p->separator,
2642 "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2645 if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){
2647 fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
2648 fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
2649 fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
2650 fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
2651 fprintf(p->out,"%9.9s: ", "nullvalue");
2652 output_c_string(p->out, p->nullvalue);
2653 fprintf(p->out, "\n");
2654 fprintf(p->out,"%9.9s: %s\n","output",
2655 strlen30(p->outfile) ? p->outfile : "stdout");
2656 fprintf(p->out,"%9.9s: ", "separator");
2657 output_c_string(p->out, p->separator);
2658 fprintf(p->out, "\n");
2659 fprintf(p->out,"%9.9s: %s\n","stats", p->statsOn ? "on" : "off");
2660 fprintf(p->out,"%9.9s: ","width");
2661 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
2662 fprintf(p->out,"%d ",p->colWidth[i]);
2664 fprintf(p->out,"\n");
2667 if( c=='s' && strncmp(azArg[0], "stats", n)==0 && nArg>1 && nArg<3 ){
2668 p->statsOn = booleanValue(azArg[1]);
2671 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){
2672 sqlite3_stmt *pStmt;
2678 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
2680 zSql = sqlite3_mprintf(
2681 "SELECT name FROM sqlite_master"
2682 " WHERE type IN ('table','view')"
2683 " AND name NOT LIKE 'sqlite_%%'"
2684 " AND name LIKE ?1");
2685 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2686 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
2687 if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
2688 if( strcmp(zDbName,"temp")==0 ){
2689 zSql = sqlite3_mprintf(
2691 "SELECT 'temp.' || name FROM sqlite_temp_master"
2692 " WHERE type IN ('table','view')"
2693 " AND name NOT LIKE 'sqlite_%%'"
2694 " AND name LIKE ?1", zSql);
2696 zSql = sqlite3_mprintf(
2698 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
2699 " WHERE type IN ('table','view')"
2700 " AND name NOT LIKE 'sqlite_%%'"
2701 " AND name LIKE ?1", zSql, zDbName, zDbName);
2704 sqlite3_finalize(pStmt);
2705 zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
2706 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2712 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
2714 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
2716 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2719 int n = nAlloc*2 + 10;
2720 azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n);
2722 fprintf(stderr, "Error: out of memory\n");
2728 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
2729 if( azResult[nRow] ) nRow++;
2731 sqlite3_finalize(pStmt);
2733 int len, maxlen = 0;
2735 int nPrintCol, nPrintRow;
2736 for(i=0; i<nRow; i++){
2737 len = strlen30(azResult[i]);
2738 if( len>maxlen ) maxlen = len;
2740 nPrintCol = 80/(maxlen+2);
2741 if( nPrintCol<1 ) nPrintCol = 1;
2742 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
2743 for(i=0; i<nPrintRow; i++){
2744 for(j=i; j<nRow; j+=nPrintRow){
2745 char *zSp = j<nPrintRow ? "" : " ";
2746 fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
2748 fprintf(p->out, "\n");
2751 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
2752 sqlite3_free(azResult);
2755 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
2756 static const struct {
2757 const char *zCtrlName; /* Name of a test-control option */
2758 int ctrlCode; /* Integer code for that option */
2760 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
2761 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
2762 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
2763 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
2764 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
2765 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
2766 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
2767 { "assert", SQLITE_TESTCTRL_ASSERT },
2768 { "always", SQLITE_TESTCTRL_ALWAYS },
2769 { "reserve", SQLITE_TESTCTRL_RESERVE },
2770 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
2771 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
2772 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
2779 /* convert testctrl text option to value. allow any unique prefix
2780 ** of the option name, or a numerical value. */
2781 n = strlen30(azArg[1]);
2782 for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){
2783 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){
2785 testctrl = aCtrl[i].ctrlCode;
2787 fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
2793 if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
2794 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
2795 fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
2799 /* sqlite3_test_control(int, db, int) */
2800 case SQLITE_TESTCTRL_OPTIMIZATIONS:
2801 case SQLITE_TESTCTRL_RESERVE:
2803 int opt = (int)strtol(azArg[2], 0, 0);
2804 rc = sqlite3_test_control(testctrl, p->db, opt);
2805 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2807 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2812 /* sqlite3_test_control(int) */
2813 case SQLITE_TESTCTRL_PRNG_SAVE:
2814 case SQLITE_TESTCTRL_PRNG_RESTORE:
2815 case SQLITE_TESTCTRL_PRNG_RESET:
2817 rc = sqlite3_test_control(testctrl);
2818 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2820 fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
2824 /* sqlite3_test_control(int, uint) */
2825 case SQLITE_TESTCTRL_PENDING_BYTE:
2827 unsigned int opt = (unsigned int)integerValue(azArg[2]);
2828 rc = sqlite3_test_control(testctrl, opt);
2829 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2831 fprintf(stderr,"Error: testctrl %s takes a single unsigned"
2832 " int option\n", azArg[1]);
2836 /* sqlite3_test_control(int, int) */
2837 case SQLITE_TESTCTRL_ASSERT:
2838 case SQLITE_TESTCTRL_ALWAYS:
2840 int opt = booleanValue(azArg[2]);
2841 rc = sqlite3_test_control(testctrl, opt);
2842 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2844 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2849 /* sqlite3_test_control(int, char *) */
2850 #ifdef SQLITE_N_KEYWORD
2851 case SQLITE_TESTCTRL_ISKEYWORD:
2853 const char *opt = azArg[2];
2854 rc = sqlite3_test_control(testctrl, opt);
2855 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2857 fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
2863 case SQLITE_TESTCTRL_BITVEC_TEST:
2864 case SQLITE_TESTCTRL_FAULT_INSTALL:
2865 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
2866 case SQLITE_TESTCTRL_SCRATCHMALLOC:
2868 fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
2875 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){
2877 sqlite3_busy_timeout(p->db, (int)integerValue(azArg[1]));
2880 if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0
2883 enableTimer = booleanValue(azArg[1]);
2886 if( c=='t' && strncmp(azArg[0], "trace", n)==0 && nArg>1 ){
2888 output_file_close(p->traceOut);
2889 p->traceOut = output_file_open(azArg[1]);
2890 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
2891 if( p->traceOut==0 ){
2892 sqlite3_trace(p->db, 0, 0);
2894 sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
2899 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
2900 fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
2901 sqlite3_libversion(), sqlite3_sourceid());
2904 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
2905 const char *zDbName = nArg==2 ? azArg[1] : "main";
2908 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
2910 fprintf(p->out, "%s\n", zVfsName);
2911 sqlite3_free(zVfsName);
2916 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
2917 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
2918 extern int sqlite3WhereTrace;
2919 sqlite3WhereTrace = booleanValue(azArg[1]);
2923 if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){
2925 assert( nArg<=ArraySize(azArg) );
2926 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
2927 p->colWidth[j-1] = (int)integerValue(azArg[j]);
2932 fprintf(stderr, "Error: unknown command or invalid arguments: "
2933 " \"%s\". Enter \".help\" for help\n", azArg[0]);
2941 ** Return TRUE if a semicolon occurs anywhere in the first N characters
2944 static int line_contains_semicolon(const char *z, int N){
2946 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
2951 ** Test to see if a line consists entirely of whitespace.
2953 static int _all_whitespace(const char *z){
2955 if( IsSpace(z[0]) ) continue;
2956 if( *z=='/' && z[1]=='*' ){
2958 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
2959 if( *z==0 ) return 0;
2963 if( *z=='-' && z[1]=='-' ){
2965 while( *z && *z!='\n' ){ z++; }
2966 if( *z==0 ) return 1;
2975 ** Return TRUE if the line typed in is an SQL command terminator other
2976 ** than a semi-colon. The SQL Server style "go" command is understood
2977 ** as is the Oracle "/".
2979 static int line_is_command_terminator(const char *zLine){
2980 while( IsSpace(zLine[0]) ){ zLine++; };
2981 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
2982 return 1; /* Oracle */
2984 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
2985 && _all_whitespace(&zLine[2]) ){
2986 return 1; /* SQL Server */
2992 ** Return true if zSql is a complete SQL statement. Return false if it
2993 ** ends in the middle of a string literal or C-style comment.
2995 static int line_is_complete(char *zSql, int nSql){
2997 if( zSql==0 ) return 1;
3000 rc = sqlite3_complete(zSql);
3006 ** Read input from *in and process it. If *in==0 then input
3007 ** is interactive - the user is typing it it. Otherwise, input
3008 ** is coming from a file or device. A prompt is issued and history
3009 ** is saved only if input is interactive. An interrupt signal will
3010 ** cause this routine to exit immediately, unless input is interactive.
3012 ** Return the number of errors.
3014 static int process_input(struct callback_data *p, FILE *in){
3015 char *zLine = 0; /* A single input line */
3016 char *zSql = 0; /* Accumulated SQL text */
3017 int nLine; /* Length of current line */
3018 int nSql = 0; /* Bytes of zSql[] used */
3019 int nAlloc = 0; /* Allocated zSql[] space */
3020 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
3021 char *zErrMsg; /* Error message returned */
3022 int rc; /* Error code */
3023 int errCnt = 0; /* Number of errors seen */
3024 int lineno = 0; /* Current line number */
3025 int startline = 0; /* Line number for start of current input */
3027 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
3029 zLine = one_input_line(in, zLine, nSql>0);
3032 if( stdin_is_interactive ) printf("\n");
3035 if( seenInterrupt ){
3040 if( nSql==0 && _all_whitespace(zLine) ) continue;
3041 if( zLine && zLine[0]=='.' && nSql==0 ){
3042 if( p->echoOn ) printf("%s\n", zLine);
3043 rc = do_meta_command(zLine, p);
3044 if( rc==2 ){ /* exit requested */
3051 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
3052 memcpy(zLine,";",2);
3054 nLine = strlen30(zLine);
3055 if( nSql+nLine+2>=nAlloc ){
3056 nAlloc = nSql+nLine+100;
3057 zSql = realloc(zSql, nAlloc);
3059 fprintf(stderr, "Error: out of memory\n");
3066 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
3067 assert( nAlloc>0 && zSql!=0 );
3068 memcpy(zSql, zLine+i, nLine+1-i);
3072 zSql[nSql++] = '\n';
3073 memcpy(zSql+nSql, zLine, nLine+1);
3076 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
3077 && sqlite3_complete(zSql) ){
3081 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
3083 if( rc || zErrMsg ){
3085 if( in!=0 || !stdin_is_interactive ){
3086 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
3087 "Error: near line %d:", startline);
3089 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
3092 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
3093 sqlite3_free(zErrMsg);
3096 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
3101 }else if( nSql && _all_whitespace(zSql) ){
3106 if( !_all_whitespace(zSql) ){
3107 fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
3116 ** Return a pathname which is the user's home directory. A
3117 ** 0 return indicates an error of some kind.
3119 static char *find_home_dir(void){
3120 static char *home_dir = NULL;
3121 if( home_dir ) return home_dir;
3123 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)
3125 struct passwd *pwent;
3126 uid_t uid = getuid();
3127 if( (pwent=getpwuid(uid)) != NULL) {
3128 home_dir = pwent->pw_dir;
3133 #if defined(_WIN32_WCE)
3134 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
3139 #if defined(_WIN32) || defined(WIN32)
3141 home_dir = getenv("USERPROFILE");
3146 home_dir = getenv("HOME");
3149 #if defined(_WIN32) || defined(WIN32)
3151 char *zDrive, *zPath;
3153 zDrive = getenv("HOMEDRIVE");
3154 zPath = getenv("HOMEPATH");
3155 if( zDrive && zPath ){
3156 n = strlen30(zDrive) + strlen30(zPath) + 1;
3157 home_dir = malloc( n );
3158 if( home_dir==0 ) return 0;
3159 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
3166 #endif /* !_WIN32_WCE */
3169 int n = strlen30(home_dir) + 1;
3170 char *z = malloc( n );
3171 if( z ) memcpy(z, home_dir, n);
3179 ** Read input from the file given by sqliterc_override. Or if that
3180 ** parameter is NULL, take input from ~/.sqliterc
3182 ** Returns the number of errors.
3184 static int process_sqliterc(
3185 struct callback_data *p, /* Configuration data */
3186 const char *sqliterc_override /* Name of config file. NULL to use default */
3188 char *home_dir = NULL;
3189 const char *sqliterc = sqliterc_override;
3194 if (sqliterc == NULL) {
3195 home_dir = find_home_dir();
3197 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
3198 fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
3202 sqlite3_initialize();
3203 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
3206 in = fopen(sqliterc,"rb");
3208 if( stdin_is_interactive ){
3209 fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
3211 rc = process_input(p,in);
3219 ** Show available command line options
3221 static const char zOptions[] =
3222 " -bail stop after hitting an error\n"
3223 " -batch force batch I/O\n"
3224 " -column set output mode to 'column'\n"
3225 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
3226 " -csv set output mode to 'csv'\n"
3227 " -echo print commands before execution\n"
3228 " -init FILENAME read/process named file\n"
3229 " -[no]header turn headers on or off\n"
3230 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
3231 " -heap SIZE Size of heap for memsys3 or memsys5\n"
3233 " -help show this message\n"
3234 " -html set output mode to HTML\n"
3235 " -interactive force interactive I/O\n"
3236 " -line set output mode to 'line'\n"
3237 " -list set output mode to 'list'\n"
3238 " -mmap N default mmap size set to N\n"
3239 #ifdef SQLITE_ENABLE_MULTIPLEX
3240 " -multiplex enable the multiplexor VFS\n"
3242 " -nullvalue TEXT set text string for NULL values. Default ''\n"
3243 " -separator SEP set output field separator. Default: '|'\n"
3244 " -stats print memory stats before each finalize\n"
3245 " -version show SQLite version\n"
3246 " -vfs NAME use NAME as the default VFS\n"
3247 #ifdef SQLITE_ENABLE_VFSTRACE
3248 " -vfstrace enable tracing of all VFS calls\n"
3251 static void usage(int showDetail){
3253 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
3254 "FILENAME is the name of an SQLite database. A new database is created\n"
3255 "if the file does not previously exist.\n", Argv0);
3257 fprintf(stderr, "OPTIONS include:\n%s", zOptions);
3259 fprintf(stderr, "Use the -help option for additional information\n");
3265 ** Initialize the state information in data
3267 static void main_init(struct callback_data *data) {
3268 memset(data, 0, sizeof(*data));
3269 data->mode = MODE_List;
3270 memcpy(data->separator,"|", 2);
3271 data->showHeader = 0;
3272 sqlite3_config(SQLITE_CONFIG_URI, 1);
3273 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
3274 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
3275 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
3276 sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
3280 ** Get the argument to an --option. Throw an error and die if no argument
3283 static char *cmdline_option_value(int argc, char **argv, int i){
3285 fprintf(stderr, "%s: Error: missing argument to %s\n",
3286 argv[0], argv[argc-1]);
3292 int main(int argc, char **argv){
3294 struct callback_data data;
3295 const char *zInitFile = 0;
3296 char *zFirstCmd = 0;
3300 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
3301 fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
3302 sqlite3_sourceid(), SQLITE_SOURCE_ID);
3307 stdin_is_interactive = isatty(0);
3309 /* Make sure we have a valid signal handler early, before anything
3313 signal(SIGINT, interrupt_handler);
3316 /* Do an initial pass through the command-line argument to locate
3317 ** the name of the database file, the name of the initialization file,
3318 ** the size of the alternative malloc heap,
3319 ** and the first command to execute.
3321 for(i=1; i<argc; i++){
3325 if( data.zDbFilename==0 ){
3326 data.zDbFilename = z;
3333 fprintf(stderr,"%s: Error: too many options: \"%s\"\n", Argv0, argv[i]);
3334 fprintf(stderr,"Use -help for a list of options.\n");
3337 if( z[1]=='-' ) z++;
3338 if( strcmp(z,"-separator")==0
3339 || strcmp(z,"-nullvalue")==0
3340 || strcmp(z,"-cmd")==0
3342 (void)cmdline_option_value(argc, argv, ++i);
3343 }else if( strcmp(z,"-init")==0 ){
3344 zInitFile = cmdline_option_value(argc, argv, ++i);
3345 }else if( strcmp(z,"-batch")==0 ){
3346 /* Need to check for batch mode here to so we can avoid printing
3347 ** informational messages (like from process_sqliterc) before
3348 ** we do the actual processing of arguments later in a second pass.
3350 stdin_is_interactive = 0;
3351 }else if( strcmp(z,"-heap")==0 ){
3352 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
3354 sqlite3_int64 szHeap;
3356 zSize = cmdline_option_value(argc, argv, ++i);
3357 szHeap = integerValue(zSize);
3358 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
3359 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
3361 #ifdef SQLITE_ENABLE_VFSTRACE
3362 }else if( strcmp(z,"-vfstrace")==0 ){
3363 extern int vfstrace_register(
3364 const char *zTraceName,
3365 const char *zOldVfsName,
3366 int (*xOut)(const char*,void*),
3370 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
3372 #ifdef SQLITE_ENABLE_MULTIPLEX
3373 }else if( strcmp(z,"-multiplex")==0 ){
3374 extern int sqlite3_multiple_initialize(const char*,int);
3375 sqlite3_multiplex_initialize(0, 1);
3377 }else if( strcmp(z,"-mmap")==0 ){
3378 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
3379 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
3380 }else if( strcmp(z,"-vfs")==0 ){
3381 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
3383 sqlite3_vfs_register(pVfs, 1);
3385 fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
3390 if( data.zDbFilename==0 ){
3391 #ifndef SQLITE_OMIT_MEMORYDB
3392 data.zDbFilename = ":memory:";
3394 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
3400 /* Go ahead and open the database file if it already exists. If the
3401 ** file does not exist, delay opening it. This prevents empty database
3402 ** files from being created if a user mistypes the database name argument
3403 ** to the sqlite command-line tool.
3405 if( access(data.zDbFilename, 0)==0 ){
3409 /* Process the initialization file if there is one. If no -init option
3410 ** is given on the command line, look for a file named ~/.sqliterc and
3411 ** try to process it.
3413 rc = process_sqliterc(&data,zInitFile);
3418 /* Make a second pass through the command-line argument and set
3419 ** options. This second pass is delayed until after the initialization
3420 ** file is processed so that the command-line arguments will override
3421 ** settings in the initialization file.
3423 for(i=1; i<argc; i++){
3425 if( z[0]!='-' ) continue;
3426 if( z[1]=='-' ){ z++; }
3427 if( strcmp(z,"-init")==0 ){
3429 }else if( strcmp(z,"-html")==0 ){
3430 data.mode = MODE_Html;
3431 }else if( strcmp(z,"-list")==0 ){
3432 data.mode = MODE_List;
3433 }else if( strcmp(z,"-line")==0 ){
3434 data.mode = MODE_Line;
3435 }else if( strcmp(z,"-column")==0 ){
3436 data.mode = MODE_Column;
3437 }else if( strcmp(z,"-csv")==0 ){
3438 data.mode = MODE_Csv;
3439 memcpy(data.separator,",",2);
3440 }else if( strcmp(z,"-separator")==0 ){
3441 sqlite3_snprintf(sizeof(data.separator), data.separator,
3442 "%s",cmdline_option_value(argc,argv,++i));
3443 }else if( strcmp(z,"-nullvalue")==0 ){
3444 sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
3445 "%s",cmdline_option_value(argc,argv,++i));
3446 }else if( strcmp(z,"-header")==0 ){
3447 data.showHeader = 1;
3448 }else if( strcmp(z,"-noheader")==0 ){
3449 data.showHeader = 0;
3450 }else if( strcmp(z,"-echo")==0 ){
3452 }else if( strcmp(z,"-stats")==0 ){
3454 }else if( strcmp(z,"-bail")==0 ){
3456 }else if( strcmp(z,"-version")==0 ){
3457 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
3459 }else if( strcmp(z,"-interactive")==0 ){
3460 stdin_is_interactive = 1;
3461 }else if( strcmp(z,"-batch")==0 ){
3462 stdin_is_interactive = 0;
3463 }else if( strcmp(z,"-heap")==0 ){
3465 }else if( strcmp(z,"-mmap")==0 ){
3467 }else if( strcmp(z,"-vfs")==0 ){
3469 #ifdef SQLITE_ENABLE_VFSTRACE
3470 }else if( strcmp(z,"-vfstrace")==0 ){
3473 #ifdef SQLITE_ENABLE_MULTIPLEX
3474 }else if( strcmp(z,"-multiplex")==0 ){
3477 }else if( strcmp(z,"-help")==0 ){
3479 }else if( strcmp(z,"-cmd")==0 ){
3480 if( i==argc-1 ) break;
3481 z = cmdline_option_value(argc,argv,++i);
3483 rc = do_meta_command(z, &data);
3484 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
3487 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
3489 fprintf(stderr,"Error: %s\n", zErrMsg);
3490 if( bail_on_error ) return rc!=0 ? rc : 1;
3492 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
3493 if( bail_on_error ) return rc;
3497 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
3498 fprintf(stderr,"Use -help for a list of options.\n");
3504 /* Run just the command that follows the database name
3506 if( zFirstCmd[0]=='.' ){
3507 rc = do_meta_command(zFirstCmd, &data);
3511 rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
3513 fprintf(stderr,"Error: %s\n", zErrMsg);
3514 return rc!=0 ? rc : 1;
3516 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd);
3521 /* Run commands received from standard input
3523 if( stdin_is_interactive ){
3528 "SQLite version %s %.19s\n" /*extra-version-info*/
3529 "Enter \".help\" for instructions\n"
3530 "Enter SQL statements terminated with a \";\"\n",
3531 sqlite3_libversion(), sqlite3_sourceid()
3533 zHome = find_home_dir();
3535 nHistory = strlen30(zHome) + 20;
3536 if( (zHistory = malloc(nHistory))!=0 ){
3537 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
3540 #if defined(HAVE_READLINE) && HAVE_READLINE==1
3541 if( zHistory ) read_history(zHistory);
3543 rc = process_input(&data, 0);
3545 stifle_history(100);
3546 write_history(zHistory);
3550 rc = process_input(&data, stdin);
3553 set_table_name(&data, 0);
3555 sqlite3_close(data.db);
3557 sqlite3_free(data.zFreeOnClose);