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 readline(p) local_getline(p,stdin,0)
57 # define add_history(X)
58 # define read_history(X)
59 # define write_history(X)
60 # define stifle_history(X)
63 #if defined(_WIN32) || defined(WIN32)
65 #define isatty(h) _isatty(h)
66 #define access(f,m) _access((f),(m))
68 #define popen(a,b) _popen((a),(b))
70 #define pclose(x) _pclose(x)
72 /* Make sure isatty() has a prototype.
74 extern int isatty(int);
77 #if defined(_WIN32_WCE)
78 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
79 * thus we always assume that we have a console. That can be
80 * overridden with the -batch command line option.
85 /* True if the timer is enabled */
86 static int enableTimer = 0;
88 /* ctype macros that work with signed characters */
89 #define IsSpace(X) isspace((unsigned char)X)
90 #define IsDigit(X) isdigit((unsigned char)X)
91 #define ToLower(X) (char)tolower((unsigned char)X)
93 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL)
95 #include <sys/resource.h>
97 /* Saved resource information for the beginning of an operation */
98 static struct rusage sBegin;
101 ** Begin timing an operation
103 static void beginTimer(void){
105 getrusage(RUSAGE_SELF, &sBegin);
109 /* Return the difference of two time_structs in seconds */
110 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
111 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
112 (double)(pEnd->tv_sec - pStart->tv_sec);
116 ** Print the timing results.
118 static void endTimer(void){
121 getrusage(RUSAGE_SELF, &sEnd);
122 printf("CPU Time: user %f sys %f\n",
123 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
124 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
128 #define BEGIN_TIMER beginTimer()
129 #define END_TIMER endTimer()
132 #elif (defined(_WIN32) || defined(WIN32))
136 /* Saved resource information for the beginning of an operation */
137 static HANDLE hProcess;
138 static FILETIME ftKernelBegin;
139 static FILETIME ftUserBegin;
140 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
141 static GETPROCTIMES getProcessTimesAddr = NULL;
144 ** Check to see if we have timer support. Return 1 if necessary
145 ** support found (or found previously).
147 static int hasTimer(void){
148 if( getProcessTimesAddr ){
151 /* GetProcessTimes() isn't supported in WIN95 and some other Windows versions.
152 ** See if the version we are running on has it, and if it does, save off
153 ** a pointer to it and the current process handle.
155 hProcess = GetCurrentProcess();
157 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
158 if( NULL != hinstLib ){
159 getProcessTimesAddr = (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
160 if( NULL != getProcessTimesAddr ){
163 FreeLibrary(hinstLib);
171 ** Begin timing an operation
173 static void beginTimer(void){
174 if( enableTimer && getProcessTimesAddr ){
175 FILETIME ftCreation, ftExit;
176 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin);
180 /* Return the difference of two FILETIME structs in seconds */
181 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
182 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
183 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
184 return (double) ((i64End - i64Start) / 10000000.0);
188 ** Print the timing results.
190 static void endTimer(void){
191 if( enableTimer && getProcessTimesAddr){
192 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
193 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd);
194 printf("CPU Time: user %f sys %f\n",
195 timeDiff(&ftUserBegin, &ftUserEnd),
196 timeDiff(&ftKernelBegin, &ftKernelEnd));
200 #define BEGIN_TIMER beginTimer()
201 #define END_TIMER endTimer()
202 #define HAS_TIMER hasTimer()
211 ** Used to prevent warnings about unused parameters
213 #define UNUSED_PARAMETER(x) (void)(x)
216 ** If the following flag is set, then command execution stops
217 ** at an error if we are not interactive.
219 static int bail_on_error = 0;
222 ** Threat stdin as an interactive input if the following variable
223 ** is true. Otherwise, assume stdin is connected to a file or pipe.
225 static int stdin_is_interactive = 1;
228 ** The following is the open SQLite database. We make a pointer
229 ** to this database a static variable so that it can be accessed
230 ** by the SIGINT handler to interrupt database processing.
232 static sqlite3 *db = 0;
235 ** True if an interrupt (Control-C) has been received.
237 static volatile int seenInterrupt = 0;
240 ** This is the name of our program. It is set in main(), used
241 ** in a number of other places, mostly for error messages.
246 ** Prompt strings. Initialized in main. Settable with
247 ** .prompt main continue
249 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
250 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
253 ** Write I/O traces to the following stream.
255 #ifdef SQLITE_ENABLE_IOTRACE
256 static FILE *iotrace = 0;
260 ** This routine works like printf in that its first argument is a
261 ** format string and subsequent arguments are values to be substituted
262 ** in place of % fields. The result of formatting this string
263 ** is written to iotrace.
265 #ifdef SQLITE_ENABLE_IOTRACE
266 static void iotracePrintf(const char *zFormat, ...){
269 if( iotrace==0 ) return;
270 va_start(ap, zFormat);
271 z = sqlite3_vmprintf(zFormat, ap);
273 fprintf(iotrace, "%s", z);
280 ** Determines if a string is a number of not.
282 static int isNumber(const char *z, int *realnum){
283 if( *z=='-' || *z=='+' ) z++;
288 if( realnum ) *realnum = 0;
289 while( IsDigit(*z) ){ z++; }
292 if( !IsDigit(*z) ) return 0;
293 while( IsDigit(*z) ){ z++; }
294 if( realnum ) *realnum = 1;
296 if( *z=='e' || *z=='E' ){
298 if( *z=='+' || *z=='-' ) z++;
299 if( !IsDigit(*z) ) return 0;
300 while( IsDigit(*z) ){ z++; }
301 if( realnum ) *realnum = 1;
307 ** A global char* and an SQL function to access its current value
308 ** from within an SQL statement. This program used to use the
309 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
310 ** The correct way to do this with sqlite3 is to use the bind API, but
311 ** since the shell is built around the callback paradigm it would be a lot
312 ** of work. Instead just use this hack, which is quite harmless.
314 static const char *zShellStatic = 0;
315 static void shellstaticFunc(
316 sqlite3_context *context,
321 assert( zShellStatic );
322 UNUSED_PARAMETER(argc);
323 UNUSED_PARAMETER(argv);
324 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
329 ** This routine reads a line of text from FILE in, stores
330 ** the text in memory obtained from malloc() and returns a pointer
331 ** to the text. NULL is returned at end of file, or if malloc()
334 ** The interface is like "readline" but no command-line editing
337 static char *local_getline(char *zPrompt, FILE *in, int csvFlag){
343 if( zPrompt && *zPrompt ){
344 printf("%s",zPrompt);
348 zLine = malloc( nLine );
349 if( zLine==0 ) return 0;
353 nLine = nLine*2 + 100;
354 zLine = realloc(zLine, nLine);
355 if( zLine==0 ) return 0;
357 if( fgets(&zLine[n], nLine - n, in)==0 ){
366 if( zLine[n]=='"' ) inQuote = !inQuote;
369 if( n>0 && zLine[n-1]=='\n' && (!inQuote || !csvFlag) ){
371 if( n>0 && zLine[n-1]=='\r' ) n--;
376 zLine = realloc( zLine, n+1 );
381 ** Retrieve a single line of input text.
383 ** zPrior is a string of prior text retrieved. If not the empty
384 ** string, then issue a continuation prompt.
386 static char *one_input_line(const char *zPrior, FILE *in){
390 return local_getline(0, in, 0);
392 if( zPrior && zPrior[0] ){
393 zPrompt = continuePrompt;
395 zPrompt = mainPrompt;
397 zResult = readline(zPrompt);
398 #if defined(HAVE_READLINE) && HAVE_READLINE==1
399 if( zResult && *zResult ) add_history(zResult);
404 struct previous_mode_data {
405 int valid; /* Is there legit data in here? */
412 ** An pointer to an instance of this structure is passed from
413 ** the main program to the callback. This is used to communicate
414 ** state and mode information.
416 struct callback_data {
417 sqlite3 *db; /* The database */
418 int echoOn; /* True to echo input commands */
419 int statsOn; /* True to display memory stats before each finalize */
420 int cnt; /* Number of records displayed so far */
421 FILE *out; /* Write results here */
422 FILE *traceOut; /* Output for sqlite3_trace() */
423 int nErr; /* Number of errors seen */
424 int mode; /* An output mode setting */
425 int writableSchema; /* True if PRAGMA writable_schema=ON */
426 int showHeader; /* True to show column names in List or Column mode */
427 char *zDestTable; /* Name of destination table when MODE_Insert */
428 char separator[20]; /* Separator character for MODE_List */
429 int colWidth[100]; /* Requested width of each column when in column mode*/
430 int actualWidth[100]; /* Actual width of each column */
431 char nullvalue[20]; /* The text to print when a NULL comes back from
433 struct previous_mode_data explainPrev;
434 /* Holds the mode information just before
436 char outfile[FILENAME_MAX]; /* Filename for *out */
437 const char *zDbFilename; /* name of the database file */
438 const char *zVfs; /* Name of VFS to use */
439 sqlite3_stmt *pStmt; /* Current statement if any. */
440 FILE *pLog; /* Write log output here */
444 ** These are the allowed modes.
446 #define MODE_Line 0 /* One column per line. Blank line between records */
447 #define MODE_Column 1 /* One record per line in neat columns */
448 #define MODE_List 2 /* One record per line with a separator */
449 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
450 #define MODE_Html 4 /* Generate an XHTML table */
451 #define MODE_Insert 5 /* Generate SQL "insert" statements */
452 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
453 #define MODE_Csv 7 /* Quote strings, numbers are plain */
454 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
456 static const char *modeDescr[] = {
469 ** Number of elements in an array
471 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
474 ** Compute a string length that is limited to what can be stored in
475 ** lower 30 bits of a 32-bit signed integer.
477 static int strlen30(const char *z){
479 while( *z2 ){ z2++; }
480 return 0x3fffffff & (int)(z2 - z);
484 ** A callback for the sqlite3_log() interface.
486 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
487 struct callback_data *p = (struct callback_data*)pArg;
488 if( p->pLog==0 ) return;
489 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
494 ** Output the given string as a hex-encoded blob (eg. X'1234' )
496 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
498 char *zBlob = (char *)pBlob;
500 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
505 ** Output the given string as a quoted string using SQL quoting conventions.
507 static void output_quoted_string(FILE *out, const char *z){
511 if( z[i]=='\'' ) nSingle++;
514 fprintf(out,"'%s'",z);
518 for(i=0; z[i] && z[i]!='\''; i++){}
522 }else if( z[i]=='\'' ){
523 fprintf(out,"%.*s''",i,z);
535 ** Output the given string as a quoted according to C or TCL quoting rules.
537 static void output_c_string(FILE *out, const char *z){
540 while( (c = *(z++))!=0 ){
556 }else if( !isprint(c) ){
557 fprintf(out, "\\%03o", c&0xff);
566 ** Output the given string with characters that are special to
569 static void output_html_string(FILE *out, const char *z){
580 fprintf(out,"%.*s",i,z);
584 }else if( z[i]=='&' ){
585 fprintf(out,"&");
586 }else if( z[i]=='>' ){
588 }else if( z[i]=='\"' ){
589 fprintf(out,""");
590 }else if( z[i]=='\'' ){
591 fprintf(out,"'");
600 ** If a field contains any character identified by a 1 in the following
601 ** array, then the string must be quoted for CSV.
603 static const char needCsvQuote[] = {
604 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
605 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
606 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
607 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
608 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
609 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
610 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
611 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
612 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
613 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
614 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
615 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
616 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
617 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
618 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
619 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
623 ** Output a single term of CSV. Actually, p->separator is used for
624 ** the separator, which may or may not be a comma. p->nullvalue is
625 ** the null value. Strings are quoted if necessary.
627 static void output_csv(struct callback_data *p, const char *z, int bSep){
630 fprintf(out,"%s",p->nullvalue);
633 int nSep = strlen30(p->separator);
635 if( needCsvQuote[((unsigned char*)z)[i]]
636 || (z[i]==p->separator[0] &&
637 (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
645 if( z[i]=='"' ) putc('"', out);
650 fprintf(out, "%s", z);
654 fprintf(p->out, "%s", p->separator);
660 ** This routine runs when the user presses Ctrl-C
662 static void interrupt_handler(int NotUsed){
663 UNUSED_PARAMETER(NotUsed);
665 if( db ) sqlite3_interrupt(db);
670 ** This is the callback routine that the shell
671 ** invokes for each row of a query result.
673 static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){
675 struct callback_data *p = (struct callback_data*)pArg;
680 if( azArg==0 ) break;
681 for(i=0; i<nArg; i++){
682 int len = strlen30(azCol[i] ? azCol[i] : "");
685 if( p->cnt++>0 ) fprintf(p->out,"\n");
686 for(i=0; i<nArg; i++){
687 fprintf(p->out,"%*s = %s\n", w, azCol[i],
688 azArg[i] ? azArg[i] : p->nullvalue);
695 for(i=0; i<nArg; i++){
697 if( i<ArraySize(p->colWidth) ){
703 w = strlen30(azCol[i] ? azCol[i] : "");
705 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);
708 if( i<ArraySize(p->actualWidth) ){
709 p->actualWidth[i] = w;
713 fprintf(p->out,"%*.*s%s",-w,-w,azCol[i], i==nArg-1 ? "\n": " ");
715 fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " ");
720 for(i=0; i<nArg; i++){
722 if( i<ArraySize(p->actualWidth) ){
723 w = p->actualWidth[i];
728 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
729 "----------------------------------------------------------",
730 i==nArg-1 ? "\n": " ");
734 if( azArg==0 ) break;
735 for(i=0; i<nArg; i++){
737 if( i<ArraySize(p->actualWidth) ){
738 w = p->actualWidth[i];
742 if( p->mode==MODE_Explain && azArg[i] &&
743 strlen30(azArg[i])>w ){
744 w = strlen30(azArg[i]);
747 fprintf(p->out,"%*.*s%s",-w,-w,
748 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
750 fprintf(p->out,"%-*.*s%s",w,w,
751 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
758 if( p->cnt++==0 && p->showHeader ){
759 for(i=0; i<nArg; i++){
760 fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
763 if( azArg==0 ) break;
764 for(i=0; i<nArg; i++){
766 if( z==0 ) z = p->nullvalue;
767 fprintf(p->out, "%s", z);
769 fprintf(p->out, "%s", p->separator);
770 }else if( p->mode==MODE_Semi ){
771 fprintf(p->out, ";\n");
773 fprintf(p->out, "\n");
779 if( p->cnt++==0 && p->showHeader ){
780 fprintf(p->out,"<TR>");
781 for(i=0; i<nArg; i++){
782 fprintf(p->out,"<TH>");
783 output_html_string(p->out, azCol[i]);
784 fprintf(p->out,"</TH>\n");
786 fprintf(p->out,"</TR>\n");
788 if( azArg==0 ) break;
789 fprintf(p->out,"<TR>");
790 for(i=0; i<nArg; i++){
791 fprintf(p->out,"<TD>");
792 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
793 fprintf(p->out,"</TD>\n");
795 fprintf(p->out,"</TR>\n");
799 if( p->cnt++==0 && p->showHeader ){
800 for(i=0; i<nArg; i++){
801 output_c_string(p->out,azCol[i] ? azCol[i] : "");
802 if(i<nArg-1) fprintf(p->out, "%s", p->separator);
804 fprintf(p->out,"\n");
806 if( azArg==0 ) break;
807 for(i=0; i<nArg; i++){
808 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
809 if(i<nArg-1) fprintf(p->out, "%s", p->separator);
811 fprintf(p->out,"\n");
815 if( p->cnt++==0 && p->showHeader ){
816 for(i=0; i<nArg; i++){
817 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
819 fprintf(p->out,"\n");
821 if( azArg==0 ) break;
822 for(i=0; i<nArg; i++){
823 output_csv(p, azArg[i], i<nArg-1);
825 fprintf(p->out,"\n");
830 if( azArg==0 ) break;
831 fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
832 for(i=0; i<nArg; i++){
833 char *zSep = i>0 ? ",": "";
834 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
835 fprintf(p->out,"%sNULL",zSep);
836 }else if( aiType && aiType[i]==SQLITE_TEXT ){
837 if( zSep[0] ) fprintf(p->out,"%s",zSep);
838 output_quoted_string(p->out, azArg[i]);
839 }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){
840 fprintf(p->out,"%s%s",zSep, azArg[i]);
841 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
842 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
843 int nBlob = sqlite3_column_bytes(p->pStmt, i);
844 if( zSep[0] ) fprintf(p->out,"%s",zSep);
845 output_hex_blob(p->out, pBlob, nBlob);
846 }else if( isNumber(azArg[i], 0) ){
847 fprintf(p->out,"%s%s",zSep, azArg[i]);
849 if( zSep[0] ) fprintf(p->out,"%s",zSep);
850 output_quoted_string(p->out, azArg[i]);
853 fprintf(p->out,");\n");
861 ** This is the callback routine that the SQLite library
862 ** invokes for each row of a query result.
864 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
865 /* since we don't have type info, call the shell_callback with a NULL value */
866 return shell_callback(pArg, nArg, azArg, azCol, NULL);
870 ** Set the destination table field of the callback_data structure to
871 ** the name of the table given. Escape any quote characters in the
874 static void set_table_name(struct callback_data *p, const char *zName){
883 if( zName==0 ) return;
884 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
885 for(i=n=0; zName[i]; i++, n++){
886 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
888 if( zName[i]=='\'' ) n++;
891 if( needQuote ) n += 2;
892 z = p->zDestTable = malloc( n+1 );
894 fprintf(stderr,"Error: out of memory\n");
898 if( needQuote ) z[n++] = '\'';
899 for(i=0; zName[i]; i++){
901 if( zName[i]=='\'' ) z[n++] = '\'';
903 if( needQuote ) z[n++] = '\'';
907 /* zIn is either a pointer to a NULL-terminated string in memory obtained
908 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
909 ** added to zIn, and the result returned in memory obtained from malloc().
910 ** zIn, if it was not NULL, is freed.
912 ** If the third argument, quote, is not '\0', then it is used as a
913 ** quote character for zAppend.
915 static char *appendText(char *zIn, char const *zAppend, char quote){
918 int nAppend = strlen30(zAppend);
919 int nIn = (zIn?strlen30(zIn):0);
924 for(i=0; i<nAppend; i++){
925 if( zAppend[i]==quote ) len++;
929 zIn = (char *)realloc(zIn, len);
935 char *zCsr = &zIn[nIn];
937 for(i=0; i<nAppend; i++){
938 *zCsr++ = zAppend[i];
939 if( zAppend[i]==quote ) *zCsr++ = quote;
943 assert( (zCsr-zIn)==len );
945 memcpy(&zIn[nIn], zAppend, nAppend);
954 ** Execute a query statement that will generate SQL output. Print
955 ** the result columns, comma-separated, on a line and then add a
956 ** semicolon terminator to the end of that line.
958 ** If the number of columns is 1 and that column contains text "--"
959 ** then write the semicolon on a separate line. That way, if a
960 ** "--" comment occurs at the end of the statement, the comment
961 ** won't consume the semicolon terminator.
963 static int run_table_dump_query(
964 struct callback_data *p, /* Query context */
965 const char *zSelect, /* SELECT statement to extract content */
966 const char *zFirstRow /* Print before first row, if not NULL */
968 sqlite3_stmt *pSelect;
973 rc = sqlite3_prepare(p->db, zSelect, -1, &pSelect, 0);
974 if( rc!=SQLITE_OK || !pSelect ){
975 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
979 rc = sqlite3_step(pSelect);
980 nResult = sqlite3_column_count(pSelect);
981 while( rc==SQLITE_ROW ){
983 fprintf(p->out, "%s", zFirstRow);
986 z = (const char*)sqlite3_column_text(pSelect, 0);
987 fprintf(p->out, "%s", z);
988 for(i=1; i<nResult; i++){
989 fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
992 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
994 fprintf(p->out, "\n;\n");
996 fprintf(p->out, ";\n");
998 rc = sqlite3_step(pSelect);
1000 rc = sqlite3_finalize(pSelect);
1001 if( rc!=SQLITE_OK ){
1002 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1009 ** Allocate space and save off current error string.
1011 static char *save_err_msg(
1012 sqlite3 *db /* Database to query */
1014 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1015 char *zErrMsg = sqlite3_malloc(nErrMsg);
1017 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1023 ** Display memory stats.
1025 static int display_stats(
1026 sqlite3 *db, /* Database to query */
1027 struct callback_data *pArg, /* Pointer to struct callback_data */
1028 int bReset /* True to reset the stats */
1033 if( pArg && pArg->out ){
1036 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1037 fprintf(pArg->out, "Memory Used: %d (max %d) bytes\n", iCur, iHiwtr);
1039 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1040 fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n", iCur, iHiwtr);
1042 ** Not currently used by the CLI.
1043 ** iHiwtr = iCur = -1;
1044 ** sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1045 ** fprintf(pArg->out, "Number of Pcache Pages Used: %d (max %d) pages\n", iCur, iHiwtr);
1048 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1049 fprintf(pArg->out, "Number of Pcache Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
1051 ** Not currently used by the CLI.
1052 ** iHiwtr = iCur = -1;
1053 ** sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1054 ** fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n", iCur, iHiwtr);
1057 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1058 fprintf(pArg->out, "Number of Scratch Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
1060 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1061 fprintf(pArg->out, "Largest Allocation: %d bytes\n", iHiwtr);
1063 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1064 fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n", iHiwtr);
1066 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1067 fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n", iHiwtr);
1068 #ifdef YYTRACKMAXSTACKDEPTH
1070 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1071 fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n", iCur, iHiwtr);
1075 if( pArg && pArg->out && db ){
1077 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHiwtr, bReset);
1078 fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n", iCur, iHiwtr);
1079 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, &iCur, &iHiwtr, bReset);
1080 fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr);
1081 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, &iCur, &iHiwtr, bReset);
1082 fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr);
1083 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, &iCur, &iHiwtr, bReset);
1084 fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr);
1086 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1087 fprintf(pArg->out, "Pager Heap Usage: %d bytes\n", iCur); iHiwtr = iCur = -1;
1088 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1089 fprintf(pArg->out, "Page cache hits: %d\n", iCur);
1091 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1092 fprintf(pArg->out, "Page cache misses: %d\n", iCur);
1094 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1095 fprintf(pArg->out, "Page cache writes: %d\n", iCur);
1097 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1098 fprintf(pArg->out, "Schema Heap Usage: %d bytes\n", iCur);
1100 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1101 fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", iCur);
1104 if( pArg && pArg->out && db && pArg->pStmt ){
1105 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, bReset);
1106 fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1107 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1108 fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1109 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX, bReset);
1110 fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1117 ** Execute a statement or set of statements. Print
1118 ** any result rows/columns depending on the current mode
1119 ** set via the supplied callback.
1121 ** This is very similar to SQLite's built-in sqlite3_exec()
1122 ** function except it takes a slightly different callback
1123 ** and callback data argument.
1125 static int shell_exec(
1126 sqlite3 *db, /* An open database */
1127 const char *zSql, /* SQL to be evaluated */
1128 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1129 /* (not the same as sqlite3_exec) */
1130 struct callback_data *pArg, /* Pointer to struct callback_data */
1131 char **pzErrMsg /* Error msg written here */
1133 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1134 int rc = SQLITE_OK; /* Return Code */
1136 const char *zLeftover; /* Tail of unprocessed SQL */
1142 while( zSql[0] && (SQLITE_OK == rc) ){
1143 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1144 if( SQLITE_OK != rc ){
1146 *pzErrMsg = save_err_msg(db);
1150 /* this happens for a comment or white-space */
1152 while( IsSpace(zSql[0]) ) zSql++;
1156 /* save off the prepared statment handle and reset row count */
1158 pArg->pStmt = pStmt;
1162 /* echo the sql statement if echo on */
1163 if( pArg && pArg->echoOn ){
1164 const char *zStmtSql = sqlite3_sql(pStmt);
1165 fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1168 /* Output TESTCTRL_EXPLAIN text of requested */
1169 if( pArg && pArg->mode==MODE_Explain ){
1170 const char *zExplain = 0;
1171 sqlite3_test_control(SQLITE_TESTCTRL_EXPLAIN_STMT, pStmt, &zExplain);
1172 if( zExplain && zExplain[0] ){
1173 fprintf(pArg->out, "%s", zExplain);
1177 /* perform the first step. this will tell us if we
1178 ** have a result set or not and how wide it is.
1180 rc = sqlite3_step(pStmt);
1181 /* if we have a result set... */
1182 if( SQLITE_ROW == rc ){
1183 /* if we have a callback... */
1185 /* allocate space for col name ptr, value ptr, and type */
1186 int nCol = sqlite3_column_count(pStmt);
1187 void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1191 char **azCols = (char **)pData; /* Names of result columns */
1192 char **azVals = &azCols[nCol]; /* Results */
1193 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1195 assert(sizeof(int) <= sizeof(char *));
1196 /* save off ptrs to column names */
1197 for(i=0; i<nCol; i++){
1198 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1201 /* extract the data and data types */
1202 for(i=0; i<nCol; i++){
1203 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
1204 aiTypes[i] = sqlite3_column_type(pStmt, i);
1205 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1207 break; /* from for */
1211 /* if data and types extracted successfully... */
1212 if( SQLITE_ROW == rc ){
1213 /* call the supplied callback with the result row data */
1214 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1217 rc = sqlite3_step(pStmt);
1220 } while( SQLITE_ROW == rc );
1221 sqlite3_free(pData);
1225 rc = sqlite3_step(pStmt);
1226 } while( rc == SQLITE_ROW );
1230 /* print usage stats if stats on */
1231 if( pArg && pArg->statsOn ){
1232 display_stats(db, pArg, 0);
1235 /* Finalize the statement just executed. If this fails, save a
1236 ** copy of the error message. Otherwise, set zSql to point to the
1237 ** next statement to execute. */
1238 rc2 = sqlite3_finalize(pStmt);
1239 if( rc!=SQLITE_NOMEM ) rc = rc2;
1240 if( rc==SQLITE_OK ){
1242 while( IsSpace(zSql[0]) ) zSql++;
1243 }else if( pzErrMsg ){
1244 *pzErrMsg = save_err_msg(db);
1247 /* clear saved stmt handle */
1259 ** This is a different callback routine used for dumping the database.
1260 ** Each row received by this callback consists of a table name,
1261 ** the table type ("index" or "table") and SQL to create the table.
1262 ** This routine should print text sufficient to recreate the table.
1264 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1269 const char *zPrepStmt = 0;
1270 struct callback_data *p = (struct callback_data *)pArg;
1272 UNUSED_PARAMETER(azCol);
1273 if( nArg!=3 ) return 1;
1278 if( strcmp(zTable, "sqlite_sequence")==0 ){
1279 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1280 }else if( strcmp(zTable, "sqlite_stat1")==0 ){
1281 fprintf(p->out, "ANALYZE sqlite_master;\n");
1282 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1284 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1286 if( !p->writableSchema ){
1287 fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1288 p->writableSchema = 1;
1290 zIns = sqlite3_mprintf(
1291 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1292 "VALUES('table','%q','%q',0,'%q');",
1293 zTable, zTable, zSql);
1294 fprintf(p->out, "%s\n", zIns);
1298 fprintf(p->out, "%s;\n", zSql);
1301 if( strcmp(zType, "table")==0 ){
1302 sqlite3_stmt *pTableInfo = 0;
1304 char *zTableInfo = 0;
1308 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1309 zTableInfo = appendText(zTableInfo, zTable, '"');
1310 zTableInfo = appendText(zTableInfo, ");", 0);
1312 rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1314 if( rc!=SQLITE_OK || !pTableInfo ){
1318 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1319 /* Always quote the table name, even if it appears to be pure ascii,
1320 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1321 zTmp = appendText(zTmp, zTable, '"');
1323 zSelect = appendText(zSelect, zTmp, '\'');
1326 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1327 rc = sqlite3_step(pTableInfo);
1328 while( rc==SQLITE_ROW ){
1329 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1330 zSelect = appendText(zSelect, "quote(", 0);
1331 zSelect = appendText(zSelect, zText, '"');
1332 rc = sqlite3_step(pTableInfo);
1333 if( rc==SQLITE_ROW ){
1334 zSelect = appendText(zSelect, "), ", 0);
1336 zSelect = appendText(zSelect, ") ", 0);
1340 rc = sqlite3_finalize(pTableInfo);
1341 if( rc!=SQLITE_OK || nRow==0 ){
1345 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1346 zSelect = appendText(zSelect, zTable, '"');
1348 rc = run_table_dump_query(p, zSelect, zPrepStmt);
1349 if( rc==SQLITE_CORRUPT ){
1350 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1351 run_table_dump_query(p, zSelect, 0);
1359 ** Run zQuery. Use dump_callback() as the callback routine so that
1360 ** the contents of the query are output as SQL statements.
1362 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1363 ** "ORDER BY rowid DESC" to the end.
1365 static int run_schema_dump_query(
1366 struct callback_data *p,
1371 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1372 if( rc==SQLITE_CORRUPT ){
1374 int len = strlen30(zQuery);
1375 fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1377 fprintf(p->out, "/****** %s ******/\n", zErr);
1381 zQ2 = malloc( len+100 );
1382 if( zQ2==0 ) return rc;
1383 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1384 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1386 fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1388 rc = SQLITE_CORRUPT;
1397 ** Text of a help message
1399 static char zHelp[] =
1400 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1401 ".bail ON|OFF Stop after hitting an error. Default OFF\n"
1402 ".databases List names and files of attached databases\n"
1403 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1404 " If TABLE specified, only dump tables matching\n"
1405 " LIKE pattern TABLE.\n"
1406 ".echo ON|OFF Turn command echo on or off\n"
1407 ".exit Exit this program\n"
1408 ".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.\n"
1409 " With no args, it turns EXPLAIN on.\n"
1410 ".header(s) ON|OFF Turn display of headers on or off\n"
1411 ".help Show this message\n"
1412 ".import FILE TABLE Import data from FILE into TABLE\n"
1413 ".indices ?TABLE? Show names of all indices\n"
1414 " If TABLE specified, only show indices for tables\n"
1415 " matching LIKE pattern TABLE.\n"
1416 #ifdef SQLITE_ENABLE_IOTRACE
1417 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1419 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1420 ".load FILE ?ENTRY? Load an extension library\n"
1422 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1423 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1424 " csv Comma-separated values\n"
1425 " column Left-aligned columns. (See .width)\n"
1426 " html HTML <table> code\n"
1427 " insert SQL insert statements for TABLE\n"
1428 " line One value per line\n"
1429 " list Values delimited by .separator string\n"
1430 " tabs Tab-separated values\n"
1431 " tcl TCL list elements\n"
1432 ".nullvalue STRING Use STRING in place of NULL values\n"
1433 ".output FILENAME Send output to FILENAME\n"
1434 ".output stdout Send output to the screen\n"
1435 ".print STRING... Print literal STRING\n"
1436 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1437 ".quit Exit this program\n"
1438 ".read FILENAME Execute SQL in FILENAME\n"
1439 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1440 ".schema ?TABLE? Show the CREATE statements\n"
1441 " If TABLE specified, only show tables matching\n"
1442 " LIKE pattern TABLE.\n"
1443 ".separator STRING Change separator used by output mode and .import\n"
1444 ".show Show the current values for various settings\n"
1445 ".stats ON|OFF Turn stats on or off\n"
1446 ".tables ?TABLE? List names of tables\n"
1447 " If TABLE specified, only list tables matching\n"
1448 " LIKE pattern TABLE.\n"
1449 ".timeout MS Try opening locked tables for MS milliseconds\n"
1450 ".trace FILE|off Output each SQL statement as it is run\n"
1451 ".vfsname ?AUX? Print the name of the VFS stack\n"
1452 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1455 static char zTimerHelp[] =
1456 ".timer ON|OFF Turn the CPU timer measurement on or off\n"
1459 /* Forward reference */
1460 static int process_input(struct callback_data *p, FILE *in);
1463 ** Make sure the database is open. If it is not, then open it. If
1464 ** the database fails to open, print an error message and exit.
1466 static void open_db(struct callback_data *p){
1468 sqlite3_initialize();
1469 sqlite3_open(p->zDbFilename, &p->db);
1471 if( db && sqlite3_errcode(db)==SQLITE_OK ){
1472 sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1473 shellstaticFunc, 0, 0);
1475 if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1476 fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1477 p->zDbFilename, sqlite3_errmsg(db));
1480 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1481 sqlite3_enable_load_extension(p->db, 1);
1487 ** Do C-language style dequoting.
1491 ** \r -> carriage return
1492 ** \NNN -> ascii character NNN in octal
1495 static void resolve_backslashes(char *z){
1498 for(i=j=0; (c = z[i])!=0; i++, j++){
1507 }else if( c>='0' && c<='7' ){
1509 if( z[i+1]>='0' && z[i+1]<='7' ){
1511 c = (c<<3) + z[i] - '0';
1512 if( z[i+1]>='0' && z[i+1]<='7' ){
1514 c = (c<<3) + z[i] - '0';
1525 ** Interpret zArg as a boolean value. Return either 0 or 1.
1527 static int booleanValue(char *zArg){
1528 int val = atoi(zArg);
1530 for(j=0; zArg[j]; j++){
1531 zArg[j] = ToLower(zArg[j]);
1533 if( strcmp(zArg,"on")==0 ){
1535 }else if( strcmp(zArg,"yes")==0 ){
1542 ** Close an output file, assuming it is not stderr or stdout
1544 static void output_file_close(FILE *f){
1545 if( f && f!=stdout && f!=stderr ) fclose(f);
1549 ** Try to open an output file. The names "stdout" and "stderr" are
1550 ** recognized and do the right thing. NULL is returned if the output
1551 ** filename is "off".
1553 static FILE *output_file_open(const char *zFile){
1555 if( strcmp(zFile,"stdout")==0 ){
1557 }else if( strcmp(zFile, "stderr")==0 ){
1559 }else if( strcmp(zFile, "off")==0 ){
1562 f = fopen(zFile, "wb");
1564 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1571 ** A routine for handling output from sqlite3_trace().
1573 static void sql_trace_callback(void *pArg, const char *z){
1574 FILE *f = (FILE*)pArg;
1575 if( f ) fprintf(f, "%s\n", z);
1579 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
1580 ** a useful spot to set a debugger breakpoint.
1582 static void test_breakpoint(void){
1583 static int nCall = 0;
1588 ** If an input line begins with "." then invoke this routine to
1589 ** process that line.
1591 ** Return 1 on error, 2 to exit, and 0 otherwise.
1593 static int do_meta_command(char *zLine, struct callback_data *p){
1600 /* Parse the input line into tokens.
1602 while( zLine[i] && nArg<ArraySize(azArg) ){
1603 while( IsSpace(zLine[i]) ){ i++; }
1604 if( zLine[i]==0 ) break;
1605 if( zLine[i]=='\'' || zLine[i]=='"' ){
1606 int delim = zLine[i++];
1607 azArg[nArg++] = &zLine[i];
1608 while( zLine[i] && zLine[i]!=delim ){ i++; }
1609 if( zLine[i]==delim ){
1612 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1614 azArg[nArg++] = &zLine[i];
1615 while( zLine[i] && !IsSpace(zLine[i]) ){ i++; }
1616 if( zLine[i] ) zLine[i++] = 0;
1617 resolve_backslashes(azArg[nArg-1]);
1621 /* Process the input line.
1623 if( nArg==0 ) return 0; /* no tokens, no error */
1624 n = strlen30(azArg[0]);
1626 if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 && nArg>1 && nArg<4){
1627 const char *zDestFile;
1630 sqlite3_backup *pBackup;
1632 zDestFile = azArg[1];
1635 zDestFile = azArg[2];
1638 rc = sqlite3_open(zDestFile, &pDest);
1639 if( rc!=SQLITE_OK ){
1640 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
1641 sqlite3_close(pDest);
1645 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
1647 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1648 sqlite3_close(pDest);
1651 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
1652 sqlite3_backup_finish(pBackup);
1653 if( rc==SQLITE_DONE ){
1656 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1659 sqlite3_close(pDest);
1662 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){
1663 bail_on_error = booleanValue(azArg[1]);
1666 /* The undocumented ".breakpoint" command causes a call to the no-op
1667 ** routine named test_breakpoint().
1669 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
1673 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
1674 struct callback_data data;
1677 memcpy(&data, p, sizeof(data));
1678 data.showHeader = 1;
1679 data.mode = MODE_Column;
1680 data.colWidth[0] = 3;
1681 data.colWidth[1] = 15;
1682 data.colWidth[2] = 58;
1684 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
1686 fprintf(stderr,"Error: %s\n", zErrMsg);
1687 sqlite3_free(zErrMsg);
1692 if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
1694 /* When playing back a "dump", the content might appear in an order
1695 ** which causes immediate foreign key constraints to be violated.
1696 ** So disable foreign-key constraint enforcement to prevent problems. */
1697 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
1698 fprintf(p->out, "BEGIN TRANSACTION;\n");
1699 p->writableSchema = 0;
1700 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
1703 run_schema_dump_query(p,
1704 "SELECT name, type, sql FROM sqlite_master "
1705 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
1707 run_schema_dump_query(p,
1708 "SELECT name, type, sql FROM sqlite_master "
1709 "WHERE name=='sqlite_sequence'"
1711 run_table_dump_query(p,
1712 "SELECT sql FROM sqlite_master "
1713 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
1717 for(i=1; i<nArg; i++){
1718 zShellStatic = azArg[i];
1719 run_schema_dump_query(p,
1720 "SELECT name, type, sql FROM sqlite_master "
1721 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
1722 " AND sql NOT NULL");
1723 run_table_dump_query(p,
1724 "SELECT sql FROM sqlite_master "
1725 "WHERE sql NOT NULL"
1726 " AND type IN ('index','trigger','view')"
1727 " AND tbl_name LIKE shellstatic()", 0
1732 if( p->writableSchema ){
1733 fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
1734 p->writableSchema = 0;
1736 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
1737 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
1738 fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
1741 if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){
1742 p->echoOn = booleanValue(azArg[1]);
1745 if( c=='e' && strncmp(azArg[0], "exit", n)==0 && nArg==1 ){
1749 if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){
1750 int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
1752 if(!p->explainPrev.valid) {
1753 p->explainPrev.valid = 1;
1754 p->explainPrev.mode = p->mode;
1755 p->explainPrev.showHeader = p->showHeader;
1756 memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
1758 /* We could put this code under the !p->explainValid
1759 ** condition so that it does not execute if we are already in
1760 ** explain mode. However, always executing it allows us an easy
1761 ** was to reset to explain mode in case the user previously
1762 ** did an .explain followed by a .width, .mode or .header
1765 p->mode = MODE_Explain;
1767 memset(p->colWidth,0,ArraySize(p->colWidth));
1768 p->colWidth[0] = 4; /* addr */
1769 p->colWidth[1] = 13; /* opcode */
1770 p->colWidth[2] = 4; /* P1 */
1771 p->colWidth[3] = 4; /* P2 */
1772 p->colWidth[4] = 4; /* P3 */
1773 p->colWidth[5] = 13; /* P4 */
1774 p->colWidth[6] = 2; /* P5 */
1775 p->colWidth[7] = 13; /* Comment */
1776 }else if (p->explainPrev.valid) {
1777 p->explainPrev.valid = 0;
1778 p->mode = p->explainPrev.mode;
1779 p->showHeader = p->explainPrev.showHeader;
1780 memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
1784 if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
1785 strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){
1786 p->showHeader = booleanValue(azArg[1]);
1789 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1790 fprintf(stderr,"%s",zHelp);
1792 fprintf(stderr,"%s",zTimerHelp);
1796 if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1797 char *zTable = azArg[2]; /* Insert data into this table */
1798 char *zFile = azArg[1]; /* The file from which to extract data */
1799 sqlite3_stmt *pStmt = NULL; /* A statement */
1800 int nCol; /* Number of columns in the table */
1801 int nByte; /* Number of bytes in an SQL string */
1802 int i, j; /* Loop counters */
1803 int nSep; /* Number of bytes in p->separator[] */
1804 char *zSql; /* An SQL statement */
1805 char *zLine; /* A single line of input from the file */
1806 char **azCol; /* zLine[] broken up into columns */
1807 char *zCommit; /* How to commit changes */
1808 FILE *in; /* The input file */
1809 int lineno = 0; /* Line number of input file */
1812 nSep = strlen30(p->separator);
1814 fprintf(stderr, "Error: non-null separator required for import\n");
1817 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
1819 fprintf(stderr, "Error: out of memory\n");
1822 nByte = strlen30(zSql);
1823 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1826 if (pStmt) sqlite3_finalize(pStmt);
1827 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1830 nCol = sqlite3_column_count(pStmt);
1831 sqlite3_finalize(pStmt);
1833 if( nCol==0 ) return 0; /* no columns, no error */
1834 zSql = malloc( nByte + 20 + nCol*2 );
1836 fprintf(stderr, "Error: out of memory\n");
1839 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO %s VALUES(?", zTable);
1841 for(i=1; i<nCol; i++){
1847 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1850 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
1851 if (pStmt) sqlite3_finalize(pStmt);
1854 in = fopen(zFile, "rb");
1856 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1857 sqlite3_finalize(pStmt);
1860 azCol = malloc( sizeof(azCol[0])*(nCol+1) );
1862 fprintf(stderr, "Error: out of memory\n");
1864 sqlite3_finalize(pStmt);
1867 sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
1869 while( (zLine = local_getline(0, in, 1))!=0 ){
1874 for(i=0, z=zLine; (c = *z)!=0; z++){
1875 if( c=='"' ) inQuote = !inQuote;
1876 if( c=='\n' ) lineno++;
1877 if( !inQuote && c==p->separator[0] && strncmp(z,p->separator,nSep)==0 ){
1881 azCol[i] = &z[nSep];
1889 "Error: %s line %d: expected %d columns of data but found %d\n",
1890 zFile, lineno, nCol, i+1);
1891 zCommit = "ROLLBACK";
1894 break; /* from while */
1896 for(i=0; i<nCol; i++){
1897 if( azCol[i][0]=='"' ){
1899 for(z=azCol[i], j=1, k=0; z[j]; j++){
1900 if( z[j]=='"' ){ j++; if( z[j]==0 ) break; }
1905 sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
1907 sqlite3_step(pStmt);
1908 rc = sqlite3_reset(pStmt);
1910 if( rc!=SQLITE_OK ){
1911 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1912 zCommit = "ROLLBACK";
1914 break; /* from while */
1919 sqlite3_finalize(pStmt);
1920 sqlite3_exec(p->db, zCommit, 0, 0, 0);
1923 if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){
1924 struct callback_data data;
1927 memcpy(&data, p, sizeof(data));
1928 data.showHeader = 0;
1929 data.mode = MODE_List;
1931 rc = sqlite3_exec(p->db,
1932 "SELECT name FROM sqlite_master "
1933 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
1935 "SELECT name FROM sqlite_temp_master "
1936 "WHERE type='index' "
1938 callback, &data, &zErrMsg
1941 zShellStatic = azArg[1];
1942 rc = sqlite3_exec(p->db,
1943 "SELECT name FROM sqlite_master "
1944 "WHERE type='index' AND tbl_name LIKE shellstatic() "
1946 "SELECT name FROM sqlite_temp_master "
1947 "WHERE type='index' AND tbl_name LIKE shellstatic() "
1949 callback, &data, &zErrMsg
1954 fprintf(stderr,"Error: %s\n", zErrMsg);
1955 sqlite3_free(zErrMsg);
1957 }else if( rc != SQLITE_OK ){
1958 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
1963 #ifdef SQLITE_ENABLE_IOTRACE
1964 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
1965 extern void (*sqlite3IoTrace)(const char*, ...);
1966 if( iotrace && iotrace!=stdout ) fclose(iotrace);
1970 }else if( strcmp(azArg[1], "-")==0 ){
1971 sqlite3IoTrace = iotracePrintf;
1974 iotrace = fopen(azArg[1], "w");
1976 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
1980 sqlite3IoTrace = iotracePrintf;
1986 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1987 if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
1988 const char *zFile, *zProc;
1991 zProc = nArg>=3 ? azArg[2] : 0;
1993 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
1994 if( rc!=SQLITE_OK ){
1995 fprintf(stderr, "Error: %s\n", zErrMsg);
1996 sqlite3_free(zErrMsg);
2002 if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=2 ){
2003 const char *zFile = azArg[1];
2004 output_file_close(p->pLog);
2005 p->pLog = output_file_open(zFile);
2008 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){
2009 int n2 = strlen30(azArg[1]);
2010 if( (n2==4 && strncmp(azArg[1],"line",n2)==0)
2012 (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){
2013 p->mode = MODE_Line;
2014 }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0)
2016 (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){
2017 p->mode = MODE_Column;
2018 }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){
2019 p->mode = MODE_List;
2020 }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){
2021 p->mode = MODE_Html;
2022 }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){
2024 sqlite3_snprintf(sizeof(p->separator), p->separator, " ");
2025 }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){
2027 sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
2028 }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){
2029 p->mode = MODE_List;
2030 sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
2031 }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2032 p->mode = MODE_Insert;
2033 set_table_name(p, "table");
2035 fprintf(stderr,"Error: mode should be one of: "
2036 "column csv html insert line list tabs tcl\n");
2041 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){
2042 int n2 = strlen30(azArg[1]);
2043 if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2044 p->mode = MODE_Insert;
2045 set_table_name(p, azArg[2]);
2047 fprintf(stderr, "Error: invalid arguments: "
2048 " \"%s\". Enter \".help\" for help\n", azArg[2]);
2053 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
2054 sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
2055 "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
2058 if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
2059 if( p->outfile[0]=='|' ){
2062 output_file_close(p->out);
2065 if( azArg[1][0]=='|' ){
2066 p->out = popen(&azArg[1][1], "w");
2068 fprintf(stderr,"Error: cannot open pipe \"%s\"\n", &azArg[1][1]);
2072 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2075 p->out = output_file_open(azArg[1]);
2077 if( strcmp(azArg[1],"off")!=0 ){
2078 fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]);
2083 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2088 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
2090 for(i=1; i<nArg; i++){
2091 if( i>1 ) fprintf(p->out, " ");
2092 fprintf(p->out, "%s", azArg[i]);
2094 fprintf(p->out, "\n");
2097 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
2099 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
2102 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
2106 if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){
2110 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
2111 FILE *alt = fopen(azArg[1], "rb");
2113 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
2116 rc = process_input(p, alt);
2121 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){
2122 const char *zSrcFile;
2125 sqlite3_backup *pBackup;
2129 zSrcFile = azArg[1];
2132 zSrcFile = azArg[2];
2135 rc = sqlite3_open(zSrcFile, &pSrc);
2136 if( rc!=SQLITE_OK ){
2137 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
2138 sqlite3_close(pSrc);
2142 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
2144 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2145 sqlite3_close(pSrc);
2148 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
2149 || rc==SQLITE_BUSY ){
2150 if( rc==SQLITE_BUSY ){
2151 if( nTimeout++ >= 3 ) break;
2155 sqlite3_backup_finish(pBackup);
2156 if( rc==SQLITE_DONE ){
2158 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
2159 fprintf(stderr, "Error: source database is busy\n");
2162 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2165 sqlite3_close(pSrc);
2168 if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){
2169 struct callback_data data;
2172 memcpy(&data, p, sizeof(data));
2173 data.showHeader = 0;
2174 data.mode = MODE_Semi;
2177 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
2178 if( strcmp(azArg[1],"sqlite_master")==0 ){
2179 char *new_argv[2], *new_colv[2];
2180 new_argv[0] = "CREATE TABLE sqlite_master (\n"
2184 " rootpage integer,\n"
2188 new_colv[0] = "sql";
2190 callback(&data, 1, new_argv, new_colv);
2192 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
2193 char *new_argv[2], *new_colv[2];
2194 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
2198 " rootpage integer,\n"
2202 new_colv[0] = "sql";
2204 callback(&data, 1, new_argv, new_colv);
2207 zShellStatic = azArg[1];
2208 rc = sqlite3_exec(p->db,
2210 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2211 " FROM sqlite_master UNION ALL"
2212 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2213 "WHERE lower(tbl_name) LIKE shellstatic()"
2214 " AND type!='meta' AND sql NOTNULL "
2215 "ORDER BY substr(type,2,1), "
2216 " CASE type WHEN 'view' THEN rowid ELSE name END",
2217 callback, &data, &zErrMsg);
2221 rc = sqlite3_exec(p->db,
2223 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2224 " FROM sqlite_master UNION ALL"
2225 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2226 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
2227 "ORDER BY substr(type,2,1),"
2228 " CASE type WHEN 'view' THEN rowid ELSE name END",
2229 callback, &data, &zErrMsg
2233 fprintf(stderr,"Error: %s\n", zErrMsg);
2234 sqlite3_free(zErrMsg);
2236 }else if( rc != SQLITE_OK ){
2237 fprintf(stderr,"Error: querying schema information\n");
2244 if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2245 sqlite3_snprintf(sizeof(p->separator), p->separator,
2246 "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2249 if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){
2251 fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
2252 fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
2253 fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
2254 fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
2255 fprintf(p->out,"%9.9s: ", "nullvalue");
2256 output_c_string(p->out, p->nullvalue);
2257 fprintf(p->out, "\n");
2258 fprintf(p->out,"%9.9s: %s\n","output",
2259 strlen30(p->outfile) ? p->outfile : "stdout");
2260 fprintf(p->out,"%9.9s: ", "separator");
2261 output_c_string(p->out, p->separator);
2262 fprintf(p->out, "\n");
2263 fprintf(p->out,"%9.9s: %s\n","stats", p->statsOn ? "on" : "off");
2264 fprintf(p->out,"%9.9s: ","width");
2265 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
2266 fprintf(p->out,"%d ",p->colWidth[i]);
2268 fprintf(p->out,"\n");
2271 if( c=='s' && strncmp(azArg[0], "stats", n)==0 && nArg>1 && nArg<3 ){
2272 p->statsOn = booleanValue(azArg[1]);
2275 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){
2276 sqlite3_stmt *pStmt;
2282 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
2284 zSql = sqlite3_mprintf(
2285 "SELECT name FROM sqlite_master"
2286 " WHERE type IN ('table','view')"
2287 " AND name NOT LIKE 'sqlite_%%'"
2288 " AND name LIKE ?1");
2289 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2290 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
2291 if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
2292 if( strcmp(zDbName,"temp")==0 ){
2293 zSql = sqlite3_mprintf(
2295 "SELECT 'temp.' || name FROM sqlite_temp_master"
2296 " WHERE type IN ('table','view')"
2297 " AND name NOT LIKE 'sqlite_%%'"
2298 " AND name LIKE ?1", zSql);
2300 zSql = sqlite3_mprintf(
2302 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
2303 " WHERE type IN ('table','view')"
2304 " AND name NOT LIKE 'sqlite_%%'"
2305 " AND name LIKE ?1", zSql, zDbName, zDbName);
2308 sqlite3_finalize(pStmt);
2309 zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
2310 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2316 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
2318 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
2320 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2323 int n = nAlloc*2 + 10;
2324 azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n);
2326 fprintf(stderr, "Error: out of memory\n");
2332 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
2333 if( azResult[nRow] ) nRow++;
2335 sqlite3_finalize(pStmt);
2337 int len, maxlen = 0;
2339 int nPrintCol, nPrintRow;
2340 for(i=0; i<nRow; i++){
2341 len = strlen30(azResult[i]);
2342 if( len>maxlen ) maxlen = len;
2344 nPrintCol = 80/(maxlen+2);
2345 if( nPrintCol<1 ) nPrintCol = 1;
2346 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
2347 for(i=0; i<nPrintRow; i++){
2348 for(j=i; j<nRow; j+=nPrintRow){
2349 char *zSp = j<nPrintRow ? "" : " ";
2350 printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
2355 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
2356 sqlite3_free(azResult);
2359 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
2360 static const struct {
2361 const char *zCtrlName; /* Name of a test-control option */
2362 int ctrlCode; /* Integer code for that option */
2364 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
2365 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
2366 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
2367 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
2368 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
2369 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
2370 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
2371 { "assert", SQLITE_TESTCTRL_ASSERT },
2372 { "always", SQLITE_TESTCTRL_ALWAYS },
2373 { "reserve", SQLITE_TESTCTRL_RESERVE },
2374 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
2375 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
2376 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
2383 /* convert testctrl text option to value. allow any unique prefix
2384 ** of the option name, or a numerical value. */
2385 n = strlen30(azArg[1]);
2386 for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){
2387 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){
2389 testctrl = aCtrl[i].ctrlCode;
2391 fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
2397 if( testctrl<0 ) testctrl = atoi(azArg[1]);
2398 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
2399 fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
2403 /* sqlite3_test_control(int, db, int) */
2404 case SQLITE_TESTCTRL_OPTIMIZATIONS:
2405 case SQLITE_TESTCTRL_RESERVE:
2407 int opt = (int)strtol(azArg[2], 0, 0);
2408 rc = sqlite3_test_control(testctrl, p->db, opt);
2409 printf("%d (0x%08x)\n", rc, rc);
2411 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2416 /* sqlite3_test_control(int) */
2417 case SQLITE_TESTCTRL_PRNG_SAVE:
2418 case SQLITE_TESTCTRL_PRNG_RESTORE:
2419 case SQLITE_TESTCTRL_PRNG_RESET:
2421 rc = sqlite3_test_control(testctrl);
2422 printf("%d (0x%08x)\n", rc, rc);
2424 fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
2428 /* sqlite3_test_control(int, uint) */
2429 case SQLITE_TESTCTRL_PENDING_BYTE:
2431 unsigned int opt = (unsigned int)atoi(azArg[2]);
2432 rc = sqlite3_test_control(testctrl, opt);
2433 printf("%d (0x%08x)\n", rc, rc);
2435 fprintf(stderr,"Error: testctrl %s takes a single unsigned"
2436 " int option\n", azArg[1]);
2440 /* sqlite3_test_control(int, int) */
2441 case SQLITE_TESTCTRL_ASSERT:
2442 case SQLITE_TESTCTRL_ALWAYS:
2444 int opt = atoi(azArg[2]);
2445 rc = sqlite3_test_control(testctrl, opt);
2446 printf("%d (0x%08x)\n", rc, rc);
2448 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2453 /* sqlite3_test_control(int, char *) */
2454 #ifdef SQLITE_N_KEYWORD
2455 case SQLITE_TESTCTRL_ISKEYWORD:
2457 const char *opt = azArg[2];
2458 rc = sqlite3_test_control(testctrl, opt);
2459 printf("%d (0x%08x)\n", rc, rc);
2461 fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
2467 case SQLITE_TESTCTRL_BITVEC_TEST:
2468 case SQLITE_TESTCTRL_FAULT_INSTALL:
2469 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
2470 case SQLITE_TESTCTRL_SCRATCHMALLOC:
2472 fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
2479 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){
2481 sqlite3_busy_timeout(p->db, atoi(azArg[1]));
2484 if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0
2487 enableTimer = booleanValue(azArg[1]);
2490 if( c=='t' && strncmp(azArg[0], "trace", n)==0 && nArg>1 ){
2492 output_file_close(p->traceOut);
2493 p->traceOut = output_file_open(azArg[1]);
2494 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
2495 if( p->traceOut==0 ){
2496 sqlite3_trace(p->db, 0, 0);
2498 sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
2503 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
2504 printf("SQLite %s %s\n" /*extra-version-info*/,
2505 sqlite3_libversion(), sqlite3_sourceid());
2508 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
2509 const char *zDbName = nArg==2 ? azArg[1] : "main";
2512 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
2514 printf("%s\n", zVfsName);
2515 sqlite3_free(zVfsName);
2520 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
2521 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
2522 extern int sqlite3WhereTrace;
2523 sqlite3WhereTrace = atoi(azArg[1]);
2527 if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){
2529 assert( nArg<=ArraySize(azArg) );
2530 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
2531 p->colWidth[j-1] = atoi(azArg[j]);
2536 fprintf(stderr, "Error: unknown command or invalid arguments: "
2537 " \"%s\". Enter \".help\" for help\n", azArg[0]);
2545 ** Return TRUE if a semicolon occurs anywhere in the first N characters
2548 static int _contains_semicolon(const char *z, int N){
2550 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
2555 ** Test to see if a line consists entirely of whitespace.
2557 static int _all_whitespace(const char *z){
2559 if( IsSpace(z[0]) ) continue;
2560 if( *z=='/' && z[1]=='*' ){
2562 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
2563 if( *z==0 ) return 0;
2567 if( *z=='-' && z[1]=='-' ){
2569 while( *z && *z!='\n' ){ z++; }
2570 if( *z==0 ) return 1;
2579 ** Return TRUE if the line typed in is an SQL command terminator other
2580 ** than a semi-colon. The SQL Server style "go" command is understood
2581 ** as is the Oracle "/".
2583 static int _is_command_terminator(const char *zLine){
2584 while( IsSpace(zLine[0]) ){ zLine++; };
2585 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
2586 return 1; /* Oracle */
2588 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
2589 && _all_whitespace(&zLine[2]) ){
2590 return 1; /* SQL Server */
2596 ** Return true if zSql is a complete SQL statement. Return false if it
2597 ** ends in the middle of a string literal or C-style comment.
2599 static int _is_complete(char *zSql, int nSql){
2601 if( zSql==0 ) return 1;
2604 rc = sqlite3_complete(zSql);
2610 ** Read input from *in and process it. If *in==0 then input
2611 ** is interactive - the user is typing it it. Otherwise, input
2612 ** is coming from a file or device. A prompt is issued and history
2613 ** is saved only if input is interactive. An interrupt signal will
2614 ** cause this routine to exit immediately, unless input is interactive.
2616 ** Return the number of errors.
2618 static int process_input(struct callback_data *p, FILE *in){
2629 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
2632 zLine = one_input_line(zSql, in);
2635 if( stdin_is_interactive ) printf("\n");
2638 if( seenInterrupt ){
2643 if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
2644 if( zLine && zLine[0]=='.' && nSql==0 ){
2645 if( p->echoOn ) printf("%s\n", zLine);
2646 rc = do_meta_command(zLine, p);
2647 if( rc==2 ){ /* exit requested */
2654 if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){
2655 memcpy(zLine,";",2);
2660 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
2662 nSql = strlen30(zLine);
2663 zSql = malloc( nSql+3 );
2665 fprintf(stderr, "Error: out of memory\n");
2668 memcpy(zSql, zLine, nSql+1);
2672 int len = strlen30(zLine);
2673 zSql = realloc( zSql, nSql + len + 4 );
2675 fprintf(stderr,"Error: out of memory\n");
2678 zSql[nSql++] = '\n';
2679 memcpy(&zSql[nSql], zLine, len+1);
2682 if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
2683 && sqlite3_complete(zSql) ){
2687 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
2689 if( rc || zErrMsg ){
2691 if( in!=0 || !stdin_is_interactive ){
2692 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
2693 "Error: near line %d:", startline);
2695 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
2698 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
2699 sqlite3_free(zErrMsg);
2702 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
2712 if( !_all_whitespace(zSql) ){
2713 fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
2722 ** Return a pathname which is the user's home directory. A
2723 ** 0 return indicates an error of some kind.
2725 static char *find_home_dir(void){
2726 static char *home_dir = NULL;
2727 if( home_dir ) return home_dir;
2729 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)
2731 struct passwd *pwent;
2732 uid_t uid = getuid();
2733 if( (pwent=getpwuid(uid)) != NULL) {
2734 home_dir = pwent->pw_dir;
2739 #if defined(_WIN32_WCE)
2740 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
2745 #if defined(_WIN32) || defined(WIN32)
2747 home_dir = getenv("USERPROFILE");
2752 home_dir = getenv("HOME");
2755 #if defined(_WIN32) || defined(WIN32)
2757 char *zDrive, *zPath;
2759 zDrive = getenv("HOMEDRIVE");
2760 zPath = getenv("HOMEPATH");
2761 if( zDrive && zPath ){
2762 n = strlen30(zDrive) + strlen30(zPath) + 1;
2763 home_dir = malloc( n );
2764 if( home_dir==0 ) return 0;
2765 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
2772 #endif /* !_WIN32_WCE */
2775 int n = strlen30(home_dir) + 1;
2776 char *z = malloc( n );
2777 if( z ) memcpy(z, home_dir, n);
2785 ** Read input from the file given by sqliterc_override. Or if that
2786 ** parameter is NULL, take input from ~/.sqliterc
2788 ** Returns the number of errors.
2790 static int process_sqliterc(
2791 struct callback_data *p, /* Configuration data */
2792 const char *sqliterc_override /* Name of config file. NULL to use default */
2794 char *home_dir = NULL;
2795 const char *sqliterc = sqliterc_override;
2800 if (sqliterc == NULL) {
2801 home_dir = find_home_dir();
2803 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
2804 fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
2808 sqlite3_initialize();
2809 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
2812 in = fopen(sqliterc,"rb");
2814 if( stdin_is_interactive ){
2815 fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
2817 rc = process_input(p,in);
2825 ** Show available command line options
2827 static const char zOptions[] =
2828 " -bail stop after hitting an error\n"
2829 " -batch force batch I/O\n"
2830 " -column set output mode to 'column'\n"
2831 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
2832 " -csv set output mode to 'csv'\n"
2833 " -echo print commands before execution\n"
2834 " -init FILENAME read/process named file\n"
2835 " -[no]header turn headers on or off\n"
2836 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
2837 " -heap SIZE Size of heap for memsys3 or memsys5\n"
2839 " -help show this message\n"
2840 " -html set output mode to HTML\n"
2841 " -interactive force interactive I/O\n"
2842 " -line set output mode to 'line'\n"
2843 " -list set output mode to 'list'\n"
2844 #ifdef SQLITE_ENABLE_MULTIPLEX
2845 " -multiplex enable the multiplexor VFS\n"
2847 " -nullvalue TEXT set text string for NULL values. Default ''\n"
2848 " -separator SEP set output field separator. Default: '|'\n"
2849 " -stats print memory stats before each finalize\n"
2850 " -version show SQLite version\n"
2851 " -vfs NAME use NAME as the default VFS\n"
2852 #ifdef SQLITE_ENABLE_VFSTRACE
2853 " -vfstrace enable tracing of all VFS calls\n"
2856 static void usage(int showDetail){
2858 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
2859 "FILENAME is the name of an SQLite database. A new database is created\n"
2860 "if the file does not previously exist.\n", Argv0);
2862 fprintf(stderr, "OPTIONS include:\n%s", zOptions);
2864 fprintf(stderr, "Use the -help option for additional information\n");
2870 ** Initialize the state information in data
2872 static void main_init(struct callback_data *data) {
2873 memset(data, 0, sizeof(*data));
2874 data->mode = MODE_List;
2875 memcpy(data->separator,"|", 2);
2876 data->showHeader = 0;
2877 sqlite3_config(SQLITE_CONFIG_URI, 1);
2878 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
2879 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
2880 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
2881 sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
2885 ** Get the argument to an --option. Throw an error and die if no argument
2888 static char *cmdline_option_value(int argc, char **argv, int i){
2890 fprintf(stderr, "%s: Error: missing argument to %s\n",
2891 argv[0], argv[argc-1]);
2897 int main(int argc, char **argv){
2899 struct callback_data data;
2900 const char *zInitFile = 0;
2901 char *zFirstCmd = 0;
2905 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
2906 fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
2907 sqlite3_sourceid(), SQLITE_SOURCE_ID);
2912 stdin_is_interactive = isatty(0);
2914 /* Make sure we have a valid signal handler early, before anything
2918 signal(SIGINT, interrupt_handler);
2921 /* Do an initial pass through the command-line argument to locate
2922 ** the name of the database file, the name of the initialization file,
2923 ** the size of the alternative malloc heap,
2924 ** and the first command to execute.
2926 for(i=1; i<argc; i++){
2930 if( data.zDbFilename==0 ){
2931 data.zDbFilename = z;
2938 fprintf(stderr,"%s: Error: too many options: \"%s\"\n", Argv0, argv[i]);
2939 fprintf(stderr,"Use -help for a list of options.\n");
2942 if( z[1]=='-' ) z++;
2943 if( strcmp(z,"-separator")==0
2944 || strcmp(z,"-nullvalue")==0
2945 || strcmp(z,"-cmd")==0
2947 (void)cmdline_option_value(argc, argv, ++i);
2948 }else if( strcmp(z,"-init")==0 ){
2949 zInitFile = cmdline_option_value(argc, argv, ++i);
2950 }else if( strcmp(z,"-batch")==0 ){
2951 /* Need to check for batch mode here to so we can avoid printing
2952 ** informational messages (like from process_sqliterc) before
2953 ** we do the actual processing of arguments later in a second pass.
2955 stdin_is_interactive = 0;
2956 }else if( strcmp(z,"-heap")==0 ){
2957 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
2960 sqlite3_int64 szHeap;
2962 zSize = cmdline_option_value(argc, argv, ++i);
2963 szHeap = atoi(zSize);
2964 for(j=0; (c = zSize[j])!=0; j++){
2965 if( c=='M' ){ szHeap *= 1000000; break; }
2966 if( c=='K' ){ szHeap *= 1000; break; }
2967 if( c=='G' ){ szHeap *= 1000000000; break; }
2969 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
2970 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
2972 #ifdef SQLITE_ENABLE_VFSTRACE
2973 }else if( strcmp(z,"-vfstrace")==0 ){
2974 extern int vfstrace_register(
2975 const char *zTraceName,
2976 const char *zOldVfsName,
2977 int (*xOut)(const char*,void*),
2981 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
2983 #ifdef SQLITE_ENABLE_MULTIPLEX
2984 }else if( strcmp(z,"-multiplex")==0 ){
2985 extern int sqlite3_multiple_initialize(const char*,int);
2986 sqlite3_multiplex_initialize(0, 1);
2988 }else if( strcmp(z,"-vfs")==0 ){
2989 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
2991 sqlite3_vfs_register(pVfs, 1);
2993 fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
2998 if( data.zDbFilename==0 ){
2999 #ifndef SQLITE_OMIT_MEMORYDB
3000 data.zDbFilename = ":memory:";
3002 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
3008 /* Go ahead and open the database file if it already exists. If the
3009 ** file does not exist, delay opening it. This prevents empty database
3010 ** files from being created if a user mistypes the database name argument
3011 ** to the sqlite command-line tool.
3013 if( access(data.zDbFilename, 0)==0 ){
3017 /* Process the initialization file if there is one. If no -init option
3018 ** is given on the command line, look for a file named ~/.sqliterc and
3019 ** try to process it.
3021 rc = process_sqliterc(&data,zInitFile);
3026 /* Make a second pass through the command-line argument and set
3027 ** options. This second pass is delayed until after the initialization
3028 ** file is processed so that the command-line arguments will override
3029 ** settings in the initialization file.
3031 for(i=1; i<argc; i++){
3033 if( z[0]!='-' ) continue;
3034 if( z[1]=='-' ){ z++; }
3035 if( strcmp(z,"-init")==0 ){
3037 }else if( strcmp(z,"-html")==0 ){
3038 data.mode = MODE_Html;
3039 }else if( strcmp(z,"-list")==0 ){
3040 data.mode = MODE_List;
3041 }else if( strcmp(z,"-line")==0 ){
3042 data.mode = MODE_Line;
3043 }else if( strcmp(z,"-column")==0 ){
3044 data.mode = MODE_Column;
3045 }else if( strcmp(z,"-csv")==0 ){
3046 data.mode = MODE_Csv;
3047 memcpy(data.separator,",",2);
3048 }else if( strcmp(z,"-separator")==0 ){
3049 sqlite3_snprintf(sizeof(data.separator), data.separator,
3050 "%s",cmdline_option_value(argc,argv,++i));
3051 }else if( strcmp(z,"-nullvalue")==0 ){
3052 sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
3053 "%s",cmdline_option_value(argc,argv,++i));
3054 }else if( strcmp(z,"-header")==0 ){
3055 data.showHeader = 1;
3056 }else if( strcmp(z,"-noheader")==0 ){
3057 data.showHeader = 0;
3058 }else if( strcmp(z,"-echo")==0 ){
3060 }else if( strcmp(z,"-stats")==0 ){
3062 }else if( strcmp(z,"-bail")==0 ){
3064 }else if( strcmp(z,"-version")==0 ){
3065 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
3067 }else if( strcmp(z,"-interactive")==0 ){
3068 stdin_is_interactive = 1;
3069 }else if( strcmp(z,"-batch")==0 ){
3070 stdin_is_interactive = 0;
3071 }else if( strcmp(z,"-heap")==0 ){
3073 }else if( strcmp(z,"-vfs")==0 ){
3075 #ifdef SQLITE_ENABLE_VFSTRACE
3076 }else if( strcmp(z,"-vfstrace")==0 ){
3079 #ifdef SQLITE_ENABLE_MULTIPLEX
3080 }else if( strcmp(z,"-multiplex")==0 ){
3083 }else if( strcmp(z,"-help")==0 ){
3085 }else if( strcmp(z,"-cmd")==0 ){
3086 if( i==argc-1 ) break;
3087 z = cmdline_option_value(argc,argv,++i);
3089 rc = do_meta_command(z, &data);
3090 if( rc && bail_on_error ) return rc;
3093 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
3095 fprintf(stderr,"Error: %s\n", zErrMsg);
3096 if( bail_on_error ) return rc!=0 ? rc : 1;
3098 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
3099 if( bail_on_error ) return rc;
3103 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
3104 fprintf(stderr,"Use -help for a list of options.\n");
3110 /* Run just the command that follows the database name
3112 if( zFirstCmd[0]=='.' ){
3113 rc = do_meta_command(zFirstCmd, &data);
3116 rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
3118 fprintf(stderr,"Error: %s\n", zErrMsg);
3119 return rc!=0 ? rc : 1;
3121 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd);
3126 /* Run commands received from standard input
3128 if( stdin_is_interactive ){
3133 "SQLite version %s %.19s\n" /*extra-version-info*/
3134 "Enter \".help\" for instructions\n"
3135 "Enter SQL statements terminated with a \";\"\n",
3136 sqlite3_libversion(), sqlite3_sourceid()
3138 zHome = find_home_dir();
3140 nHistory = strlen30(zHome) + 20;
3141 if( (zHistory = malloc(nHistory))!=0 ){
3142 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
3145 #if defined(HAVE_READLINE) && HAVE_READLINE==1
3146 if( zHistory ) read_history(zHistory);
3148 rc = process_input(&data, 0);
3150 stifle_history(100);
3151 write_history(zHistory);
3155 rc = process_input(&data, stdin);
3158 set_table_name(&data, 0);
3160 sqlite3_close(data.db);