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)
16 /* This needs to come before any includes for MSVC compiler */
17 #define _CRT_SECURE_NO_WARNINGS
28 #if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)
30 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
34 # include <sys/types.h>
41 #if defined(HAVE_READLINE) && HAVE_READLINE==1
42 # include <readline/readline.h>
43 # include <readline/history.h>
45 # define readline(p) local_getline(p,stdin)
46 # define add_history(X)
47 # define read_history(X)
48 # define write_history(X)
49 # define stifle_history(X)
52 #if defined(_WIN32) || defined(WIN32)
54 #define isatty(h) _isatty(h)
55 #define access(f,m) _access((f),(m))
57 /* Make sure isatty() has a prototype.
62 #if defined(_WIN32_WCE)
63 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
64 * thus we always assume that we have a console. That can be
65 * overridden with the -batch command line option.
70 #if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(__RTP__) && !defined(_WRS_KERNEL)
72 #include <sys/resource.h>
74 /* Saved resource information for the beginning of an operation */
75 static struct rusage sBegin;
77 /* True if the timer is enabled */
78 static int enableTimer = 0;
81 ** Begin timing an operation
83 static void beginTimer(void){
85 getrusage(RUSAGE_SELF, &sBegin);
89 /* Return the difference of two time_structs in seconds */
90 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
91 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
92 (double)(pEnd->tv_sec - pStart->tv_sec);
96 ** Print the timing results.
98 static void endTimer(void){
101 getrusage(RUSAGE_SELF, &sEnd);
102 printf("CPU Time: user %f sys %f\n",
103 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
104 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
108 #define BEGIN_TIMER beginTimer()
109 #define END_TIMER endTimer()
112 #elif (defined(_WIN32) || defined(WIN32))
116 /* Saved resource information for the beginning of an operation */
117 static HANDLE hProcess;
118 static FILETIME ftKernelBegin;
119 static FILETIME ftUserBegin;
120 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
121 static GETPROCTIMES getProcessTimesAddr = NULL;
123 /* True if the timer is enabled */
124 static int enableTimer = 0;
127 ** Check to see if we have timer support. Return 1 if necessary
128 ** support found (or found previously).
130 static int hasTimer(void){
131 if( getProcessTimesAddr ){
134 /* GetProcessTimes() isn't supported in WIN95 and some other Windows versions.
135 ** See if the version we are running on has it, and if it does, save off
136 ** a pointer to it and the current process handle.
138 hProcess = GetCurrentProcess();
140 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
141 if( NULL != hinstLib ){
142 getProcessTimesAddr = (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
143 if( NULL != getProcessTimesAddr ){
146 FreeLibrary(hinstLib);
154 ** Begin timing an operation
156 static void beginTimer(void){
157 if( enableTimer && getProcessTimesAddr ){
158 FILETIME ftCreation, ftExit;
159 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin);
163 /* Return the difference of two FILETIME structs in seconds */
164 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
165 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
166 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
167 return (double) ((i64End - i64Start) / 10000000.0);
171 ** Print the timing results.
173 static void endTimer(void){
174 if( enableTimer && getProcessTimesAddr){
175 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
176 getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd);
177 printf("CPU Time: user %f sys %f\n",
178 timeDiff(&ftUserBegin, &ftUserEnd),
179 timeDiff(&ftKernelBegin, &ftKernelEnd));
183 #define BEGIN_TIMER beginTimer()
184 #define END_TIMER endTimer()
185 #define HAS_TIMER hasTimer()
194 ** Used to prevent warnings about unused parameters
196 #define UNUSED_PARAMETER(x) (void)(x)
199 ** If the following flag is set, then command execution stops
200 ** at an error if we are not interactive.
202 static int bail_on_error = 0;
205 ** Threat stdin as an interactive input if the following variable
206 ** is true. Otherwise, assume stdin is connected to a file or pipe.
208 static int stdin_is_interactive = 1;
211 ** The following is the open SQLite database. We make a pointer
212 ** to this database a static variable so that it can be accessed
213 ** by the SIGINT handler to interrupt database processing.
215 static sqlite3 *db = 0;
218 ** True if an interrupt (Control-C) has been received.
220 static volatile int seenInterrupt = 0;
223 ** This is the name of our program. It is set in main(), used
224 ** in a number of other places, mostly for error messages.
229 ** Prompt strings. Initialized in main. Settable with
230 ** .prompt main continue
232 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
233 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
236 ** Write I/O traces to the following stream.
238 #ifdef SQLITE_ENABLE_IOTRACE
239 static FILE *iotrace = 0;
243 ** This routine works like printf in that its first argument is a
244 ** format string and subsequent arguments are values to be substituted
245 ** in place of % fields. The result of formatting this string
246 ** is written to iotrace.
248 #ifdef SQLITE_ENABLE_IOTRACE
249 static void iotracePrintf(const char *zFormat, ...){
252 if( iotrace==0 ) return;
253 va_start(ap, zFormat);
254 z = sqlite3_vmprintf(zFormat, ap);
256 fprintf(iotrace, "%s", z);
263 ** Determines if a string is a number of not.
265 static int isNumber(const char *z, int *realnum){
266 if( *z=='-' || *z=='+' ) z++;
271 if( realnum ) *realnum = 0;
272 while( isdigit(*z) ){ z++; }
275 if( !isdigit(*z) ) return 0;
276 while( isdigit(*z) ){ z++; }
277 if( realnum ) *realnum = 1;
279 if( *z=='e' || *z=='E' ){
281 if( *z=='+' || *z=='-' ) z++;
282 if( !isdigit(*z) ) return 0;
283 while( isdigit(*z) ){ z++; }
284 if( realnum ) *realnum = 1;
290 ** A global char* and an SQL function to access its current value
291 ** from within an SQL statement. This program used to use the
292 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
293 ** The correct way to do this with sqlite3 is to use the bind API, but
294 ** since the shell is built around the callback paradigm it would be a lot
295 ** of work. Instead just use this hack, which is quite harmless.
297 static const char *zShellStatic = 0;
298 static void shellstaticFunc(
299 sqlite3_context *context,
304 assert( zShellStatic );
305 UNUSED_PARAMETER(argc);
306 UNUSED_PARAMETER(argv);
307 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
312 ** This routine reads a line of text from FILE in, stores
313 ** the text in memory obtained from malloc() and returns a pointer
314 ** to the text. NULL is returned at end of file, or if malloc()
317 ** The interface is like "readline" but no command-line editing
320 static char *local_getline(char *zPrompt, FILE *in){
326 if( zPrompt && *zPrompt ){
327 printf("%s",zPrompt);
331 zLine = malloc( nLine );
332 if( zLine==0 ) return 0;
337 nLine = nLine*2 + 100;
338 zLine = realloc(zLine, nLine);
339 if( zLine==0 ) return 0;
341 if( fgets(&zLine[n], nLine - n, in)==0 ){
350 while( zLine[n] ){ n++; }
351 if( n>0 && zLine[n-1]=='\n' ){
353 if( n>0 && zLine[n-1]=='\r' ) n--;
358 zLine = realloc( zLine, n+1 );
363 ** Retrieve a single line of input text.
365 ** zPrior is a string of prior text retrieved. If not the empty
366 ** string, then issue a continuation prompt.
368 static char *one_input_line(const char *zPrior, FILE *in){
372 return local_getline(0, in);
374 if( zPrior && zPrior[0] ){
375 zPrompt = continuePrompt;
377 zPrompt = mainPrompt;
379 zResult = readline(zPrompt);
380 #if defined(HAVE_READLINE) && HAVE_READLINE==1
381 if( zResult && *zResult ) add_history(zResult);
386 struct previous_mode_data {
387 int valid; /* Is there legit data in here? */
394 ** An pointer to an instance of this structure is passed from
395 ** the main program to the callback. This is used to communicate
396 ** state and mode information.
398 struct callback_data {
399 sqlite3 *db; /* The database */
400 int echoOn; /* True to echo input commands */
401 int cnt; /* Number of records displayed so far */
402 FILE *out; /* Write results here */
403 int mode; /* An output mode setting */
404 int writableSchema; /* True if PRAGMA writable_schema=ON */
405 int showHeader; /* True to show column names in List or Column mode */
406 char *zDestTable; /* Name of destination table when MODE_Insert */
407 char separator[20]; /* Separator character for MODE_List */
408 int colWidth[100]; /* Requested width of each column when in column mode*/
409 int actualWidth[100]; /* Actual width of each column */
410 char nullvalue[20]; /* The text to print when a NULL comes back from
412 struct previous_mode_data explainPrev;
413 /* Holds the mode information just before
415 char outfile[FILENAME_MAX]; /* Filename for *out */
416 const char *zDbFilename; /* name of the database file */
417 sqlite3_stmt *pStmt; /* Current statement if any. */
418 FILE *pLog; /* Write log output here */
422 ** These are the allowed modes.
424 #define MODE_Line 0 /* One column per line. Blank line between records */
425 #define MODE_Column 1 /* One record per line in neat columns */
426 #define MODE_List 2 /* One record per line with a separator */
427 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
428 #define MODE_Html 4 /* Generate an XHTML table */
429 #define MODE_Insert 5 /* Generate SQL "insert" statements */
430 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
431 #define MODE_Csv 7 /* Quote strings, numbers are plain */
432 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
434 static const char *modeDescr[] = {
447 ** Number of elements in an array
449 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
452 ** Compute a string length that is limited to what can be stored in
453 ** lower 30 bits of a 32-bit signed integer.
455 static int strlen30(const char *z){
457 while( *z2 ){ z2++; }
458 return 0x3fffffff & (int)(z2 - z);
462 ** A callback for the sqlite3_log() interface.
464 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
465 struct callback_data *p = (struct callback_data*)pArg;
466 if( p->pLog==0 ) return;
467 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
472 ** Output the given string as a hex-encoded blob (eg. X'1234' )
474 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
476 char *zBlob = (char *)pBlob;
478 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]); }
483 ** Output the given string as a quoted string using SQL quoting conventions.
485 static void output_quoted_string(FILE *out, const char *z){
489 if( z[i]=='\'' ) nSingle++;
492 fprintf(out,"'%s'",z);
496 for(i=0; z[i] && z[i]!='\''; i++){}
500 }else if( z[i]=='\'' ){
501 fprintf(out,"%.*s''",i,z);
513 ** Output the given string as a quoted according to C or TCL quoting rules.
515 static void output_c_string(FILE *out, const char *z){
518 while( (c = *(z++))!=0 ){
531 }else if( !isprint(c) ){
532 fprintf(out, "\\%03o", c&0xff);
541 ** Output the given string with characters that are special to
544 static void output_html_string(FILE *out, const char *z){
555 fprintf(out,"%.*s",i,z);
559 }else if( z[i]=='&' ){
560 fprintf(out,"&");
561 }else if( z[i]=='>' ){
563 }else if( z[i]=='\"' ){
564 fprintf(out,""");
565 }else if( z[i]=='\'' ){
566 fprintf(out,"'");
575 ** If a field contains any character identified by a 1 in the following
576 ** array, then the string must be quoted for CSV.
578 static const char needCsvQuote[] = {
579 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
580 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
581 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
582 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
583 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
584 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
585 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
586 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
587 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
588 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
589 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
590 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
591 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
592 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
593 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
594 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
598 ** Output a single term of CSV. Actually, p->separator is used for
599 ** the separator, which may or may not be a comma. p->nullvalue is
600 ** the null value. Strings are quoted using ANSI-C rules. Numbers
601 ** appear outside of quotes.
603 static void output_csv(struct callback_data *p, const char *z, int bSep){
606 fprintf(out,"%s",p->nullvalue);
609 int nSep = strlen30(p->separator);
611 if( needCsvQuote[((unsigned char*)z)[i]]
612 || (z[i]==p->separator[0] &&
613 (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
621 if( z[i]=='"' ) putc('"', out);
626 fprintf(out, "%s", z);
630 fprintf(p->out, "%s", p->separator);
636 ** This routine runs when the user presses Ctrl-C
638 static void interrupt_handler(int NotUsed){
639 UNUSED_PARAMETER(NotUsed);
641 if( db ) sqlite3_interrupt(db);
646 ** This is the callback routine that the shell
647 ** invokes for each row of a query result.
649 static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){
651 struct callback_data *p = (struct callback_data*)pArg;
656 if( azArg==0 ) break;
657 for(i=0; i<nArg; i++){
658 int len = strlen30(azCol[i] ? azCol[i] : "");
661 if( p->cnt++>0 ) fprintf(p->out,"\n");
662 for(i=0; i<nArg; i++){
663 fprintf(p->out,"%*s = %s\n", w, azCol[i],
664 azArg[i] ? azArg[i] : p->nullvalue);
671 for(i=0; i<nArg; i++){
673 if( i<ArraySize(p->colWidth) ){
679 w = strlen30(azCol[i] ? azCol[i] : "");
681 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);
684 if( i<ArraySize(p->actualWidth) ){
685 p->actualWidth[i] = w;
688 fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " ");
692 for(i=0; i<nArg; i++){
694 if( i<ArraySize(p->actualWidth) ){
695 w = p->actualWidth[i];
699 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
700 "----------------------------------------------------------",
701 i==nArg-1 ? "\n": " ");
705 if( azArg==0 ) break;
706 for(i=0; i<nArg; i++){
708 if( i<ArraySize(p->actualWidth) ){
709 w = p->actualWidth[i];
713 if( p->mode==MODE_Explain && azArg[i] &&
714 strlen30(azArg[i])>w ){
715 w = strlen30(azArg[i]);
717 fprintf(p->out,"%-*.*s%s",w,w,
718 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
724 if( p->cnt++==0 && p->showHeader ){
725 for(i=0; i<nArg; i++){
726 fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
729 if( azArg==0 ) break;
730 for(i=0; i<nArg; i++){
732 if( z==0 ) z = p->nullvalue;
733 fprintf(p->out, "%s", z);
735 fprintf(p->out, "%s", p->separator);
736 }else if( p->mode==MODE_Semi ){
737 fprintf(p->out, ";\n");
739 fprintf(p->out, "\n");
745 if( p->cnt++==0 && p->showHeader ){
746 fprintf(p->out,"<TR>");
747 for(i=0; i<nArg; i++){
748 fprintf(p->out,"<TH>");
749 output_html_string(p->out, azCol[i]);
750 fprintf(p->out,"</TH>\n");
752 fprintf(p->out,"</TR>\n");
754 if( azArg==0 ) break;
755 fprintf(p->out,"<TR>");
756 for(i=0; i<nArg; i++){
757 fprintf(p->out,"<TD>");
758 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
759 fprintf(p->out,"</TD>\n");
761 fprintf(p->out,"</TR>\n");
765 if( p->cnt++==0 && p->showHeader ){
766 for(i=0; i<nArg; i++){
767 output_c_string(p->out,azCol[i] ? azCol[i] : "");
768 fprintf(p->out, "%s", p->separator);
770 fprintf(p->out,"\n");
772 if( azArg==0 ) break;
773 for(i=0; i<nArg; i++){
774 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
775 fprintf(p->out, "%s", p->separator);
777 fprintf(p->out,"\n");
781 if( p->cnt++==0 && p->showHeader ){
782 for(i=0; i<nArg; i++){
783 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
785 fprintf(p->out,"\n");
787 if( azArg==0 ) break;
788 for(i=0; i<nArg; i++){
789 output_csv(p, azArg[i], i<nArg-1);
791 fprintf(p->out,"\n");
796 if( azArg==0 ) break;
797 fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
798 for(i=0; i<nArg; i++){
799 char *zSep = i>0 ? ",": "";
800 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
801 fprintf(p->out,"%sNULL",zSep);
802 }else if( aiType && aiType[i]==SQLITE_TEXT ){
803 if( zSep[0] ) fprintf(p->out,"%s",zSep);
804 output_quoted_string(p->out, azArg[i]);
805 }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){
806 fprintf(p->out,"%s%s",zSep, azArg[i]);
807 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
808 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
809 int nBlob = sqlite3_column_bytes(p->pStmt, i);
810 if( zSep[0] ) fprintf(p->out,"%s",zSep);
811 output_hex_blob(p->out, pBlob, nBlob);
812 }else if( isNumber(azArg[i], 0) ){
813 fprintf(p->out,"%s%s",zSep, azArg[i]);
815 if( zSep[0] ) fprintf(p->out,"%s",zSep);
816 output_quoted_string(p->out, azArg[i]);
819 fprintf(p->out,");\n");
827 ** This is the callback routine that the SQLite library
828 ** invokes for each row of a query result.
830 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
831 /* since we don't have type info, call the shell_callback with a NULL value */
832 return shell_callback(pArg, nArg, azArg, azCol, NULL);
836 ** Set the destination table field of the callback_data structure to
837 ** the name of the table given. Escape any quote characters in the
840 static void set_table_name(struct callback_data *p, const char *zName){
849 if( zName==0 ) return;
850 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
851 for(i=n=0; zName[i]; i++, n++){
852 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
854 if( zName[i]=='\'' ) n++;
857 if( needQuote ) n += 2;
858 z = p->zDestTable = malloc( n+1 );
860 fprintf(stderr,"Error: out of memory\n");
864 if( needQuote ) z[n++] = '\'';
865 for(i=0; zName[i]; i++){
867 if( zName[i]=='\'' ) z[n++] = '\'';
869 if( needQuote ) z[n++] = '\'';
873 /* zIn is either a pointer to a NULL-terminated string in memory obtained
874 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
875 ** added to zIn, and the result returned in memory obtained from malloc().
876 ** zIn, if it was not NULL, is freed.
878 ** If the third argument, quote, is not '\0', then it is used as a
879 ** quote character for zAppend.
881 static char *appendText(char *zIn, char const *zAppend, char quote){
884 int nAppend = strlen30(zAppend);
885 int nIn = (zIn?strlen30(zIn):0);
890 for(i=0; i<nAppend; i++){
891 if( zAppend[i]==quote ) len++;
895 zIn = (char *)realloc(zIn, len);
901 char *zCsr = &zIn[nIn];
903 for(i=0; i<nAppend; i++){
904 *zCsr++ = zAppend[i];
905 if( zAppend[i]==quote ) *zCsr++ = quote;
909 assert( (zCsr-zIn)==len );
911 memcpy(&zIn[nIn], zAppend, nAppend);
920 ** Execute a query statement that has a single result column. Print
921 ** that result column on a line by itself with a semicolon terminator.
923 ** This is used, for example, to show the schema of the database by
924 ** querying the SQLITE_MASTER table.
926 static int run_table_dump_query(
927 FILE *out, /* Send output here */
928 sqlite3 *db, /* Database to query */
929 const char *zSelect, /* SELECT statement to extract content */
930 const char *zFirstRow /* Print before first row, if not NULL */
932 sqlite3_stmt *pSelect;
934 rc = sqlite3_prepare(db, zSelect, -1, &pSelect, 0);
935 if( rc!=SQLITE_OK || !pSelect ){
938 rc = sqlite3_step(pSelect);
939 while( rc==SQLITE_ROW ){
941 fprintf(out, "%s", zFirstRow);
944 fprintf(out, "%s;\n", sqlite3_column_text(pSelect, 0));
945 rc = sqlite3_step(pSelect);
947 return sqlite3_finalize(pSelect);
951 ** Allocate space and save off current error string.
953 static char *save_err_msg(
954 sqlite3 *db /* Database to query */
956 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
957 char *zErrMsg = sqlite3_malloc(nErrMsg);
959 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
965 ** Execute a statement or set of statements. Print
966 ** any result rows/columns depending on the current mode
967 ** set via the supplied callback.
969 ** This is very similar to SQLite's built-in sqlite3_exec()
970 ** function except it takes a slightly different callback
971 ** and callback data argument.
973 static int shell_exec(
974 sqlite3 *db, /* An open database */
975 const char *zSql, /* SQL to be evaluated */
976 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
977 /* (not the same as sqlite3_exec) */
978 struct callback_data *pArg, /* Pointer to struct callback_data */
979 char **pzErrMsg /* Error msg written here */
981 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
982 int rc = SQLITE_OK; /* Return Code */
983 const char *zLeftover; /* Tail of unprocessed SQL */
989 while( zSql[0] && (SQLITE_OK == rc) ){
990 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
991 if( SQLITE_OK != rc ){
993 *pzErrMsg = save_err_msg(db);
997 /* this happens for a comment or white-space */
999 while( isspace(zSql[0]) ) zSql++;
1003 /* echo the sql statement if echo on */
1005 const char *zStmtSql = sqlite3_sql(pStmt);
1006 fprintf(pArg->out,"%s\n", zStmtSql ? zStmtSql : zSql);
1009 /* perform the first step. this will tell us if we
1010 ** have a result set or not and how wide it is.
1012 rc = sqlite3_step(pStmt);
1013 /* if we have a result set... */
1014 if( SQLITE_ROW == rc ){
1015 /* if we have a callback... */
1017 /* allocate space for col name ptr, value ptr, and type */
1018 int nCol = sqlite3_column_count(pStmt);
1019 void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1023 char **azCols = (char **)pData; /* Names of result columns */
1024 char **azVals = &azCols[nCol]; /* Results */
1025 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1027 assert(sizeof(int) <= sizeof(char *));
1028 /* save off ptrs to column names */
1029 for(i=0; i<nCol; i++){
1030 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1032 /* save off the prepared statment handle and reset row count */
1034 pArg->pStmt = pStmt;
1038 /* extract the data and data types */
1039 for(i=0; i<nCol; i++){
1040 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
1041 aiTypes[i] = sqlite3_column_type(pStmt, i);
1042 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1044 break; /* from for */
1048 /* if data and types extracted successfully... */
1049 if( SQLITE_ROW == rc ){
1050 /* call the supplied callback with the result row data */
1051 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1054 rc = sqlite3_step(pStmt);
1057 } while( SQLITE_ROW == rc );
1058 sqlite3_free(pData);
1065 rc = sqlite3_step(pStmt);
1066 } while( rc == SQLITE_ROW );
1070 /* Finalize the statement just executed. If this fails, save a
1071 ** copy of the error message. Otherwise, set zSql to point to the
1072 ** next statement to execute. */
1073 rc = sqlite3_finalize(pStmt);
1074 if( rc==SQLITE_OK ){
1076 while( isspace(zSql[0]) ) zSql++;
1077 }else if( pzErrMsg ){
1078 *pzErrMsg = save_err_msg(db);
1088 ** This is a different callback routine used for dumping the database.
1089 ** Each row received by this callback consists of a table name,
1090 ** the table type ("index" or "table") and SQL to create the table.
1091 ** This routine should print text sufficient to recreate the table.
1093 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1098 const char *zPrepStmt = 0;
1099 struct callback_data *p = (struct callback_data *)pArg;
1101 UNUSED_PARAMETER(azCol);
1102 if( nArg!=3 ) return 1;
1107 if( strcmp(zTable, "sqlite_sequence")==0 ){
1108 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1109 }else if( strcmp(zTable, "sqlite_stat1")==0 ){
1110 fprintf(p->out, "ANALYZE sqlite_master;\n");
1111 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1113 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1115 if( !p->writableSchema ){
1116 fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1117 p->writableSchema = 1;
1119 zIns = sqlite3_mprintf(
1120 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1121 "VALUES('table','%q','%q',0,'%q');",
1122 zTable, zTable, zSql);
1123 fprintf(p->out, "%s\n", zIns);
1127 fprintf(p->out, "%s;\n", zSql);
1130 if( strcmp(zType, "table")==0 ){
1131 sqlite3_stmt *pTableInfo = 0;
1133 char *zTableInfo = 0;
1137 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1138 zTableInfo = appendText(zTableInfo, zTable, '"');
1139 zTableInfo = appendText(zTableInfo, ");", 0);
1141 rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1143 if( rc!=SQLITE_OK || !pTableInfo ){
1147 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1148 zTmp = appendText(zTmp, zTable, '"');
1150 zSelect = appendText(zSelect, zTmp, '\'');
1152 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1153 rc = sqlite3_step(pTableInfo);
1154 while( rc==SQLITE_ROW ){
1155 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1156 zSelect = appendText(zSelect, "quote(", 0);
1157 zSelect = appendText(zSelect, zText, '"');
1158 rc = sqlite3_step(pTableInfo);
1159 if( rc==SQLITE_ROW ){
1160 zSelect = appendText(zSelect, ") || ',' || ", 0);
1162 zSelect = appendText(zSelect, ") ", 0);
1166 rc = sqlite3_finalize(pTableInfo);
1167 if( rc!=SQLITE_OK || nRow==0 ){
1171 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1172 zSelect = appendText(zSelect, zTable, '"');
1174 rc = run_table_dump_query(p->out, p->db, zSelect, zPrepStmt);
1175 if( rc==SQLITE_CORRUPT ){
1176 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1177 rc = run_table_dump_query(p->out, p->db, zSelect, 0);
1179 if( zSelect ) free(zSelect);
1185 ** Run zQuery. Use dump_callback() as the callback routine so that
1186 ** the contents of the query are output as SQL statements.
1188 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1189 ** "ORDER BY rowid DESC" to the end.
1191 static int run_schema_dump_query(
1192 struct callback_data *p,
1197 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg);
1198 if( rc==SQLITE_CORRUPT ){
1200 int len = strlen30(zQuery);
1201 if( pzErrMsg ) sqlite3_free(*pzErrMsg);
1202 zQ2 = malloc( len+100 );
1203 if( zQ2==0 ) return rc;
1204 sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery);
1205 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg);
1212 ** Text of a help message
1214 static char zHelp[] =
1215 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1216 ".bail ON|OFF Stop after hitting an error. Default OFF\n"
1217 ".databases List names and files of attached databases\n"
1218 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1219 " If TABLE specified, only dump tables matching\n"
1220 " LIKE pattern TABLE.\n"
1221 ".echo ON|OFF Turn command echo on or off\n"
1222 ".exit Exit this program\n"
1223 ".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.\n"
1224 " With no args, it turns EXPLAIN on.\n"
1225 ".header(s) ON|OFF Turn display of headers on or off\n"
1226 ".help Show this message\n"
1227 ".import FILE TABLE Import data from FILE into TABLE\n"
1228 ".indices ?TABLE? Show names of all indices\n"
1229 " If TABLE specified, only show indices for tables\n"
1230 " matching LIKE pattern TABLE.\n"
1231 #ifdef SQLITE_ENABLE_IOTRACE
1232 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1234 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1235 ".load FILE ?ENTRY? Load an extension library\n"
1237 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1238 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1239 " csv Comma-separated values\n"
1240 " column Left-aligned columns. (See .width)\n"
1241 " html HTML <table> code\n"
1242 " insert SQL insert statements for TABLE\n"
1243 " line One value per line\n"
1244 " list Values delimited by .separator string\n"
1245 " tabs Tab-separated values\n"
1246 " tcl TCL list elements\n"
1247 ".nullvalue STRING Print STRING in place of NULL values\n"
1248 ".output FILENAME Send output to FILENAME\n"
1249 ".output stdout Send output to the screen\n"
1250 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1251 ".quit Exit this program\n"
1252 ".read FILENAME Execute SQL in FILENAME\n"
1253 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1254 ".schema ?TABLE? Show the CREATE statements\n"
1255 " If TABLE specified, only show tables matching\n"
1256 " LIKE pattern TABLE.\n"
1257 ".separator STRING Change separator used by output mode and .import\n"
1258 ".show Show the current values for various settings\n"
1259 ".tables ?TABLE? List names of tables\n"
1260 " If TABLE specified, only list tables matching\n"
1261 " LIKE pattern TABLE.\n"
1262 ".timeout MS Try opening locked tables for MS milliseconds\n"
1263 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1266 static char zTimerHelp[] =
1267 ".timer ON|OFF Turn the CPU timer measurement on or off\n"
1270 /* Forward reference */
1271 static int process_input(struct callback_data *p, FILE *in);
1274 ** Make sure the database is open. If it is not, then open it. If
1275 ** the database fails to open, print an error message and exit.
1277 static void open_db(struct callback_data *p){
1279 sqlite3_open(p->zDbFilename, &p->db);
1281 if( db && sqlite3_errcode(db)==SQLITE_OK ){
1282 sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1283 shellstaticFunc, 0, 0);
1285 if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1286 fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1287 p->zDbFilename, sqlite3_errmsg(db));
1290 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1291 sqlite3_enable_load_extension(p->db, 1);
1297 ** Do C-language style dequoting.
1301 ** \r -> carriage return
1302 ** \NNN -> ascii character NNN in octal
1305 static void resolve_backslashes(char *z){
1308 for(i=j=0; (c = z[i])!=0; i++, j++){
1317 }else if( c>='0' && c<='7' ){
1319 if( z[i+1]>='0' && z[i+1]<='7' ){
1321 c = (c<<3) + z[i] - '0';
1322 if( z[i+1]>='0' && z[i+1]<='7' ){
1324 c = (c<<3) + z[i] - '0';
1335 ** Interpret zArg as a boolean value. Return either 0 or 1.
1337 static int booleanValue(char *zArg){
1338 int val = atoi(zArg);
1340 for(j=0; zArg[j]; j++){
1341 zArg[j] = (char)tolower(zArg[j]);
1343 if( strcmp(zArg,"on")==0 ){
1345 }else if( strcmp(zArg,"yes")==0 ){
1352 ** If an input line begins with "." then invoke this routine to
1353 ** process that line.
1355 ** Return 1 on error, 2 to exit, and 0 otherwise.
1357 static int do_meta_command(char *zLine, struct callback_data *p){
1364 /* Parse the input line into tokens.
1366 while( zLine[i] && nArg<ArraySize(azArg) ){
1367 while( isspace((unsigned char)zLine[i]) ){ i++; }
1368 if( zLine[i]==0 ) break;
1369 if( zLine[i]=='\'' || zLine[i]=='"' ){
1370 int delim = zLine[i++];
1371 azArg[nArg++] = &zLine[i];
1372 while( zLine[i] && zLine[i]!=delim ){ i++; }
1373 if( zLine[i]==delim ){
1376 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1378 azArg[nArg++] = &zLine[i];
1379 while( zLine[i] && !isspace((unsigned char)zLine[i]) ){ i++; }
1380 if( zLine[i] ) zLine[i++] = 0;
1381 resolve_backslashes(azArg[nArg-1]);
1385 /* Process the input line.
1387 if( nArg==0 ) return 0; /* no tokens, no error */
1388 n = strlen30(azArg[0]);
1390 if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 && nArg>1 && nArg<4){
1391 const char *zDestFile;
1394 sqlite3_backup *pBackup;
1396 zDestFile = azArg[1];
1399 zDestFile = azArg[2];
1402 rc = sqlite3_open(zDestFile, &pDest);
1403 if( rc!=SQLITE_OK ){
1404 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
1405 sqlite3_close(pDest);
1409 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
1411 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1412 sqlite3_close(pDest);
1415 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
1416 sqlite3_backup_finish(pBackup);
1417 if( rc==SQLITE_DONE ){
1420 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1423 sqlite3_close(pDest);
1426 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){
1427 bail_on_error = booleanValue(azArg[1]);
1430 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
1431 struct callback_data data;
1434 memcpy(&data, p, sizeof(data));
1435 data.showHeader = 1;
1436 data.mode = MODE_Column;
1437 data.colWidth[0] = 3;
1438 data.colWidth[1] = 15;
1439 data.colWidth[2] = 58;
1441 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
1443 fprintf(stderr,"Error: %s\n", zErrMsg);
1444 sqlite3_free(zErrMsg);
1449 if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
1452 /* When playing back a "dump", the content might appear in an order
1453 ** which causes immediate foreign key constraints to be violated.
1454 ** So disable foreign-key constraint enforcement to prevent problems. */
1455 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
1456 fprintf(p->out, "BEGIN TRANSACTION;\n");
1457 p->writableSchema = 0;
1458 sqlite3_exec(p->db, "PRAGMA writable_schema=ON", 0, 0, 0);
1460 run_schema_dump_query(p,
1461 "SELECT name, type, sql FROM sqlite_master "
1462 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'", 0
1464 run_schema_dump_query(p,
1465 "SELECT name, type, sql FROM sqlite_master "
1466 "WHERE name=='sqlite_sequence'", 0
1468 run_table_dump_query(p->out, p->db,
1469 "SELECT sql FROM sqlite_master "
1470 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
1474 for(i=1; i<nArg; i++){
1475 zShellStatic = azArg[i];
1476 run_schema_dump_query(p,
1477 "SELECT name, type, sql FROM sqlite_master "
1478 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
1479 " AND sql NOT NULL", 0);
1480 run_table_dump_query(p->out, p->db,
1481 "SELECT sql FROM sqlite_master "
1482 "WHERE sql NOT NULL"
1483 " AND type IN ('index','trigger','view')"
1484 " AND tbl_name LIKE shellstatic()", 0
1489 if( p->writableSchema ){
1490 fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
1491 p->writableSchema = 0;
1493 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF", 0, 0, 0);
1495 fprintf(stderr,"Error: %s\n", zErrMsg);
1496 sqlite3_free(zErrMsg);
1498 fprintf(p->out, "COMMIT;\n");
1502 if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){
1503 p->echoOn = booleanValue(azArg[1]);
1506 if( c=='e' && strncmp(azArg[0], "exit", n)==0 && nArg==1 ){
1510 if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){
1511 int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
1513 if(!p->explainPrev.valid) {
1514 p->explainPrev.valid = 1;
1515 p->explainPrev.mode = p->mode;
1516 p->explainPrev.showHeader = p->showHeader;
1517 memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
1519 /* We could put this code under the !p->explainValid
1520 ** condition so that it does not execute if we are already in
1521 ** explain mode. However, always executing it allows us an easy
1522 ** was to reset to explain mode in case the user previously
1523 ** did an .explain followed by a .width, .mode or .header
1526 p->mode = MODE_Explain;
1528 memset(p->colWidth,0,ArraySize(p->colWidth));
1529 p->colWidth[0] = 4; /* addr */
1530 p->colWidth[1] = 13; /* opcode */
1531 p->colWidth[2] = 4; /* P1 */
1532 p->colWidth[3] = 4; /* P2 */
1533 p->colWidth[4] = 4; /* P3 */
1534 p->colWidth[5] = 13; /* P4 */
1535 p->colWidth[6] = 2; /* P5 */
1536 p->colWidth[7] = 13; /* Comment */
1537 }else if (p->explainPrev.valid) {
1538 p->explainPrev.valid = 0;
1539 p->mode = p->explainPrev.mode;
1540 p->showHeader = p->explainPrev.showHeader;
1541 memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
1545 if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
1546 strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){
1547 p->showHeader = booleanValue(azArg[1]);
1550 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1551 fprintf(stderr,"%s",zHelp);
1553 fprintf(stderr,"%s",zTimerHelp);
1557 if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1558 char *zTable = azArg[2]; /* Insert data into this table */
1559 char *zFile = azArg[1]; /* The file from which to extract data */
1560 sqlite3_stmt *pStmt = NULL; /* A statement */
1561 int nCol; /* Number of columns in the table */
1562 int nByte; /* Number of bytes in an SQL string */
1563 int i, j; /* Loop counters */
1564 int nSep; /* Number of bytes in p->separator[] */
1565 char *zSql; /* An SQL statement */
1566 char *zLine; /* A single line of input from the file */
1567 char **azCol; /* zLine[] broken up into columns */
1568 char *zCommit; /* How to commit changes */
1569 FILE *in; /* The input file */
1570 int lineno = 0; /* Line number of input file */
1573 nSep = strlen30(p->separator);
1575 fprintf(stderr, "Error: non-null separator required for import\n");
1578 zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
1580 fprintf(stderr, "Error: out of memory\n");
1583 nByte = strlen30(zSql);
1584 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1587 if (pStmt) sqlite3_finalize(pStmt);
1588 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1591 nCol = sqlite3_column_count(pStmt);
1592 sqlite3_finalize(pStmt);
1594 if( nCol==0 ) return 0; /* no columns, no error */
1595 zSql = malloc( nByte + 20 + nCol*2 );
1597 fprintf(stderr, "Error: out of memory\n");
1600 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable);
1602 for(i=1; i<nCol; i++){
1608 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1611 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
1612 if (pStmt) sqlite3_finalize(pStmt);
1615 in = fopen(zFile, "rb");
1617 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1618 sqlite3_finalize(pStmt);
1621 azCol = malloc( sizeof(azCol[0])*(nCol+1) );
1623 fprintf(stderr, "Error: out of memory\n");
1625 sqlite3_finalize(pStmt);
1628 sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
1630 while( (zLine = local_getline(0, in))!=0 ){
1635 for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){
1636 if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){
1640 azCol[i] = &z[nSep];
1648 "Error: %s line %d: expected %d columns of data but found %d\n",
1649 zFile, lineno, nCol, i+1);
1650 zCommit = "ROLLBACK";
1653 break; /* from while */
1655 for(i=0; i<nCol; i++){
1656 sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
1658 sqlite3_step(pStmt);
1659 rc = sqlite3_reset(pStmt);
1661 if( rc!=SQLITE_OK ){
1662 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1663 zCommit = "ROLLBACK";
1665 break; /* from while */
1670 sqlite3_finalize(pStmt);
1671 sqlite3_exec(p->db, zCommit, 0, 0, 0);
1674 if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){
1675 struct callback_data data;
1678 memcpy(&data, p, sizeof(data));
1679 data.showHeader = 0;
1680 data.mode = MODE_List;
1682 rc = sqlite3_exec(p->db,
1683 "SELECT name FROM sqlite_master "
1684 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
1686 "SELECT name FROM sqlite_temp_master "
1687 "WHERE type='index' "
1689 callback, &data, &zErrMsg
1692 zShellStatic = azArg[1];
1693 rc = sqlite3_exec(p->db,
1694 "SELECT name FROM sqlite_master "
1695 "WHERE type='index' AND tbl_name LIKE shellstatic() "
1697 "SELECT name FROM sqlite_temp_master "
1698 "WHERE type='index' AND tbl_name LIKE shellstatic() "
1700 callback, &data, &zErrMsg
1705 fprintf(stderr,"Error: %s\n", zErrMsg);
1706 sqlite3_free(zErrMsg);
1708 }else if( rc != SQLITE_OK ){
1709 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
1714 #ifdef SQLITE_ENABLE_IOTRACE
1715 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
1716 extern void (*sqlite3IoTrace)(const char*, ...);
1717 if( iotrace && iotrace!=stdout ) fclose(iotrace);
1721 }else if( strcmp(azArg[1], "-")==0 ){
1722 sqlite3IoTrace = iotracePrintf;
1725 iotrace = fopen(azArg[1], "w");
1727 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
1731 sqlite3IoTrace = iotracePrintf;
1737 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1738 if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
1739 const char *zFile, *zProc;
1742 zProc = nArg>=3 ? azArg[2] : 0;
1744 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
1745 if( rc!=SQLITE_OK ){
1746 fprintf(stderr, "Error: %s\n", zErrMsg);
1747 sqlite3_free(zErrMsg);
1753 if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=1 ){
1754 const char *zFile = azArg[1];
1755 if( p->pLog && p->pLog!=stdout && p->pLog!=stderr ){
1759 if( strcmp(zFile,"stdout")==0 ){
1761 }else if( strcmp(zFile, "stderr")==0 ){
1763 }else if( strcmp(zFile, "off")==0 ){
1766 p->pLog = fopen(zFile, "w");
1768 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1773 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){
1774 int n2 = strlen30(azArg[1]);
1775 if( (n2==4 && strncmp(azArg[1],"line",n2)==0)
1777 (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){
1778 p->mode = MODE_Line;
1779 }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0)
1781 (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){
1782 p->mode = MODE_Column;
1783 }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){
1784 p->mode = MODE_List;
1785 }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){
1786 p->mode = MODE_Html;
1787 }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){
1789 }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){
1791 sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
1792 }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){
1793 p->mode = MODE_List;
1794 sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
1795 }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
1796 p->mode = MODE_Insert;
1797 set_table_name(p, "table");
1799 fprintf(stderr,"Error: mode should be one of: "
1800 "column csv html insert line list tabs tcl\n");
1805 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){
1806 int n2 = strlen30(azArg[1]);
1807 if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
1808 p->mode = MODE_Insert;
1809 set_table_name(p, azArg[2]);
1811 fprintf(stderr, "Error: invalid arguments: "
1812 " \"%s\". Enter \".help\" for help\n", azArg[2]);
1817 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
1818 sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
1819 "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
1822 if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
1823 if( p->out!=stdout ){
1826 if( strcmp(azArg[1],"stdout")==0 ){
1828 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "stdout");
1830 p->out = fopen(azArg[1], "wb");
1832 fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]);
1836 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
1841 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
1843 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
1846 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
1850 if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){
1854 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
1855 FILE *alt = fopen(azArg[1], "rb");
1857 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
1860 rc = process_input(p, alt);
1865 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){
1866 const char *zSrcFile;
1869 sqlite3_backup *pBackup;
1873 zSrcFile = azArg[1];
1876 zSrcFile = azArg[2];
1879 rc = sqlite3_open(zSrcFile, &pSrc);
1880 if( rc!=SQLITE_OK ){
1881 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
1882 sqlite3_close(pSrc);
1886 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
1888 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
1889 sqlite3_close(pSrc);
1892 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
1893 || rc==SQLITE_BUSY ){
1894 if( rc==SQLITE_BUSY ){
1895 if( nTimeout++ >= 3 ) break;
1899 sqlite3_backup_finish(pBackup);
1900 if( rc==SQLITE_DONE ){
1902 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
1903 fprintf(stderr, "Error: source database is busy\n");
1906 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
1909 sqlite3_close(pSrc);
1912 if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){
1913 struct callback_data data;
1916 memcpy(&data, p, sizeof(data));
1917 data.showHeader = 0;
1918 data.mode = MODE_Semi;
1921 for(i=0; azArg[1][i]; i++) azArg[1][i] = (char)tolower(azArg[1][i]);
1922 if( strcmp(azArg[1],"sqlite_master")==0 ){
1923 char *new_argv[2], *new_colv[2];
1924 new_argv[0] = "CREATE TABLE sqlite_master (\n"
1928 " rootpage integer,\n"
1932 new_colv[0] = "sql";
1934 callback(&data, 1, new_argv, new_colv);
1936 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
1937 char *new_argv[2], *new_colv[2];
1938 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
1942 " rootpage integer,\n"
1946 new_colv[0] = "sql";
1948 callback(&data, 1, new_argv, new_colv);
1951 zShellStatic = azArg[1];
1952 rc = sqlite3_exec(p->db,
1954 " (SELECT sql sql, type type, tbl_name tbl_name, name name"
1955 " FROM sqlite_master UNION ALL"
1956 " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) "
1957 "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL "
1958 "ORDER BY substr(type,2,1), name",
1959 callback, &data, &zErrMsg);
1963 rc = sqlite3_exec(p->db,
1965 " (SELECT sql sql, type type, tbl_name tbl_name, name name"
1966 " FROM sqlite_master UNION ALL"
1967 " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) "
1968 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
1969 "ORDER BY substr(type,2,1), name",
1970 callback, &data, &zErrMsg
1974 fprintf(stderr,"Error: %s\n", zErrMsg);
1975 sqlite3_free(zErrMsg);
1977 }else if( rc != SQLITE_OK ){
1978 fprintf(stderr,"Error: querying schema information\n");
1985 if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
1986 sqlite3_snprintf(sizeof(p->separator), p->separator,
1987 "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
1990 if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){
1992 fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
1993 fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
1994 fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
1995 fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
1996 fprintf(p->out,"%9.9s: ", "nullvalue");
1997 output_c_string(p->out, p->nullvalue);
1998 fprintf(p->out, "\n");
1999 fprintf(p->out,"%9.9s: %s\n","output",
2000 strlen30(p->outfile) ? p->outfile : "stdout");
2001 fprintf(p->out,"%9.9s: ", "separator");
2002 output_c_string(p->out, p->separator);
2003 fprintf(p->out, "\n");
2004 fprintf(p->out,"%9.9s: ","width");
2005 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
2006 fprintf(p->out,"%d ",p->colWidth[i]);
2008 fprintf(p->out,"\n");
2011 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){
2017 rc = sqlite3_get_table(p->db,
2018 "SELECT name FROM sqlite_master "
2019 "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' "
2021 "SELECT name FROM sqlite_temp_master "
2022 "WHERE type IN ('table','view') "
2024 &azResult, &nRow, 0, &zErrMsg
2027 zShellStatic = azArg[1];
2028 rc = sqlite3_get_table(p->db,
2029 "SELECT name FROM sqlite_master "
2030 "WHERE type IN ('table','view') AND name LIKE shellstatic() "
2032 "SELECT name FROM sqlite_temp_master "
2033 "WHERE type IN ('table','view') AND name LIKE shellstatic() "
2035 &azResult, &nRow, 0, &zErrMsg
2040 fprintf(stderr,"Error: %s\n", zErrMsg);
2041 sqlite3_free(zErrMsg);
2043 }else if( rc != SQLITE_OK ){
2044 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
2047 int len, maxlen = 0;
2049 int nPrintCol, nPrintRow;
2050 for(i=1; i<=nRow; i++){
2051 if( azResult[i]==0 ) continue;
2052 len = strlen30(azResult[i]);
2053 if( len>maxlen ) maxlen = len;
2055 nPrintCol = 80/(maxlen+2);
2056 if( nPrintCol<1 ) nPrintCol = 1;
2057 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
2058 for(i=0; i<nPrintRow; i++){
2059 for(j=i+1; j<=nRow; j+=nPrintRow){
2060 char *zSp = j<=nPrintRow ? "" : " ";
2061 printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
2066 sqlite3_free_table(azResult);
2069 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){
2071 sqlite3_busy_timeout(p->db, atoi(azArg[1]));
2074 if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg==2 ){
2075 enableTimer = booleanValue(azArg[1]);
2078 if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){
2080 assert( nArg<=ArraySize(azArg) );
2081 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
2082 p->colWidth[j-1] = atoi(azArg[j]);
2087 fprintf(stderr, "Error: unknown command or invalid arguments: "
2088 " \"%s\". Enter \".help\" for help\n", azArg[0]);
2096 ** Return TRUE if a semicolon occurs anywhere in the first N characters
2099 static int _contains_semicolon(const char *z, int N){
2101 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
2106 ** Test to see if a line consists entirely of whitespace.
2108 static int _all_whitespace(const char *z){
2110 if( isspace(*(unsigned char*)z) ) continue;
2111 if( *z=='/' && z[1]=='*' ){
2113 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
2114 if( *z==0 ) return 0;
2118 if( *z=='-' && z[1]=='-' ){
2120 while( *z && *z!='\n' ){ z++; }
2121 if( *z==0 ) return 1;
2130 ** Return TRUE if the line typed in is an SQL command terminator other
2131 ** than a semi-colon. The SQL Server style "go" command is understood
2132 ** as is the Oracle "/".
2134 static int _is_command_terminator(const char *zLine){
2135 while( isspace(*(unsigned char*)zLine) ){ zLine++; };
2136 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
2137 return 1; /* Oracle */
2139 if( tolower(zLine[0])=='g' && tolower(zLine[1])=='o'
2140 && _all_whitespace(&zLine[2]) ){
2141 return 1; /* SQL Server */
2147 ** Return true if zSql is a complete SQL statement. Return false if it
2148 ** ends in the middle of a string literal or C-style comment.
2150 static int _is_complete(char *zSql, int nSql){
2152 if( zSql==0 ) return 1;
2155 rc = sqlite3_complete(zSql);
2161 ** Read input from *in and process it. If *in==0 then input
2162 ** is interactive - the user is typing it it. Otherwise, input
2163 ** is coming from a file or device. A prompt is issued and history
2164 ** is saved only if input is interactive. An interrupt signal will
2165 ** cause this routine to exit immediately, unless input is interactive.
2167 ** Return the number of errors.
2169 static int process_input(struct callback_data *p, FILE *in){
2180 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
2183 zLine = one_input_line(zSql, in);
2185 break; /* We have reached EOF */
2187 if( seenInterrupt ){
2192 if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
2193 if( zLine && zLine[0]=='.' && nSql==0 ){
2194 if( p->echoOn ) printf("%s\n", zLine);
2195 rc = do_meta_command(zLine, p);
2196 if( rc==2 ){ /* exit requested */
2203 if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){
2204 memcpy(zLine,";",2);
2209 for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){}
2211 nSql = strlen30(zLine);
2212 zSql = malloc( nSql+3 );
2214 fprintf(stderr, "Error: out of memory\n");
2217 memcpy(zSql, zLine, nSql+1);
2221 int len = strlen30(zLine);
2222 zSql = realloc( zSql, nSql + len + 4 );
2224 fprintf(stderr,"Error: out of memory\n");
2227 zSql[nSql++] = '\n';
2228 memcpy(&zSql[nSql], zLine, len+1);
2231 if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
2232 && sqlite3_complete(zSql) ){
2236 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
2238 if( rc || zErrMsg ){
2240 if( in!=0 || !stdin_is_interactive ){
2241 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
2242 "Error: near line %d:", startline);
2244 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
2247 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
2248 sqlite3_free(zErrMsg);
2251 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
2261 if( !_all_whitespace(zSql) ) fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
2269 ** Return a pathname which is the user's home directory. A
2270 ** 0 return indicates an error of some kind. Space to hold the
2271 ** resulting string is obtained from malloc(). The calling
2272 ** function should free the result.
2274 static char *find_home_dir(void){
2275 char *home_dir = NULL;
2277 #if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)
2278 struct passwd *pwent;
2279 uid_t uid = getuid();
2280 if( (pwent=getpwuid(uid)) != NULL) {
2281 home_dir = pwent->pw_dir;
2285 #if defined(_WIN32_WCE)
2286 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
2288 home_dir = strdup("/");
2291 #if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
2293 home_dir = getenv("USERPROFILE");
2298 home_dir = getenv("HOME");
2301 #if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
2303 char *zDrive, *zPath;
2305 zDrive = getenv("HOMEDRIVE");
2306 zPath = getenv("HOMEPATH");
2307 if( zDrive && zPath ){
2308 n = strlen30(zDrive) + strlen30(zPath) + 1;
2309 home_dir = malloc( n );
2310 if( home_dir==0 ) return 0;
2311 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
2318 #endif /* !_WIN32_WCE */
2321 int n = strlen30(home_dir) + 1;
2322 char *z = malloc( n );
2323 if( z ) memcpy(z, home_dir, n);
2331 ** Read input from the file given by sqliterc_override. Or if that
2332 ** parameter is NULL, take input from ~/.sqliterc
2334 ** Returns the number of errors.
2336 static int process_sqliterc(
2337 struct callback_data *p, /* Configuration data */
2338 const char *sqliterc_override /* Name of config file. NULL to use default */
2340 char *home_dir = NULL;
2341 const char *sqliterc = sqliterc_override;
2347 if (sqliterc == NULL) {
2348 home_dir = find_home_dir();
2350 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
2351 fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
2355 nBuf = strlen30(home_dir) + 16;
2356 zBuf = malloc( nBuf );
2358 fprintf(stderr,"%s: Error: out of memory\n",Argv0);
2361 sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir);
2363 sqliterc = (const char*)zBuf;
2365 in = fopen(sqliterc,"rb");
2367 if( stdin_is_interactive ){
2368 fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
2370 rc = process_input(p,in);
2378 ** Show available command line options
2380 static const char zOptions[] =
2381 " -help show this message\n"
2382 " -init filename read/process named file\n"
2383 " -echo print commands before execution\n"
2384 " -[no]header turn headers on or off\n"
2385 " -bail stop after hitting an error\n"
2386 " -interactive force interactive I/O\n"
2387 " -batch force batch I/O\n"
2388 " -column set output mode to 'column'\n"
2389 " -csv set output mode to 'csv'\n"
2390 " -html set output mode to HTML\n"
2391 " -line set output mode to 'line'\n"
2392 " -list set output mode to 'list'\n"
2393 " -separator 'x' set output field separator (|)\n"
2394 " -nullvalue 'text' set text string for NULL values\n"
2395 " -version show SQLite version\n"
2397 static void usage(int showDetail){
2399 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
2400 "FILENAME is the name of an SQLite database. A new database is created\n"
2401 "if the file does not previously exist.\n", Argv0);
2403 fprintf(stderr, "OPTIONS include:\n%s", zOptions);
2405 fprintf(stderr, "Use the -help option for additional information\n");
2411 ** Initialize the state information in data
2413 static void main_init(struct callback_data *data) {
2414 memset(data, 0, sizeof(*data));
2415 data->mode = MODE_List;
2416 memcpy(data->separator,"|", 2);
2417 data->showHeader = 0;
2418 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
2419 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
2420 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
2421 sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
2424 int main(int argc, char **argv){
2426 struct callback_data data;
2427 const char *zInitFile = 0;
2428 char *zFirstCmd = 0;
2434 stdin_is_interactive = isatty(0);
2436 /* Make sure we have a valid signal handler early, before anything
2440 signal(SIGINT, interrupt_handler);
2443 /* Do an initial pass through the command-line argument to locate
2444 ** the name of the database file, the name of the initialization file,
2445 ** and the first command to execute.
2447 for(i=1; i<argc-1; i++){
2449 if( argv[i][0]!='-' ) break;
2451 if( z[0]=='-' && z[1]=='-' ) z++;
2452 if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){
2454 }else if( strcmp(argv[i],"-init")==0 ){
2456 zInitFile = argv[i];
2457 /* Need to check for batch mode here to so we can avoid printing
2458 ** informational messages (like from process_sqliterc) before
2459 ** we do the actual processing of arguments later in a second pass.
2461 }else if( strcmp(argv[i],"-batch")==0 ){
2462 stdin_is_interactive = 0;
2466 #if defined(SQLITE_OS_OS2) && SQLITE_OS_OS2
2467 data.zDbFilename = (const char *)convertCpPathToUtf8( argv[i++] );
2469 data.zDbFilename = argv[i++];
2472 #ifndef SQLITE_OMIT_MEMORYDB
2473 data.zDbFilename = ":memory:";
2475 data.zDbFilename = 0;
2479 zFirstCmd = argv[i++];
2482 fprintf(stderr,"%s: Error: too many options: \"%s\"\n", Argv0, argv[i]);
2483 fprintf(stderr,"Use -help for a list of options.\n");
2488 #ifdef SQLITE_OMIT_MEMORYDB
2489 if( data.zDbFilename==0 ){
2490 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
2495 /* Go ahead and open the database file if it already exists. If the
2496 ** file does not exist, delay opening it. This prevents empty database
2497 ** files from being created if a user mistypes the database name argument
2498 ** to the sqlite command-line tool.
2500 if( access(data.zDbFilename, 0)==0 ){
2504 /* Process the initialization file if there is one. If no -init option
2505 ** is given on the command line, look for a file named ~/.sqliterc and
2506 ** try to process it.
2508 rc = process_sqliterc(&data,zInitFile);
2513 /* Make a second pass through the command-line argument and set
2514 ** options. This second pass is delayed until after the initialization
2515 ** file is processed so that the command-line arguments will override
2516 ** settings in the initialization file.
2518 for(i=1; i<argc && argv[i][0]=='-'; i++){
2520 if( z[1]=='-' ){ z++; }
2521 if( strcmp(z,"-init")==0 ){
2523 }else if( strcmp(z,"-html")==0 ){
2524 data.mode = MODE_Html;
2525 }else if( strcmp(z,"-list")==0 ){
2526 data.mode = MODE_List;
2527 }else if( strcmp(z,"-line")==0 ){
2528 data.mode = MODE_Line;
2529 }else if( strcmp(z,"-column")==0 ){
2530 data.mode = MODE_Column;
2531 }else if( strcmp(z,"-csv")==0 ){
2532 data.mode = MODE_Csv;
2533 memcpy(data.separator,",",2);
2534 }else if( strcmp(z,"-separator")==0 ){
2537 fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z);
2538 fprintf(stderr,"Use -help for a list of options.\n");
2541 sqlite3_snprintf(sizeof(data.separator), data.separator,
2542 "%.*s",(int)sizeof(data.separator)-1,argv[i]);
2543 }else if( strcmp(z,"-nullvalue")==0 ){
2546 fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z);
2547 fprintf(stderr,"Use -help for a list of options.\n");
2550 sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
2551 "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]);
2552 }else if( strcmp(z,"-header")==0 ){
2553 data.showHeader = 1;
2554 }else if( strcmp(z,"-noheader")==0 ){
2555 data.showHeader = 0;
2556 }else if( strcmp(z,"-echo")==0 ){
2558 }else if( strcmp(z,"-bail")==0 ){
2560 }else if( strcmp(z,"-version")==0 ){
2561 printf("%s\n", sqlite3_libversion());
2563 }else if( strcmp(z,"-interactive")==0 ){
2564 stdin_is_interactive = 1;
2565 }else if( strcmp(z,"-batch")==0 ){
2566 stdin_is_interactive = 0;
2567 }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){
2570 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
2571 fprintf(stderr,"Use -help for a list of options.\n");
2577 /* Run just the command that follows the database name
2579 if( zFirstCmd[0]=='.' ){
2580 rc = do_meta_command(zFirstCmd, &data);
2584 rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
2586 fprintf(stderr,"Error: %s\n", zErrMsg);
2587 return rc!=0 ? rc : 1;
2589 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd);
2594 /* Run commands received from standard input
2596 if( stdin_is_interactive ){
2601 "SQLite version %s\n"
2602 "Enter \".help\" for instructions\n"
2603 "Enter SQL statements terminated with a \";\"\n",
2604 sqlite3_libversion()
2606 zHome = find_home_dir();
2608 nHistory = strlen30(zHome) + 20;
2609 if( (zHistory = malloc(nHistory))!=0 ){
2610 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
2613 #if defined(HAVE_READLINE) && HAVE_READLINE==1
2614 if( zHistory ) read_history(zHistory);
2616 rc = process_input(&data, 0);
2618 stifle_history(100);
2619 write_history(zHistory);
2624 rc = process_input(&data, stdin);
2627 set_table_name(&data, 0);
2629 if( sqlite3_close(db)!=SQLITE_OK ){
2630 fprintf(stderr,"Error: cannot close database \"%s\"\n", sqlite3_errmsg(db));