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) \
96 #include <sys/resource.h>
98 /* Saved resource information for the beginning of an operation */
99 static struct rusage sBegin;
102 ** Begin timing an operation
104 static void beginTimer(void){
106 getrusage(RUSAGE_SELF, &sBegin);
110 /* Return the difference of two time_structs in seconds */
111 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
112 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
113 (double)(pEnd->tv_sec - pStart->tv_sec);
117 ** Print the timing results.
119 static void endTimer(void){
122 getrusage(RUSAGE_SELF, &sEnd);
123 printf("CPU Time: user %f sys %f\n",
124 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
125 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
129 #define BEGIN_TIMER beginTimer()
130 #define END_TIMER endTimer()
133 #elif (defined(_WIN32) || defined(WIN32))
137 /* Saved resource information for the beginning of an operation */
138 static HANDLE hProcess;
139 static FILETIME ftKernelBegin;
140 static FILETIME ftUserBegin;
141 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
142 static GETPROCTIMES getProcessTimesAddr = NULL;
145 ** Check to see if we have timer support. Return 1 if necessary
146 ** support found (or found previously).
148 static int hasTimer(void){
149 if( getProcessTimesAddr ){
152 /* GetProcessTimes() isn't supported in WIN95 and some other Windows versions.
153 ** See if the version we are running on has it, and if it does, save off
154 ** a pointer to it and the current process handle.
156 hProcess = GetCurrentProcess();
158 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
159 if( NULL != hinstLib ){
160 getProcessTimesAddr = (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
161 if( NULL != getProcessTimesAddr ){
164 FreeLibrary(hinstLib);
172 ** Begin timing an operation
174 static void beginTimer(void){
175 if( enableTimer && getProcessTimesAddr ){
176 FILETIME ftCreation, ftExit;
177 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin);
181 /* Return the difference of two FILETIME structs in seconds */
182 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
183 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
184 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
185 return (double) ((i64End - i64Start) / 10000000.0);
189 ** Print the timing results.
191 static void endTimer(void){
192 if( enableTimer && getProcessTimesAddr){
193 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
194 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd);
195 printf("CPU Time: user %f sys %f\n",
196 timeDiff(&ftUserBegin, &ftUserEnd),
197 timeDiff(&ftKernelBegin, &ftKernelEnd));
201 #define BEGIN_TIMER beginTimer()
202 #define END_TIMER endTimer()
203 #define HAS_TIMER hasTimer()
212 ** Used to prevent warnings about unused parameters
214 #define UNUSED_PARAMETER(x) (void)(x)
217 ** If the following flag is set, then command execution stops
218 ** at an error if we are not interactive.
220 static int bail_on_error = 0;
223 ** Threat stdin as an interactive input if the following variable
224 ** is true. Otherwise, assume stdin is connected to a file or pipe.
226 static int stdin_is_interactive = 1;
229 ** The following is the open SQLite database. We make a pointer
230 ** to this database a static variable so that it can be accessed
231 ** by the SIGINT handler to interrupt database processing.
233 static sqlite3 *db = 0;
236 ** True if an interrupt (Control-C) has been received.
238 static volatile int seenInterrupt = 0;
241 ** This is the name of our program. It is set in main(), used
242 ** in a number of other places, mostly for error messages.
247 ** Prompt strings. Initialized in main. Settable with
248 ** .prompt main continue
250 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
251 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
254 ** Write I/O traces to the following stream.
256 #ifdef SQLITE_ENABLE_IOTRACE
257 static FILE *iotrace = 0;
261 ** This routine works like printf in that its first argument is a
262 ** format string and subsequent arguments are values to be substituted
263 ** in place of % fields. The result of formatting this string
264 ** is written to iotrace.
266 #ifdef SQLITE_ENABLE_IOTRACE
267 static void iotracePrintf(const char *zFormat, ...){
270 if( iotrace==0 ) return;
271 va_start(ap, zFormat);
272 z = sqlite3_vmprintf(zFormat, ap);
274 fprintf(iotrace, "%s", z);
281 ** Determines if a string is a number of not.
283 static int isNumber(const char *z, int *realnum){
284 if( *z=='-' || *z=='+' ) z++;
289 if( realnum ) *realnum = 0;
290 while( IsDigit(*z) ){ z++; }
293 if( !IsDigit(*z) ) return 0;
294 while( IsDigit(*z) ){ z++; }
295 if( realnum ) *realnum = 1;
297 if( *z=='e' || *z=='E' ){
299 if( *z=='+' || *z=='-' ) z++;
300 if( !IsDigit(*z) ) return 0;
301 while( IsDigit(*z) ){ z++; }
302 if( realnum ) *realnum = 1;
308 ** A global char* and an SQL function to access its current value
309 ** from within an SQL statement. This program used to use the
310 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
311 ** The correct way to do this with sqlite3 is to use the bind API, but
312 ** since the shell is built around the callback paradigm it would be a lot
313 ** of work. Instead just use this hack, which is quite harmless.
315 static const char *zShellStatic = 0;
316 static void shellstaticFunc(
317 sqlite3_context *context,
322 assert( zShellStatic );
323 UNUSED_PARAMETER(argc);
324 UNUSED_PARAMETER(argv);
325 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
330 ** This routine reads a line of text from FILE in, stores
331 ** the text in memory obtained from malloc() and returns a pointer
332 ** to the text. NULL is returned at end of file, or if malloc()
335 ** The interface is like "readline" but no command-line editing
338 static char *local_getline(char *zPrompt, FILE *in, int csvFlag){
344 if( zPrompt && *zPrompt ){
345 printf("%s",zPrompt);
349 zLine = malloc( nLine );
350 if( zLine==0 ) return 0;
354 nLine = nLine*2 + 100;
355 zLine = realloc(zLine, nLine);
356 if( zLine==0 ) return 0;
358 if( fgets(&zLine[n], nLine - n, in)==0 ){
367 if( zLine[n]=='"' ) inQuote = !inQuote;
370 if( n>0 && zLine[n-1]=='\n' && (!inQuote || !csvFlag) ){
372 if( n>0 && zLine[n-1]=='\r' ) n--;
377 zLine = realloc( zLine, n+1 );
382 ** Retrieve a single line of input text.
384 ** zPrior is a string of prior text retrieved. If not the empty
385 ** string, then issue a continuation prompt.
387 static char *one_input_line(const char *zPrior, FILE *in){
391 return local_getline(0, in, 0);
393 if( zPrior && zPrior[0] ){
394 zPrompt = continuePrompt;
396 zPrompt = mainPrompt;
398 zResult = readline(zPrompt);
399 #if defined(HAVE_READLINE) && HAVE_READLINE==1
400 if( zResult && *zResult ) add_history(zResult);
405 struct previous_mode_data {
406 int valid; /* Is there legit data in here? */
413 ** An pointer to an instance of this structure is passed from
414 ** the main program to the callback. This is used to communicate
415 ** state and mode information.
417 struct callback_data {
418 sqlite3 *db; /* The database */
419 int echoOn; /* True to echo input commands */
420 int statsOn; /* True to display memory stats before each finalize */
421 int cnt; /* Number of records displayed so far */
422 FILE *out; /* Write results here */
423 FILE *traceOut; /* Output for sqlite3_trace() */
424 int nErr; /* Number of errors seen */
425 int mode; /* An output mode setting */
426 int writableSchema; /* True if PRAGMA writable_schema=ON */
427 int showHeader; /* True to show column names in List or Column mode */
428 char *zDestTable; /* Name of destination table when MODE_Insert */
429 char separator[20]; /* Separator character for MODE_List */
430 int colWidth[100]; /* Requested width of each column when in column mode*/
431 int actualWidth[100]; /* Actual width of each column */
432 char nullvalue[20]; /* The text to print when a NULL comes back from
434 struct previous_mode_data explainPrev;
435 /* Holds the mode information just before
437 char outfile[FILENAME_MAX]; /* Filename for *out */
438 const char *zDbFilename; /* name of the database file */
439 const char *zVfs; /* Name of VFS to use */
440 sqlite3_stmt *pStmt; /* Current statement if any. */
441 FILE *pLog; /* Write log output here */
445 ** These are the allowed modes.
447 #define MODE_Line 0 /* One column per line. Blank line between records */
448 #define MODE_Column 1 /* One record per line in neat columns */
449 #define MODE_List 2 /* One record per line with a separator */
450 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
451 #define MODE_Html 4 /* Generate an XHTML table */
452 #define MODE_Insert 5 /* Generate SQL "insert" statements */
453 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
454 #define MODE_Csv 7 /* Quote strings, numbers are plain */
455 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
457 static const char *modeDescr[] = {
470 ** Number of elements in an array
472 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
475 ** Compute a string length that is limited to what can be stored in
476 ** lower 30 bits of a 32-bit signed integer.
478 static int strlen30(const char *z){
480 while( *z2 ){ z2++; }
481 return 0x3fffffff & (int)(z2 - z);
485 ** A callback for the sqlite3_log() interface.
487 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
488 struct callback_data *p = (struct callback_data*)pArg;
489 if( p->pLog==0 ) return;
490 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
495 ** Output the given string as a hex-encoded blob (eg. X'1234' )
497 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
499 char *zBlob = (char *)pBlob;
501 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
506 ** Output the given string as a quoted string using SQL quoting conventions.
508 static void output_quoted_string(FILE *out, const char *z){
512 if( z[i]=='\'' ) nSingle++;
515 fprintf(out,"'%s'",z);
519 for(i=0; z[i] && z[i]!='\''; i++){}
523 }else if( z[i]=='\'' ){
524 fprintf(out,"%.*s''",i,z);
536 ** Output the given string as a quoted according to C or TCL quoting rules.
538 static void output_c_string(FILE *out, const char *z){
541 while( (c = *(z++))!=0 ){
557 }else if( !isprint(c) ){
558 fprintf(out, "\\%03o", c&0xff);
567 ** Output the given string with characters that are special to
570 static void output_html_string(FILE *out, const char *z){
581 fprintf(out,"%.*s",i,z);
585 }else if( z[i]=='&' ){
586 fprintf(out,"&");
587 }else if( z[i]=='>' ){
589 }else if( z[i]=='\"' ){
590 fprintf(out,""");
591 }else if( z[i]=='\'' ){
592 fprintf(out,"'");
601 ** If a field contains any character identified by a 1 in the following
602 ** array, then the string must be quoted for CSV.
604 static const char needCsvQuote[] = {
605 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
606 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
607 1, 0, 1, 0, 0, 0, 0, 1, 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, 0,
612 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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,
620 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
624 ** Output a single term of CSV. Actually, p->separator is used for
625 ** the separator, which may or may not be a comma. p->nullvalue is
626 ** the null value. Strings are quoted if necessary.
628 static void output_csv(struct callback_data *p, const char *z, int bSep){
631 fprintf(out,"%s",p->nullvalue);
634 int nSep = strlen30(p->separator);
636 if( needCsvQuote[((unsigned char*)z)[i]]
637 || (z[i]==p->separator[0] &&
638 (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
646 if( z[i]=='"' ) putc('"', out);
651 fprintf(out, "%s", z);
655 fprintf(p->out, "%s", p->separator);
661 ** This routine runs when the user presses Ctrl-C
663 static void interrupt_handler(int NotUsed){
664 UNUSED_PARAMETER(NotUsed);
666 if( db ) sqlite3_interrupt(db);
671 ** This is the callback routine that the shell
672 ** invokes for each row of a query result.
674 static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){
676 struct callback_data *p = (struct callback_data*)pArg;
681 if( azArg==0 ) break;
682 for(i=0; i<nArg; i++){
683 int len = strlen30(azCol[i] ? azCol[i] : "");
686 if( p->cnt++>0 ) fprintf(p->out,"\n");
687 for(i=0; i<nArg; i++){
688 fprintf(p->out,"%*s = %s\n", w, azCol[i],
689 azArg[i] ? azArg[i] : p->nullvalue);
696 for(i=0; i<nArg; i++){
698 if( i<ArraySize(p->colWidth) ){
704 w = strlen30(azCol[i] ? azCol[i] : "");
706 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);
709 if( i<ArraySize(p->actualWidth) ){
710 p->actualWidth[i] = w;
714 fprintf(p->out,"%*.*s%s",-w,-w,azCol[i], i==nArg-1 ? "\n": " ");
716 fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " ");
721 for(i=0; i<nArg; i++){
723 if( i<ArraySize(p->actualWidth) ){
724 w = p->actualWidth[i];
729 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
730 "----------------------------------------------------------",
731 i==nArg-1 ? "\n": " ");
735 if( azArg==0 ) break;
736 for(i=0; i<nArg; i++){
738 if( i<ArraySize(p->actualWidth) ){
739 w = p->actualWidth[i];
743 if( p->mode==MODE_Explain && azArg[i] &&
744 strlen30(azArg[i])>w ){
745 w = strlen30(azArg[i]);
748 fprintf(p->out,"%*.*s%s",-w,-w,
749 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
751 fprintf(p->out,"%-*.*s%s",w,w,
752 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
759 if( p->cnt++==0 && p->showHeader ){
760 for(i=0; i<nArg; i++){
761 fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
764 if( azArg==0 ) break;
765 for(i=0; i<nArg; i++){
767 if( z==0 ) z = p->nullvalue;
768 fprintf(p->out, "%s", z);
770 fprintf(p->out, "%s", p->separator);
771 }else if( p->mode==MODE_Semi ){
772 fprintf(p->out, ";\n");
774 fprintf(p->out, "\n");
780 if( p->cnt++==0 && p->showHeader ){
781 fprintf(p->out,"<TR>");
782 for(i=0; i<nArg; i++){
783 fprintf(p->out,"<TH>");
784 output_html_string(p->out, azCol[i]);
785 fprintf(p->out,"</TH>\n");
787 fprintf(p->out,"</TR>\n");
789 if( azArg==0 ) break;
790 fprintf(p->out,"<TR>");
791 for(i=0; i<nArg; i++){
792 fprintf(p->out,"<TD>");
793 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
794 fprintf(p->out,"</TD>\n");
796 fprintf(p->out,"</TR>\n");
800 if( p->cnt++==0 && p->showHeader ){
801 for(i=0; i<nArg; i++){
802 output_c_string(p->out,azCol[i] ? azCol[i] : "");
803 if(i<nArg-1) fprintf(p->out, "%s", p->separator);
805 fprintf(p->out,"\n");
807 if( azArg==0 ) break;
808 for(i=0; i<nArg; i++){
809 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
810 if(i<nArg-1) fprintf(p->out, "%s", p->separator);
812 fprintf(p->out,"\n");
816 if( p->cnt++==0 && p->showHeader ){
817 for(i=0; i<nArg; i++){
818 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
820 fprintf(p->out,"\n");
822 if( azArg==0 ) break;
823 for(i=0; i<nArg; i++){
824 output_csv(p, azArg[i], i<nArg-1);
826 fprintf(p->out,"\n");
831 if( azArg==0 ) break;
832 fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
833 for(i=0; i<nArg; i++){
834 char *zSep = i>0 ? ",": "";
835 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
836 fprintf(p->out,"%sNULL",zSep);
837 }else if( aiType && aiType[i]==SQLITE_TEXT ){
838 if( zSep[0] ) fprintf(p->out,"%s",zSep);
839 output_quoted_string(p->out, azArg[i]);
840 }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){
841 fprintf(p->out,"%s%s",zSep, azArg[i]);
842 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
843 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
844 int nBlob = sqlite3_column_bytes(p->pStmt, i);
845 if( zSep[0] ) fprintf(p->out,"%s",zSep);
846 output_hex_blob(p->out, pBlob, nBlob);
847 }else if( isNumber(azArg[i], 0) ){
848 fprintf(p->out,"%s%s",zSep, azArg[i]);
850 if( zSep[0] ) fprintf(p->out,"%s",zSep);
851 output_quoted_string(p->out, azArg[i]);
854 fprintf(p->out,");\n");
862 ** This is the callback routine that the SQLite library
863 ** invokes for each row of a query result.
865 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
866 /* since we don't have type info, call the shell_callback with a NULL value */
867 return shell_callback(pArg, nArg, azArg, azCol, NULL);
871 ** Set the destination table field of the callback_data structure to
872 ** the name of the table given. Escape any quote characters in the
875 static void set_table_name(struct callback_data *p, const char *zName){
884 if( zName==0 ) return;
885 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
886 for(i=n=0; zName[i]; i++, n++){
887 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
889 if( zName[i]=='\'' ) n++;
892 if( needQuote ) n += 2;
893 z = p->zDestTable = malloc( n+1 );
895 fprintf(stderr,"Error: out of memory\n");
899 if( needQuote ) z[n++] = '\'';
900 for(i=0; zName[i]; i++){
902 if( zName[i]=='\'' ) z[n++] = '\'';
904 if( needQuote ) z[n++] = '\'';
908 /* zIn is either a pointer to a NULL-terminated string in memory obtained
909 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
910 ** added to zIn, and the result returned in memory obtained from malloc().
911 ** zIn, if it was not NULL, is freed.
913 ** If the third argument, quote, is not '\0', then it is used as a
914 ** quote character for zAppend.
916 static char *appendText(char *zIn, char const *zAppend, char quote){
919 int nAppend = strlen30(zAppend);
920 int nIn = (zIn?strlen30(zIn):0);
925 for(i=0; i<nAppend; i++){
926 if( zAppend[i]==quote ) len++;
930 zIn = (char *)realloc(zIn, len);
936 char *zCsr = &zIn[nIn];
938 for(i=0; i<nAppend; i++){
939 *zCsr++ = zAppend[i];
940 if( zAppend[i]==quote ) *zCsr++ = quote;
944 assert( (zCsr-zIn)==len );
946 memcpy(&zIn[nIn], zAppend, nAppend);
955 ** Execute a query statement that will generate SQL output. Print
956 ** the result columns, comma-separated, on a line and then add a
957 ** semicolon terminator to the end of that line.
959 ** If the number of columns is 1 and that column contains text "--"
960 ** then write the semicolon on a separate line. That way, if a
961 ** "--" comment occurs at the end of the statement, the comment
962 ** won't consume the semicolon terminator.
964 static int run_table_dump_query(
965 struct callback_data *p, /* Query context */
966 const char *zSelect, /* SELECT statement to extract content */
967 const char *zFirstRow /* Print before first row, if not NULL */
969 sqlite3_stmt *pSelect;
974 rc = sqlite3_prepare(p->db, zSelect, -1, &pSelect, 0);
975 if( rc!=SQLITE_OK || !pSelect ){
976 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
980 rc = sqlite3_step(pSelect);
981 nResult = sqlite3_column_count(pSelect);
982 while( rc==SQLITE_ROW ){
984 fprintf(p->out, "%s", zFirstRow);
987 z = (const char*)sqlite3_column_text(pSelect, 0);
988 fprintf(p->out, "%s", z);
989 for(i=1; i<nResult; i++){
990 fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
993 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
995 fprintf(p->out, "\n;\n");
997 fprintf(p->out, ";\n");
999 rc = sqlite3_step(pSelect);
1001 rc = sqlite3_finalize(pSelect);
1002 if( rc!=SQLITE_OK ){
1003 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1010 ** Allocate space and save off current error string.
1012 static char *save_err_msg(
1013 sqlite3 *db /* Database to query */
1015 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1016 char *zErrMsg = sqlite3_malloc(nErrMsg);
1018 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1024 ** Display memory stats.
1026 static int display_stats(
1027 sqlite3 *db, /* Database to query */
1028 struct callback_data *pArg, /* Pointer to struct callback_data */
1029 int bReset /* True to reset the stats */
1034 if( pArg && pArg->out ){
1037 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1038 fprintf(pArg->out, "Memory Used: %d (max %d) bytes\n", iCur, iHiwtr);
1040 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1041 fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n", iCur, iHiwtr);
1043 ** Not currently used by the CLI.
1044 ** iHiwtr = iCur = -1;
1045 ** sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1046 ** fprintf(pArg->out, "Number of Pcache Pages Used: %d (max %d) pages\n", iCur, iHiwtr);
1049 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1050 fprintf(pArg->out, "Number of Pcache Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
1052 ** Not currently used by the CLI.
1053 ** iHiwtr = iCur = -1;
1054 ** sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1055 ** fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n", iCur, iHiwtr);
1058 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1059 fprintf(pArg->out, "Number of Scratch Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
1061 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1062 fprintf(pArg->out, "Largest Allocation: %d bytes\n", iHiwtr);
1064 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1065 fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n", iHiwtr);
1067 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1068 fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n", iHiwtr);
1069 #ifdef YYTRACKMAXSTACKDEPTH
1071 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1072 fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n", iCur, iHiwtr);
1076 if( pArg && pArg->out && db ){
1078 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHiwtr, bReset);
1079 fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n", iCur, iHiwtr);
1080 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, &iCur, &iHiwtr, bReset);
1081 fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr);
1082 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, &iCur, &iHiwtr, bReset);
1083 fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr);
1084 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, &iCur, &iHiwtr, bReset);
1085 fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr);
1087 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1088 fprintf(pArg->out, "Pager Heap Usage: %d bytes\n", iCur); iHiwtr = iCur = -1;
1089 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1090 fprintf(pArg->out, "Page cache hits: %d\n", iCur);
1092 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1093 fprintf(pArg->out, "Page cache misses: %d\n", iCur);
1095 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1096 fprintf(pArg->out, "Page cache writes: %d\n", iCur);
1098 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1099 fprintf(pArg->out, "Schema Heap Usage: %d bytes\n", iCur);
1101 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1102 fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", iCur);
1105 if( pArg && pArg->out && db && pArg->pStmt ){
1106 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, bReset);
1107 fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1108 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1109 fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1110 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX, bReset);
1111 fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1118 ** Execute a statement or set of statements. Print
1119 ** any result rows/columns depending on the current mode
1120 ** set via the supplied callback.
1122 ** This is very similar to SQLite's built-in sqlite3_exec()
1123 ** function except it takes a slightly different callback
1124 ** and callback data argument.
1126 static int shell_exec(
1127 sqlite3 *db, /* An open database */
1128 const char *zSql, /* SQL to be evaluated */
1129 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1130 /* (not the same as sqlite3_exec) */
1131 struct callback_data *pArg, /* Pointer to struct callback_data */
1132 char **pzErrMsg /* Error msg written here */
1134 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1135 int rc = SQLITE_OK; /* Return Code */
1137 const char *zLeftover; /* Tail of unprocessed SQL */
1143 while( zSql[0] && (SQLITE_OK == rc) ){
1144 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1145 if( SQLITE_OK != rc ){
1147 *pzErrMsg = save_err_msg(db);
1151 /* this happens for a comment or white-space */
1153 while( IsSpace(zSql[0]) ) zSql++;
1157 /* save off the prepared statment handle and reset row count */
1159 pArg->pStmt = pStmt;
1163 /* echo the sql statement if echo on */
1164 if( pArg && pArg->echoOn ){
1165 const char *zStmtSql = sqlite3_sql(pStmt);
1166 fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1169 /* Output TESTCTRL_EXPLAIN text of requested */
1170 if( pArg && pArg->mode==MODE_Explain ){
1171 const char *zExplain = 0;
1172 sqlite3_test_control(SQLITE_TESTCTRL_EXPLAIN_STMT, pStmt, &zExplain);
1173 if( zExplain && zExplain[0] ){
1174 fprintf(pArg->out, "%s", zExplain);
1178 /* perform the first step. this will tell us if we
1179 ** have a result set or not and how wide it is.
1181 rc = sqlite3_step(pStmt);
1182 /* if we have a result set... */
1183 if( SQLITE_ROW == rc ){
1184 /* if we have a callback... */
1186 /* allocate space for col name ptr, value ptr, and type */
1187 int nCol = sqlite3_column_count(pStmt);
1188 void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1192 char **azCols = (char **)pData; /* Names of result columns */
1193 char **azVals = &azCols[nCol]; /* Results */
1194 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1196 assert(sizeof(int) <= sizeof(char *));
1197 /* save off ptrs to column names */
1198 for(i=0; i<nCol; i++){
1199 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1202 /* extract the data and data types */
1203 for(i=0; i<nCol; i++){
1204 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
1205 aiTypes[i] = sqlite3_column_type(pStmt, i);
1206 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1208 break; /* from for */
1212 /* if data and types extracted successfully... */
1213 if( SQLITE_ROW == rc ){
1214 /* call the supplied callback with the result row data */
1215 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1218 rc = sqlite3_step(pStmt);
1221 } while( SQLITE_ROW == rc );
1222 sqlite3_free(pData);
1226 rc = sqlite3_step(pStmt);
1227 } while( rc == SQLITE_ROW );
1231 /* print usage stats if stats on */
1232 if( pArg && pArg->statsOn ){
1233 display_stats(db, pArg, 0);
1236 /* Finalize the statement just executed. If this fails, save a
1237 ** copy of the error message. Otherwise, set zSql to point to the
1238 ** next statement to execute. */
1239 rc2 = sqlite3_finalize(pStmt);
1240 if( rc!=SQLITE_NOMEM ) rc = rc2;
1241 if( rc==SQLITE_OK ){
1243 while( IsSpace(zSql[0]) ) zSql++;
1244 }else if( pzErrMsg ){
1245 *pzErrMsg = save_err_msg(db);
1248 /* clear saved stmt handle */
1260 ** This is a different callback routine used for dumping the database.
1261 ** Each row received by this callback consists of a table name,
1262 ** the table type ("index" or "table") and SQL to create the table.
1263 ** This routine should print text sufficient to recreate the table.
1265 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1270 const char *zPrepStmt = 0;
1271 struct callback_data *p = (struct callback_data *)pArg;
1273 UNUSED_PARAMETER(azCol);
1274 if( nArg!=3 ) return 1;
1279 if( strcmp(zTable, "sqlite_sequence")==0 ){
1280 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1281 }else if( strcmp(zTable, "sqlite_stat1")==0 ){
1282 fprintf(p->out, "ANALYZE sqlite_master;\n");
1283 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1285 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1287 if( !p->writableSchema ){
1288 fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1289 p->writableSchema = 1;
1291 zIns = sqlite3_mprintf(
1292 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1293 "VALUES('table','%q','%q',0,'%q');",
1294 zTable, zTable, zSql);
1295 fprintf(p->out, "%s\n", zIns);
1299 fprintf(p->out, "%s;\n", zSql);
1302 if( strcmp(zType, "table")==0 ){
1303 sqlite3_stmt *pTableInfo = 0;
1305 char *zTableInfo = 0;
1309 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1310 zTableInfo = appendText(zTableInfo, zTable, '"');
1311 zTableInfo = appendText(zTableInfo, ");", 0);
1313 rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1315 if( rc!=SQLITE_OK || !pTableInfo ){
1319 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1320 /* Always quote the table name, even if it appears to be pure ascii,
1321 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1322 zTmp = appendText(zTmp, zTable, '"');
1324 zSelect = appendText(zSelect, zTmp, '\'');
1327 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1328 rc = sqlite3_step(pTableInfo);
1329 while( rc==SQLITE_ROW ){
1330 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1331 zSelect = appendText(zSelect, "quote(", 0);
1332 zSelect = appendText(zSelect, zText, '"');
1333 rc = sqlite3_step(pTableInfo);
1334 if( rc==SQLITE_ROW ){
1335 zSelect = appendText(zSelect, "), ", 0);
1337 zSelect = appendText(zSelect, ") ", 0);
1341 rc = sqlite3_finalize(pTableInfo);
1342 if( rc!=SQLITE_OK || nRow==0 ){
1346 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1347 zSelect = appendText(zSelect, zTable, '"');
1349 rc = run_table_dump_query(p, zSelect, zPrepStmt);
1350 if( rc==SQLITE_CORRUPT ){
1351 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1352 run_table_dump_query(p, zSelect, 0);
1360 ** Run zQuery. Use dump_callback() as the callback routine so that
1361 ** the contents of the query are output as SQL statements.
1363 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1364 ** "ORDER BY rowid DESC" to the end.
1366 static int run_schema_dump_query(
1367 struct callback_data *p,
1372 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1373 if( rc==SQLITE_CORRUPT ){
1375 int len = strlen30(zQuery);
1376 fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1378 fprintf(p->out, "/****** %s ******/\n", zErr);
1382 zQ2 = malloc( len+100 );
1383 if( zQ2==0 ) return rc;
1384 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1385 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1387 fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1389 rc = SQLITE_CORRUPT;
1398 ** Text of a help message
1400 static char zHelp[] =
1401 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1402 ".bail ON|OFF Stop after hitting an error. Default OFF\n"
1403 ".databases List names and files of attached databases\n"
1404 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1405 " If TABLE specified, only dump tables matching\n"
1406 " LIKE pattern TABLE.\n"
1407 ".echo ON|OFF Turn command echo on or off\n"
1408 ".exit Exit this program\n"
1409 ".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.\n"
1410 " With no args, it turns EXPLAIN on.\n"
1411 ".header(s) ON|OFF Turn display of headers on or off\n"
1412 ".help Show this message\n"
1413 ".import FILE TABLE Import data from FILE into TABLE\n"
1414 ".indices ?TABLE? Show names of all indices\n"
1415 " If TABLE specified, only show indices for tables\n"
1416 " matching LIKE pattern TABLE.\n"
1417 #ifdef SQLITE_ENABLE_IOTRACE
1418 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1420 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1421 ".load FILE ?ENTRY? Load an extension library\n"
1423 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1424 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1425 " csv Comma-separated values\n"
1426 " column Left-aligned columns. (See .width)\n"
1427 " html HTML <table> code\n"
1428 " insert SQL insert statements for TABLE\n"
1429 " line One value per line\n"
1430 " list Values delimited by .separator string\n"
1431 " tabs Tab-separated values\n"
1432 " tcl TCL list elements\n"
1433 ".nullvalue STRING Use STRING in place of NULL values\n"
1434 ".output FILENAME Send output to FILENAME\n"
1435 ".output stdout Send output to the screen\n"
1436 ".print STRING... Print literal STRING\n"
1437 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1438 ".quit Exit this program\n"
1439 ".read FILENAME Execute SQL in FILENAME\n"
1440 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1441 ".schema ?TABLE? Show the CREATE statements\n"
1442 " If TABLE specified, only show tables matching\n"
1443 " LIKE pattern TABLE.\n"
1444 ".separator STRING Change separator used by output mode and .import\n"
1445 ".show Show the current values for various settings\n"
1446 ".stats ON|OFF Turn stats on or off\n"
1447 ".tables ?TABLE? List names of tables\n"
1448 " If TABLE specified, only list tables matching\n"
1449 " LIKE pattern TABLE.\n"
1450 ".timeout MS Try opening locked tables for MS milliseconds\n"
1451 ".trace FILE|off Output each SQL statement as it is run\n"
1452 ".vfsname ?AUX? Print the name of the VFS stack\n"
1453 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1456 static char zTimerHelp[] =
1457 ".timer ON|OFF Turn the CPU timer measurement on or off\n"
1460 /* Forward reference */
1461 static int process_input(struct callback_data *p, FILE *in);
1464 ** Make sure the database is open. If it is not, then open it. If
1465 ** the database fails to open, print an error message and exit.
1467 static void open_db(struct callback_data *p){
1469 sqlite3_initialize();
1470 sqlite3_open(p->zDbFilename, &p->db);
1472 if( db && sqlite3_errcode(db)==SQLITE_OK ){
1473 sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1474 shellstaticFunc, 0, 0);
1476 if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1477 fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1478 p->zDbFilename, sqlite3_errmsg(db));
1481 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1482 sqlite3_enable_load_extension(p->db, 1);
1488 ** Do C-language style dequoting.
1492 ** \r -> carriage return
1493 ** \NNN -> ascii character NNN in octal
1496 static void resolve_backslashes(char *z){
1499 for(i=j=0; (c = z[i])!=0; i++, j++){
1508 }else if( c>='0' && c<='7' ){
1510 if( z[i+1]>='0' && z[i+1]<='7' ){
1512 c = (c<<3) + z[i] - '0';
1513 if( z[i+1]>='0' && z[i+1]<='7' ){
1515 c = (c<<3) + z[i] - '0';
1526 ** Interpret zArg as a boolean value. Return either 0 or 1.
1528 static int booleanValue(char *zArg){
1530 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
1531 if( i>0 && zArg[i]==0 ) return atoi(zArg);
1532 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
1535 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
1538 fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
1544 ** Interpret zArg as an integer value, possibly with suffixes.
1546 static sqlite3_int64 integerValue(const char *zArg){
1547 sqlite3_int64 v = 0;
1548 static const struct { char *zSuffix; int iMult; } aMult[] = {
1550 { "MiB", 1024*1024 },
1551 { "GiB", 1024*1024*1024 },
1554 { "GB", 1000000000 },
1557 { "G", 1000000000 },
1564 }else if( zArg[0]=='+' ){
1567 while( isdigit(zArg[0]) ){
1568 v = v*10 + zArg[0] - '0';
1571 for(i=0; i<sizeof(aMult)/sizeof(aMult[0]); i++){
1572 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
1573 v *= aMult[i].iMult;
1577 return isNeg? -v : v;
1581 ** Close an output file, assuming it is not stderr or stdout
1583 static void output_file_close(FILE *f){
1584 if( f && f!=stdout && f!=stderr ) fclose(f);
1588 ** Try to open an output file. The names "stdout" and "stderr" are
1589 ** recognized and do the right thing. NULL is returned if the output
1590 ** filename is "off".
1592 static FILE *output_file_open(const char *zFile){
1594 if( strcmp(zFile,"stdout")==0 ){
1596 }else if( strcmp(zFile, "stderr")==0 ){
1598 }else if( strcmp(zFile, "off")==0 ){
1601 f = fopen(zFile, "wb");
1603 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1610 ** A routine for handling output from sqlite3_trace().
1612 static void sql_trace_callback(void *pArg, const char *z){
1613 FILE *f = (FILE*)pArg;
1614 if( f ) fprintf(f, "%s\n", z);
1618 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
1619 ** a useful spot to set a debugger breakpoint.
1621 static void test_breakpoint(void){
1622 static int nCall = 0;
1627 ** If an input line begins with "." then invoke this routine to
1628 ** process that line.
1630 ** Return 1 on error, 2 to exit, and 0 otherwise.
1632 static int do_meta_command(char *zLine, struct callback_data *p){
1639 /* Parse the input line into tokens.
1641 while( zLine[i] && nArg<ArraySize(azArg) ){
1642 while( IsSpace(zLine[i]) ){ i++; }
1643 if( zLine[i]==0 ) break;
1644 if( zLine[i]=='\'' || zLine[i]=='"' ){
1645 int delim = zLine[i++];
1646 azArg[nArg++] = &zLine[i];
1647 while( zLine[i] && zLine[i]!=delim ){ i++; }
1648 if( zLine[i]==delim ){
1651 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1653 azArg[nArg++] = &zLine[i];
1654 while( zLine[i] && !IsSpace(zLine[i]) ){ i++; }
1655 if( zLine[i] ) zLine[i++] = 0;
1656 resolve_backslashes(azArg[nArg-1]);
1660 /* Process the input line.
1662 if( nArg==0 ) return 0; /* no tokens, no error */
1663 n = strlen30(azArg[0]);
1665 if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 ){
1666 const char *zDestFile = 0;
1667 const char *zDb = 0;
1668 const char *zKey = 0;
1670 sqlite3_backup *pBackup;
1672 for(j=1; j<nArg; j++){
1673 const char *z = azArg[j];
1675 while( z[0]=='-' ) z++;
1676 if( strcmp(z,"key")==0 && j<nArg-1 ){
1680 fprintf(stderr, "unknown option: %s\n", azArg[j]);
1683 }else if( zDestFile==0 ){
1684 zDestFile = azArg[j];
1687 zDestFile = azArg[j];
1689 fprintf(stderr, "too many arguments to .backup\n");
1694 fprintf(stderr, "missing FILENAME argument on .backup\n");
1697 if( zDb==0 ) zDb = "main";
1698 rc = sqlite3_open(zDestFile, &pDest);
1699 if( rc!=SQLITE_OK ){
1700 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
1701 sqlite3_close(pDest);
1704 #ifdef SQLITE_HAS_CODEC
1705 sqlite3_key(pDest, zKey, (int)strlen(zKey));
1710 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
1712 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1713 sqlite3_close(pDest);
1716 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
1717 sqlite3_backup_finish(pBackup);
1718 if( rc==SQLITE_DONE ){
1721 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1724 sqlite3_close(pDest);
1727 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){
1728 bail_on_error = booleanValue(azArg[1]);
1731 /* The undocumented ".breakpoint" command causes a call to the no-op
1732 ** routine named test_breakpoint().
1734 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
1738 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
1739 struct callback_data data;
1742 memcpy(&data, p, sizeof(data));
1743 data.showHeader = 1;
1744 data.mode = MODE_Column;
1745 data.colWidth[0] = 3;
1746 data.colWidth[1] = 15;
1747 data.colWidth[2] = 58;
1749 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
1751 fprintf(stderr,"Error: %s\n", zErrMsg);
1752 sqlite3_free(zErrMsg);
1757 if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
1759 /* When playing back a "dump", the content might appear in an order
1760 ** which causes immediate foreign key constraints to be violated.
1761 ** So disable foreign-key constraint enforcement to prevent problems. */
1762 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
1763 fprintf(p->out, "BEGIN TRANSACTION;\n");
1764 p->writableSchema = 0;
1765 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
1768 run_schema_dump_query(p,
1769 "SELECT name, type, sql FROM sqlite_master "
1770 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
1772 run_schema_dump_query(p,
1773 "SELECT name, type, sql FROM sqlite_master "
1774 "WHERE name=='sqlite_sequence'"
1776 run_table_dump_query(p,
1777 "SELECT sql FROM sqlite_master "
1778 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
1782 for(i=1; i<nArg; i++){
1783 zShellStatic = azArg[i];
1784 run_schema_dump_query(p,
1785 "SELECT name, type, sql FROM sqlite_master "
1786 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
1787 " AND sql NOT NULL");
1788 run_table_dump_query(p,
1789 "SELECT sql FROM sqlite_master "
1790 "WHERE sql NOT NULL"
1791 " AND type IN ('index','trigger','view')"
1792 " AND tbl_name LIKE shellstatic()", 0
1797 if( p->writableSchema ){
1798 fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
1799 p->writableSchema = 0;
1801 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
1802 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
1803 fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
1806 if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){
1807 p->echoOn = booleanValue(azArg[1]);
1810 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
1811 if( nArg>1 && (rc = atoi(azArg[1]))!=0 ) exit(rc);
1815 if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){
1816 int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
1818 if(!p->explainPrev.valid) {
1819 p->explainPrev.valid = 1;
1820 p->explainPrev.mode = p->mode;
1821 p->explainPrev.showHeader = p->showHeader;
1822 memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
1824 /* We could put this code under the !p->explainValid
1825 ** condition so that it does not execute if we are already in
1826 ** explain mode. However, always executing it allows us an easy
1827 ** was to reset to explain mode in case the user previously
1828 ** did an .explain followed by a .width, .mode or .header
1831 p->mode = MODE_Explain;
1833 memset(p->colWidth,0,ArraySize(p->colWidth));
1834 p->colWidth[0] = 4; /* addr */
1835 p->colWidth[1] = 13; /* opcode */
1836 p->colWidth[2] = 4; /* P1 */
1837 p->colWidth[3] = 4; /* P2 */
1838 p->colWidth[4] = 4; /* P3 */
1839 p->colWidth[5] = 13; /* P4 */
1840 p->colWidth[6] = 2; /* P5 */
1841 p->colWidth[7] = 13; /* Comment */
1842 }else if (p->explainPrev.valid) {
1843 p->explainPrev.valid = 0;
1844 p->mode = p->explainPrev.mode;
1845 p->showHeader = p->explainPrev.showHeader;
1846 memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
1850 if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
1851 strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){
1852 p->showHeader = booleanValue(azArg[1]);
1855 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1856 fprintf(stderr,"%s",zHelp);
1858 fprintf(stderr,"%s",zTimerHelp);
1862 if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1863 char *zTable = azArg[2]; /* Insert data into this table */
1864 char *zFile = azArg[1]; /* The file from which to extract data */
1865 sqlite3_stmt *pStmt = NULL; /* A statement */
1866 int nCol; /* Number of columns in the table */
1867 int nByte; /* Number of bytes in an SQL string */
1868 int i, j; /* Loop counters */
1869 int nSep; /* Number of bytes in p->separator[] */
1870 char *zSql; /* An SQL statement */
1871 char *zLine; /* A single line of input from the file */
1872 char **azCol; /* zLine[] broken up into columns */
1873 char *zCommit; /* How to commit changes */
1874 FILE *in; /* The input file */
1875 int lineno = 0; /* Line number of input file */
1878 nSep = strlen30(p->separator);
1880 fprintf(stderr, "Error: non-null separator required for import\n");
1883 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
1885 fprintf(stderr, "Error: out of memory\n");
1888 nByte = strlen30(zSql);
1889 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1892 if (pStmt) sqlite3_finalize(pStmt);
1893 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1896 nCol = sqlite3_column_count(pStmt);
1897 sqlite3_finalize(pStmt);
1899 if( nCol==0 ) return 0; /* no columns, no error */
1900 zSql = malloc( nByte + 20 + nCol*2 );
1902 fprintf(stderr, "Error: out of memory\n");
1905 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO %s VALUES(?", zTable);
1907 for(i=1; i<nCol; i++){
1913 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1916 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
1917 if (pStmt) sqlite3_finalize(pStmt);
1920 in = fopen(zFile, "rb");
1922 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1923 sqlite3_finalize(pStmt);
1926 azCol = malloc( sizeof(azCol[0])*(nCol+1) );
1928 fprintf(stderr, "Error: out of memory\n");
1930 sqlite3_finalize(pStmt);
1933 sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
1935 while( (zLine = local_getline(0, in, 1))!=0 ){
1940 for(i=0, z=zLine; (c = *z)!=0; z++){
1941 if( c=='"' ) inQuote = !inQuote;
1942 if( c=='\n' ) lineno++;
1943 if( !inQuote && c==p->separator[0] && strncmp(z,p->separator,nSep)==0 ){
1947 azCol[i] = &z[nSep];
1955 "Error: %s line %d: expected %d columns of data but found %d\n",
1956 zFile, lineno, nCol, i+1);
1957 zCommit = "ROLLBACK";
1960 break; /* from while */
1962 for(i=0; i<nCol; i++){
1963 if( azCol[i][0]=='"' ){
1965 for(z=azCol[i], j=1, k=0; z[j]; j++){
1966 if( z[j]=='"' ){ j++; if( z[j]==0 ) break; }
1971 sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
1973 sqlite3_step(pStmt);
1974 rc = sqlite3_reset(pStmt);
1976 if( rc!=SQLITE_OK ){
1977 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1978 zCommit = "ROLLBACK";
1980 break; /* from while */
1985 sqlite3_finalize(pStmt);
1986 sqlite3_exec(p->db, zCommit, 0, 0, 0);
1989 if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){
1990 struct callback_data data;
1993 memcpy(&data, p, sizeof(data));
1994 data.showHeader = 0;
1995 data.mode = MODE_List;
1997 rc = sqlite3_exec(p->db,
1998 "SELECT name FROM sqlite_master "
1999 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
2001 "SELECT name FROM sqlite_temp_master "
2002 "WHERE type='index' "
2004 callback, &data, &zErrMsg
2007 zShellStatic = azArg[1];
2008 rc = sqlite3_exec(p->db,
2009 "SELECT name FROM sqlite_master "
2010 "WHERE type='index' AND tbl_name LIKE shellstatic() "
2012 "SELECT name FROM sqlite_temp_master "
2013 "WHERE type='index' AND tbl_name LIKE shellstatic() "
2015 callback, &data, &zErrMsg
2020 fprintf(stderr,"Error: %s\n", zErrMsg);
2021 sqlite3_free(zErrMsg);
2023 }else if( rc != SQLITE_OK ){
2024 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
2029 #ifdef SQLITE_ENABLE_IOTRACE
2030 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
2031 extern void (*sqlite3IoTrace)(const char*, ...);
2032 if( iotrace && iotrace!=stdout ) fclose(iotrace);
2036 }else if( strcmp(azArg[1], "-")==0 ){
2037 sqlite3IoTrace = iotracePrintf;
2040 iotrace = fopen(azArg[1], "w");
2042 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
2046 sqlite3IoTrace = iotracePrintf;
2052 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2053 if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
2054 const char *zFile, *zProc;
2057 zProc = nArg>=3 ? azArg[2] : 0;
2059 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
2060 if( rc!=SQLITE_OK ){
2061 fprintf(stderr, "Error: %s\n", zErrMsg);
2062 sqlite3_free(zErrMsg);
2068 if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=2 ){
2069 const char *zFile = azArg[1];
2070 output_file_close(p->pLog);
2071 p->pLog = output_file_open(zFile);
2074 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){
2075 int n2 = strlen30(azArg[1]);
2076 if( (n2==4 && strncmp(azArg[1],"line",n2)==0)
2078 (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){
2079 p->mode = MODE_Line;
2080 }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0)
2082 (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){
2083 p->mode = MODE_Column;
2084 }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){
2085 p->mode = MODE_List;
2086 }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){
2087 p->mode = MODE_Html;
2088 }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){
2090 sqlite3_snprintf(sizeof(p->separator), p->separator, " ");
2091 }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){
2093 sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
2094 }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){
2095 p->mode = MODE_List;
2096 sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
2097 }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2098 p->mode = MODE_Insert;
2099 set_table_name(p, "table");
2101 fprintf(stderr,"Error: mode should be one of: "
2102 "column csv html insert line list tabs tcl\n");
2107 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){
2108 int n2 = strlen30(azArg[1]);
2109 if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2110 p->mode = MODE_Insert;
2111 set_table_name(p, azArg[2]);
2113 fprintf(stderr, "Error: invalid arguments: "
2114 " \"%s\". Enter \".help\" for help\n", azArg[2]);
2119 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
2120 sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
2121 "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
2124 if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
2125 if( p->outfile[0]=='|' ){
2128 output_file_close(p->out);
2131 if( azArg[1][0]=='|' ){
2132 p->out = popen(&azArg[1][1], "w");
2134 fprintf(stderr,"Error: cannot open pipe \"%s\"\n", &azArg[1][1]);
2138 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2141 p->out = output_file_open(azArg[1]);
2143 if( strcmp(azArg[1],"off")!=0 ){
2144 fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]);
2149 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2154 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
2156 for(i=1; i<nArg; i++){
2157 if( i>1 ) fprintf(p->out, " ");
2158 fprintf(p->out, "%s", azArg[i]);
2160 fprintf(p->out, "\n");
2163 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
2165 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
2168 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
2172 if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){
2176 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
2177 FILE *alt = fopen(azArg[1], "rb");
2179 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
2182 rc = process_input(p, alt);
2187 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){
2188 const char *zSrcFile;
2191 sqlite3_backup *pBackup;
2195 zSrcFile = azArg[1];
2198 zSrcFile = azArg[2];
2201 rc = sqlite3_open(zSrcFile, &pSrc);
2202 if( rc!=SQLITE_OK ){
2203 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
2204 sqlite3_close(pSrc);
2208 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
2210 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2211 sqlite3_close(pSrc);
2214 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
2215 || rc==SQLITE_BUSY ){
2216 if( rc==SQLITE_BUSY ){
2217 if( nTimeout++ >= 3 ) break;
2221 sqlite3_backup_finish(pBackup);
2222 if( rc==SQLITE_DONE ){
2224 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
2225 fprintf(stderr, "Error: source database is busy\n");
2228 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2231 sqlite3_close(pSrc);
2234 if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){
2235 struct callback_data data;
2238 memcpy(&data, p, sizeof(data));
2239 data.showHeader = 0;
2240 data.mode = MODE_Semi;
2243 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
2244 if( strcmp(azArg[1],"sqlite_master")==0 ){
2245 char *new_argv[2], *new_colv[2];
2246 new_argv[0] = "CREATE TABLE sqlite_master (\n"
2250 " rootpage integer,\n"
2254 new_colv[0] = "sql";
2256 callback(&data, 1, new_argv, new_colv);
2258 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
2259 char *new_argv[2], *new_colv[2];
2260 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
2264 " rootpage integer,\n"
2268 new_colv[0] = "sql";
2270 callback(&data, 1, new_argv, new_colv);
2273 zShellStatic = azArg[1];
2274 rc = sqlite3_exec(p->db,
2276 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2277 " FROM sqlite_master UNION ALL"
2278 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2279 "WHERE lower(tbl_name) LIKE shellstatic()"
2280 " AND type!='meta' AND sql NOTNULL "
2282 callback, &data, &zErrMsg);
2286 rc = sqlite3_exec(p->db,
2288 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2289 " FROM sqlite_master UNION ALL"
2290 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2291 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
2293 callback, &data, &zErrMsg
2297 fprintf(stderr,"Error: %s\n", zErrMsg);
2298 sqlite3_free(zErrMsg);
2300 }else if( rc != SQLITE_OK ){
2301 fprintf(stderr,"Error: querying schema information\n");
2308 if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2309 sqlite3_snprintf(sizeof(p->separator), p->separator,
2310 "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2313 if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){
2315 fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
2316 fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
2317 fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
2318 fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
2319 fprintf(p->out,"%9.9s: ", "nullvalue");
2320 output_c_string(p->out, p->nullvalue);
2321 fprintf(p->out, "\n");
2322 fprintf(p->out,"%9.9s: %s\n","output",
2323 strlen30(p->outfile) ? p->outfile : "stdout");
2324 fprintf(p->out,"%9.9s: ", "separator");
2325 output_c_string(p->out, p->separator);
2326 fprintf(p->out, "\n");
2327 fprintf(p->out,"%9.9s: %s\n","stats", p->statsOn ? "on" : "off");
2328 fprintf(p->out,"%9.9s: ","width");
2329 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
2330 fprintf(p->out,"%d ",p->colWidth[i]);
2332 fprintf(p->out,"\n");
2335 if( c=='s' && strncmp(azArg[0], "stats", n)==0 && nArg>1 && nArg<3 ){
2336 p->statsOn = booleanValue(azArg[1]);
2339 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){
2340 sqlite3_stmt *pStmt;
2346 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
2348 zSql = sqlite3_mprintf(
2349 "SELECT name FROM sqlite_master"
2350 " WHERE type IN ('table','view')"
2351 " AND name NOT LIKE 'sqlite_%%'"
2352 " AND name LIKE ?1");
2353 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2354 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
2355 if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
2356 if( strcmp(zDbName,"temp")==0 ){
2357 zSql = sqlite3_mprintf(
2359 "SELECT 'temp.' || name FROM sqlite_temp_master"
2360 " WHERE type IN ('table','view')"
2361 " AND name NOT LIKE 'sqlite_%%'"
2362 " AND name LIKE ?1", zSql);
2364 zSql = sqlite3_mprintf(
2366 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
2367 " WHERE type IN ('table','view')"
2368 " AND name NOT LIKE 'sqlite_%%'"
2369 " AND name LIKE ?1", zSql, zDbName, zDbName);
2372 sqlite3_finalize(pStmt);
2373 zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
2374 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2380 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
2382 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
2384 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2387 int n = nAlloc*2 + 10;
2388 azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n);
2390 fprintf(stderr, "Error: out of memory\n");
2396 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
2397 if( azResult[nRow] ) nRow++;
2399 sqlite3_finalize(pStmt);
2401 int len, maxlen = 0;
2403 int nPrintCol, nPrintRow;
2404 for(i=0; i<nRow; i++){
2405 len = strlen30(azResult[i]);
2406 if( len>maxlen ) maxlen = len;
2408 nPrintCol = 80/(maxlen+2);
2409 if( nPrintCol<1 ) nPrintCol = 1;
2410 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
2411 for(i=0; i<nPrintRow; i++){
2412 for(j=i; j<nRow; j+=nPrintRow){
2413 char *zSp = j<nPrintRow ? "" : " ";
2414 fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
2416 fprintf(p->out, "\n");
2419 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
2420 sqlite3_free(azResult);
2423 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
2424 static const struct {
2425 const char *zCtrlName; /* Name of a test-control option */
2426 int ctrlCode; /* Integer code for that option */
2428 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
2429 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
2430 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
2431 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
2432 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
2433 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
2434 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
2435 { "assert", SQLITE_TESTCTRL_ASSERT },
2436 { "always", SQLITE_TESTCTRL_ALWAYS },
2437 { "reserve", SQLITE_TESTCTRL_RESERVE },
2438 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
2439 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
2440 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
2447 /* convert testctrl text option to value. allow any unique prefix
2448 ** of the option name, or a numerical value. */
2449 n = strlen30(azArg[1]);
2450 for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){
2451 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){
2453 testctrl = aCtrl[i].ctrlCode;
2455 fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
2461 if( testctrl<0 ) testctrl = atoi(azArg[1]);
2462 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
2463 fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
2467 /* sqlite3_test_control(int, db, int) */
2468 case SQLITE_TESTCTRL_OPTIMIZATIONS:
2469 case SQLITE_TESTCTRL_RESERVE:
2471 int opt = (int)strtol(azArg[2], 0, 0);
2472 rc = sqlite3_test_control(testctrl, p->db, opt);
2473 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2475 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2480 /* sqlite3_test_control(int) */
2481 case SQLITE_TESTCTRL_PRNG_SAVE:
2482 case SQLITE_TESTCTRL_PRNG_RESTORE:
2483 case SQLITE_TESTCTRL_PRNG_RESET:
2485 rc = sqlite3_test_control(testctrl);
2486 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2488 fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
2492 /* sqlite3_test_control(int, uint) */
2493 case SQLITE_TESTCTRL_PENDING_BYTE:
2495 unsigned int opt = (unsigned int)integerValue(azArg[2]);
2496 rc = sqlite3_test_control(testctrl, opt);
2497 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2499 fprintf(stderr,"Error: testctrl %s takes a single unsigned"
2500 " int option\n", azArg[1]);
2504 /* sqlite3_test_control(int, int) */
2505 case SQLITE_TESTCTRL_ASSERT:
2506 case SQLITE_TESTCTRL_ALWAYS:
2508 int opt = atoi(azArg[2]);
2509 rc = sqlite3_test_control(testctrl, opt);
2510 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2512 fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2517 /* sqlite3_test_control(int, char *) */
2518 #ifdef SQLITE_N_KEYWORD
2519 case SQLITE_TESTCTRL_ISKEYWORD:
2521 const char *opt = azArg[2];
2522 rc = sqlite3_test_control(testctrl, opt);
2523 fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2525 fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
2531 case SQLITE_TESTCTRL_BITVEC_TEST:
2532 case SQLITE_TESTCTRL_FAULT_INSTALL:
2533 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
2534 case SQLITE_TESTCTRL_SCRATCHMALLOC:
2536 fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
2543 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){
2545 sqlite3_busy_timeout(p->db, atoi(azArg[1]));
2548 if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0
2551 enableTimer = booleanValue(azArg[1]);
2554 if( c=='t' && strncmp(azArg[0], "trace", n)==0 && nArg>1 ){
2556 output_file_close(p->traceOut);
2557 p->traceOut = output_file_open(azArg[1]);
2558 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
2559 if( p->traceOut==0 ){
2560 sqlite3_trace(p->db, 0, 0);
2562 sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
2567 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
2568 fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
2569 sqlite3_libversion(), sqlite3_sourceid());
2572 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
2573 const char *zDbName = nArg==2 ? azArg[1] : "main";
2576 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
2578 fprintf(p->out, "%s\n", zVfsName);
2579 sqlite3_free(zVfsName);
2584 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
2585 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
2586 extern int sqlite3WhereTrace;
2587 sqlite3WhereTrace = booleanValue(azArg[1]);
2591 if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){
2593 assert( nArg<=ArraySize(azArg) );
2594 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
2595 p->colWidth[j-1] = atoi(azArg[j]);
2600 fprintf(stderr, "Error: unknown command or invalid arguments: "
2601 " \"%s\". Enter \".help\" for help\n", azArg[0]);
2609 ** Return TRUE if a semicolon occurs anywhere in the first N characters
2612 static int _contains_semicolon(const char *z, int N){
2614 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
2619 ** Test to see if a line consists entirely of whitespace.
2621 static int _all_whitespace(const char *z){
2623 if( IsSpace(z[0]) ) continue;
2624 if( *z=='/' && z[1]=='*' ){
2626 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
2627 if( *z==0 ) return 0;
2631 if( *z=='-' && z[1]=='-' ){
2633 while( *z && *z!='\n' ){ z++; }
2634 if( *z==0 ) return 1;
2643 ** Return TRUE if the line typed in is an SQL command terminator other
2644 ** than a semi-colon. The SQL Server style "go" command is understood
2645 ** as is the Oracle "/".
2647 static int _is_command_terminator(const char *zLine){
2648 while( IsSpace(zLine[0]) ){ zLine++; };
2649 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
2650 return 1; /* Oracle */
2652 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
2653 && _all_whitespace(&zLine[2]) ){
2654 return 1; /* SQL Server */
2660 ** Return true if zSql is a complete SQL statement. Return false if it
2661 ** ends in the middle of a string literal or C-style comment.
2663 static int _is_complete(char *zSql, int nSql){
2665 if( zSql==0 ) return 1;
2668 rc = sqlite3_complete(zSql);
2674 ** Read input from *in and process it. If *in==0 then input
2675 ** is interactive - the user is typing it it. Otherwise, input
2676 ** is coming from a file or device. A prompt is issued and history
2677 ** is saved only if input is interactive. An interrupt signal will
2678 ** cause this routine to exit immediately, unless input is interactive.
2680 ** Return the number of errors.
2682 static int process_input(struct callback_data *p, FILE *in){
2693 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
2696 zLine = one_input_line(zSql, in);
2699 if( stdin_is_interactive ) printf("\n");
2702 if( seenInterrupt ){
2707 if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
2708 if( zLine && zLine[0]=='.' && nSql==0 ){
2709 if( p->echoOn ) printf("%s\n", zLine);
2710 rc = do_meta_command(zLine, p);
2711 if( rc==2 ){ /* exit requested */
2718 if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){
2719 memcpy(zLine,";",2);
2724 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
2726 nSql = strlen30(zLine);
2727 zSql = malloc( nSql+3 );
2729 fprintf(stderr, "Error: out of memory\n");
2732 memcpy(zSql, zLine, nSql+1);
2736 int len = strlen30(zLine);
2737 zSql = realloc( zSql, nSql + len + 4 );
2739 fprintf(stderr,"Error: out of memory\n");
2742 zSql[nSql++] = '\n';
2743 memcpy(&zSql[nSql], zLine, len+1);
2746 if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
2747 && sqlite3_complete(zSql) ){
2751 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
2753 if( rc || zErrMsg ){
2755 if( in!=0 || !stdin_is_interactive ){
2756 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
2757 "Error: near line %d:", startline);
2759 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
2762 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
2763 sqlite3_free(zErrMsg);
2766 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
2773 }else if( zSql && _all_whitespace(zSql) ){
2780 if( !_all_whitespace(zSql) ){
2781 fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
2790 ** Return a pathname which is the user's home directory. A
2791 ** 0 return indicates an error of some kind.
2793 static char *find_home_dir(void){
2794 static char *home_dir = NULL;
2795 if( home_dir ) return home_dir;
2797 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)
2799 struct passwd *pwent;
2800 uid_t uid = getuid();
2801 if( (pwent=getpwuid(uid)) != NULL) {
2802 home_dir = pwent->pw_dir;
2807 #if defined(_WIN32_WCE)
2808 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
2813 #if defined(_WIN32) || defined(WIN32)
2815 home_dir = getenv("USERPROFILE");
2820 home_dir = getenv("HOME");
2823 #if defined(_WIN32) || defined(WIN32)
2825 char *zDrive, *zPath;
2827 zDrive = getenv("HOMEDRIVE");
2828 zPath = getenv("HOMEPATH");
2829 if( zDrive && zPath ){
2830 n = strlen30(zDrive) + strlen30(zPath) + 1;
2831 home_dir = malloc( n );
2832 if( home_dir==0 ) return 0;
2833 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
2840 #endif /* !_WIN32_WCE */
2843 int n = strlen30(home_dir) + 1;
2844 char *z = malloc( n );
2845 if( z ) memcpy(z, home_dir, n);
2853 ** Read input from the file given by sqliterc_override. Or if that
2854 ** parameter is NULL, take input from ~/.sqliterc
2856 ** Returns the number of errors.
2858 static int process_sqliterc(
2859 struct callback_data *p, /* Configuration data */
2860 const char *sqliterc_override /* Name of config file. NULL to use default */
2862 char *home_dir = NULL;
2863 const char *sqliterc = sqliterc_override;
2868 if (sqliterc == NULL) {
2869 home_dir = find_home_dir();
2871 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
2872 fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
2876 sqlite3_initialize();
2877 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
2880 in = fopen(sqliterc,"rb");
2882 if( stdin_is_interactive ){
2883 fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
2885 rc = process_input(p,in);
2893 ** Show available command line options
2895 static const char zOptions[] =
2896 " -bail stop after hitting an error\n"
2897 " -batch force batch I/O\n"
2898 " -column set output mode to 'column'\n"
2899 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
2900 " -csv set output mode to 'csv'\n"
2901 " -echo print commands before execution\n"
2902 " -init FILENAME read/process named file\n"
2903 " -[no]header turn headers on or off\n"
2904 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
2905 " -heap SIZE Size of heap for memsys3 or memsys5\n"
2907 " -help show this message\n"
2908 " -html set output mode to HTML\n"
2909 " -interactive force interactive I/O\n"
2910 " -line set output mode to 'line'\n"
2911 " -list set output mode to 'list'\n"
2912 " -mmap N default mmap size set to N\n"
2913 #ifdef SQLITE_ENABLE_MULTIPLEX
2914 " -multiplex enable the multiplexor VFS\n"
2916 " -nullvalue TEXT set text string for NULL values. Default ''\n"
2917 " -separator SEP set output field separator. Default: '|'\n"
2918 " -stats print memory stats before each finalize\n"
2919 " -version show SQLite version\n"
2920 " -vfs NAME use NAME as the default VFS\n"
2921 #ifdef SQLITE_ENABLE_VFSTRACE
2922 " -vfstrace enable tracing of all VFS calls\n"
2925 static void usage(int showDetail){
2927 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
2928 "FILENAME is the name of an SQLite database. A new database is created\n"
2929 "if the file does not previously exist.\n", Argv0);
2931 fprintf(stderr, "OPTIONS include:\n%s", zOptions);
2933 fprintf(stderr, "Use the -help option for additional information\n");
2939 ** Initialize the state information in data
2941 static void main_init(struct callback_data *data) {
2942 memset(data, 0, sizeof(*data));
2943 data->mode = MODE_List;
2944 memcpy(data->separator,"|", 2);
2945 data->showHeader = 0;
2946 sqlite3_config(SQLITE_CONFIG_URI, 1);
2947 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
2948 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
2949 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
2950 sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
2954 ** Get the argument to an --option. Throw an error and die if no argument
2957 static char *cmdline_option_value(int argc, char **argv, int i){
2959 fprintf(stderr, "%s: Error: missing argument to %s\n",
2960 argv[0], argv[argc-1]);
2966 int main(int argc, char **argv){
2968 struct callback_data data;
2969 const char *zInitFile = 0;
2970 char *zFirstCmd = 0;
2974 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
2975 fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
2976 sqlite3_sourceid(), SQLITE_SOURCE_ID);
2981 stdin_is_interactive = isatty(0);
2983 /* Make sure we have a valid signal handler early, before anything
2987 signal(SIGINT, interrupt_handler);
2990 /* Do an initial pass through the command-line argument to locate
2991 ** the name of the database file, the name of the initialization file,
2992 ** the size of the alternative malloc heap,
2993 ** and the first command to execute.
2995 for(i=1; i<argc; i++){
2999 if( data.zDbFilename==0 ){
3000 data.zDbFilename = z;
3007 fprintf(stderr,"%s: Error: too many options: \"%s\"\n", Argv0, argv[i]);
3008 fprintf(stderr,"Use -help for a list of options.\n");
3011 if( z[1]=='-' ) z++;
3012 if( strcmp(z,"-separator")==0
3013 || strcmp(z,"-nullvalue")==0
3014 || strcmp(z,"-cmd")==0
3016 (void)cmdline_option_value(argc, argv, ++i);
3017 }else if( strcmp(z,"-init")==0 ){
3018 zInitFile = cmdline_option_value(argc, argv, ++i);
3019 }else if( strcmp(z,"-batch")==0 ){
3020 /* Need to check for batch mode here to so we can avoid printing
3021 ** informational messages (like from process_sqliterc) before
3022 ** we do the actual processing of arguments later in a second pass.
3024 stdin_is_interactive = 0;
3025 }else if( strcmp(z,"-heap")==0 ){
3026 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
3029 sqlite3_int64 szHeap;
3031 zSize = cmdline_option_value(argc, argv, ++i);
3032 szHeap = integerValue(zSize);
3033 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
3034 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
3036 #ifdef SQLITE_ENABLE_VFSTRACE
3037 }else if( strcmp(z,"-vfstrace")==0 ){
3038 extern int vfstrace_register(
3039 const char *zTraceName,
3040 const char *zOldVfsName,
3041 int (*xOut)(const char*,void*),
3045 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
3047 #ifdef SQLITE_ENABLE_MULTIPLEX
3048 }else if( strcmp(z,"-multiplex")==0 ){
3049 extern int sqlite3_multiple_initialize(const char*,int);
3050 sqlite3_multiplex_initialize(0, 1);
3052 }else if( strcmp(z,"-mmap")==0 ){
3053 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
3054 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
3055 }else if( strcmp(z,"-vfs")==0 ){
3056 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
3058 sqlite3_vfs_register(pVfs, 1);
3060 fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
3065 if( data.zDbFilename==0 ){
3066 #ifndef SQLITE_OMIT_MEMORYDB
3067 data.zDbFilename = ":memory:";
3069 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
3075 /* Go ahead and open the database file if it already exists. If the
3076 ** file does not exist, delay opening it. This prevents empty database
3077 ** files from being created if a user mistypes the database name argument
3078 ** to the sqlite command-line tool.
3080 if( access(data.zDbFilename, 0)==0 ){
3084 /* Process the initialization file if there is one. If no -init option
3085 ** is given on the command line, look for a file named ~/.sqliterc and
3086 ** try to process it.
3088 rc = process_sqliterc(&data,zInitFile);
3093 /* Make a second pass through the command-line argument and set
3094 ** options. This second pass is delayed until after the initialization
3095 ** file is processed so that the command-line arguments will override
3096 ** settings in the initialization file.
3098 for(i=1; i<argc; i++){
3100 if( z[0]!='-' ) continue;
3101 if( z[1]=='-' ){ z++; }
3102 if( strcmp(z,"-init")==0 ){
3104 }else if( strcmp(z,"-html")==0 ){
3105 data.mode = MODE_Html;
3106 }else if( strcmp(z,"-list")==0 ){
3107 data.mode = MODE_List;
3108 }else if( strcmp(z,"-line")==0 ){
3109 data.mode = MODE_Line;
3110 }else if( strcmp(z,"-column")==0 ){
3111 data.mode = MODE_Column;
3112 }else if( strcmp(z,"-csv")==0 ){
3113 data.mode = MODE_Csv;
3114 memcpy(data.separator,",",2);
3115 }else if( strcmp(z,"-separator")==0 ){
3116 sqlite3_snprintf(sizeof(data.separator), data.separator,
3117 "%s",cmdline_option_value(argc,argv,++i));
3118 }else if( strcmp(z,"-nullvalue")==0 ){
3119 sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
3120 "%s",cmdline_option_value(argc,argv,++i));
3121 }else if( strcmp(z,"-header")==0 ){
3122 data.showHeader = 1;
3123 }else if( strcmp(z,"-noheader")==0 ){
3124 data.showHeader = 0;
3125 }else if( strcmp(z,"-echo")==0 ){
3127 }else if( strcmp(z,"-stats")==0 ){
3129 }else if( strcmp(z,"-bail")==0 ){
3131 }else if( strcmp(z,"-version")==0 ){
3132 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
3134 }else if( strcmp(z,"-interactive")==0 ){
3135 stdin_is_interactive = 1;
3136 }else if( strcmp(z,"-batch")==0 ){
3137 stdin_is_interactive = 0;
3138 }else if( strcmp(z,"-heap")==0 ){
3140 }else if( strcmp(z,"-mmap")==0 ){
3142 }else if( strcmp(z,"-vfs")==0 ){
3144 #ifdef SQLITE_ENABLE_VFSTRACE
3145 }else if( strcmp(z,"-vfstrace")==0 ){
3148 #ifdef SQLITE_ENABLE_MULTIPLEX
3149 }else if( strcmp(z,"-multiplex")==0 ){
3152 }else if( strcmp(z,"-help")==0 ){
3154 }else if( strcmp(z,"-cmd")==0 ){
3155 if( i==argc-1 ) break;
3156 z = cmdline_option_value(argc,argv,++i);
3158 rc = do_meta_command(z, &data);
3159 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
3162 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
3164 fprintf(stderr,"Error: %s\n", zErrMsg);
3165 if( bail_on_error ) return rc!=0 ? rc : 1;
3167 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
3168 if( bail_on_error ) return rc;
3172 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
3173 fprintf(stderr,"Use -help for a list of options.\n");
3179 /* Run just the command that follows the database name
3181 if( zFirstCmd[0]=='.' ){
3182 rc = do_meta_command(zFirstCmd, &data);
3186 rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
3188 fprintf(stderr,"Error: %s\n", zErrMsg);
3189 return rc!=0 ? rc : 1;
3191 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd);
3196 /* Run commands received from standard input
3198 if( stdin_is_interactive ){
3203 "SQLite version %s %.19s\n" /*extra-version-info*/
3204 "Enter \".help\" for instructions\n"
3205 "Enter SQL statements terminated with a \";\"\n",
3206 sqlite3_libversion(), sqlite3_sourceid()
3208 zHome = find_home_dir();
3210 nHistory = strlen30(zHome) + 20;
3211 if( (zHistory = malloc(nHistory))!=0 ){
3212 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
3215 #if defined(HAVE_READLINE) && HAVE_READLINE==1
3216 if( zHistory ) read_history(zHistory);
3218 rc = process_input(&data, 0);
3220 stifle_history(100);
3221 write_history(zHistory);
3225 rc = process_input(&data, stdin);
3228 set_table_name(&data, 0);
3230 sqlite3_close(data.db);