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 statsOn; /* True to display memory stats before each finalize */
402 int cnt; /* Number of records displayed so far */
403 FILE *out; /* Write results here */
404 int mode; /* An output mode setting */
405 int writableSchema; /* True if PRAGMA writable_schema=ON */
406 int showHeader; /* True to show column names in List or Column mode */
407 char *zDestTable; /* Name of destination table when MODE_Insert */
408 char separator[20]; /* Separator character for MODE_List */
409 int colWidth[100]; /* Requested width of each column when in column mode*/
410 int actualWidth[100]; /* Actual width of each column */
411 char nullvalue[20]; /* The text to print when a NULL comes back from
413 struct previous_mode_data explainPrev;
414 /* Holds the mode information just before
416 char outfile[FILENAME_MAX]; /* Filename for *out */
417 const char *zDbFilename; /* name of the database file */
418 sqlite3_stmt *pStmt; /* Current statement if any. */
419 FILE *pLog; /* Write log output here */
423 ** These are the allowed modes.
425 #define MODE_Line 0 /* One column per line. Blank line between records */
426 #define MODE_Column 1 /* One record per line in neat columns */
427 #define MODE_List 2 /* One record per line with a separator */
428 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
429 #define MODE_Html 4 /* Generate an XHTML table */
430 #define MODE_Insert 5 /* Generate SQL "insert" statements */
431 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
432 #define MODE_Csv 7 /* Quote strings, numbers are plain */
433 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
435 static const char *modeDescr[] = {
448 ** Number of elements in an array
450 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
453 ** Compute a string length that is limited to what can be stored in
454 ** lower 30 bits of a 32-bit signed integer.
456 static int strlen30(const char *z){
458 while( *z2 ){ z2++; }
459 return 0x3fffffff & (int)(z2 - z);
463 ** A callback for the sqlite3_log() interface.
465 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
466 struct callback_data *p = (struct callback_data*)pArg;
467 if( p->pLog==0 ) return;
468 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
473 ** Output the given string as a hex-encoded blob (eg. X'1234' )
475 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
477 char *zBlob = (char *)pBlob;
479 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]); }
484 ** Output the given string as a quoted string using SQL quoting conventions.
486 static void output_quoted_string(FILE *out, const char *z){
490 if( z[i]=='\'' ) nSingle++;
493 fprintf(out,"'%s'",z);
497 for(i=0; z[i] && z[i]!='\''; i++){}
501 }else if( z[i]=='\'' ){
502 fprintf(out,"%.*s''",i,z);
514 ** Output the given string as a quoted according to C or TCL quoting rules.
516 static void output_c_string(FILE *out, const char *z){
519 while( (c = *(z++))!=0 ){
532 }else if( !isprint(c) ){
533 fprintf(out, "\\%03o", c&0xff);
542 ** Output the given string with characters that are special to
545 static void output_html_string(FILE *out, const char *z){
556 fprintf(out,"%.*s",i,z);
560 }else if( z[i]=='&' ){
561 fprintf(out,"&");
562 }else if( z[i]=='>' ){
564 }else if( z[i]=='\"' ){
565 fprintf(out,""");
566 }else if( z[i]=='\'' ){
567 fprintf(out,"'");
576 ** If a field contains any character identified by a 1 in the following
577 ** array, then the string must be quoted for CSV.
579 static const char needCsvQuote[] = {
580 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
581 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
582 1, 0, 1, 0, 0, 0, 0, 1, 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, 0,
587 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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,
595 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
599 ** Output a single term of CSV. Actually, p->separator is used for
600 ** the separator, which may or may not be a comma. p->nullvalue is
601 ** the null value. Strings are quoted using ANSI-C rules. Numbers
602 ** appear outside of quotes.
604 static void output_csv(struct callback_data *p, const char *z, int bSep){
607 fprintf(out,"%s",p->nullvalue);
610 int nSep = strlen30(p->separator);
612 if( needCsvQuote[((unsigned char*)z)[i]]
613 || (z[i]==p->separator[0] &&
614 (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
622 if( z[i]=='"' ) putc('"', out);
627 fprintf(out, "%s", z);
631 fprintf(p->out, "%s", p->separator);
637 ** This routine runs when the user presses Ctrl-C
639 static void interrupt_handler(int NotUsed){
640 UNUSED_PARAMETER(NotUsed);
642 if( db ) sqlite3_interrupt(db);
647 ** This is the callback routine that the shell
648 ** invokes for each row of a query result.
650 static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){
652 struct callback_data *p = (struct callback_data*)pArg;
657 if( azArg==0 ) break;
658 for(i=0; i<nArg; i++){
659 int len = strlen30(azCol[i] ? azCol[i] : "");
662 if( p->cnt++>0 ) fprintf(p->out,"\n");
663 for(i=0; i<nArg; i++){
664 fprintf(p->out,"%*s = %s\n", w, azCol[i],
665 azArg[i] ? azArg[i] : p->nullvalue);
672 for(i=0; i<nArg; i++){
674 if( i<ArraySize(p->colWidth) ){
680 w = strlen30(azCol[i] ? azCol[i] : "");
682 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);
685 if( i<ArraySize(p->actualWidth) ){
686 p->actualWidth[i] = w;
689 fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " ");
693 for(i=0; i<nArg; i++){
695 if( i<ArraySize(p->actualWidth) ){
696 w = p->actualWidth[i];
700 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
701 "----------------------------------------------------------",
702 i==nArg-1 ? "\n": " ");
706 if( azArg==0 ) break;
707 for(i=0; i<nArg; i++){
709 if( i<ArraySize(p->actualWidth) ){
710 w = p->actualWidth[i];
714 if( p->mode==MODE_Explain && azArg[i] &&
715 strlen30(azArg[i])>w ){
716 w = strlen30(azArg[i]);
718 fprintf(p->out,"%-*.*s%s",w,w,
719 azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
725 if( p->cnt++==0 && p->showHeader ){
726 for(i=0; i<nArg; i++){
727 fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
730 if( azArg==0 ) break;
731 for(i=0; i<nArg; i++){
733 if( z==0 ) z = p->nullvalue;
734 fprintf(p->out, "%s", z);
736 fprintf(p->out, "%s", p->separator);
737 }else if( p->mode==MODE_Semi ){
738 fprintf(p->out, ";\n");
740 fprintf(p->out, "\n");
746 if( p->cnt++==0 && p->showHeader ){
747 fprintf(p->out,"<TR>");
748 for(i=0; i<nArg; i++){
749 fprintf(p->out,"<TH>");
750 output_html_string(p->out, azCol[i]);
751 fprintf(p->out,"</TH>\n");
753 fprintf(p->out,"</TR>\n");
755 if( azArg==0 ) break;
756 fprintf(p->out,"<TR>");
757 for(i=0; i<nArg; i++){
758 fprintf(p->out,"<TD>");
759 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
760 fprintf(p->out,"</TD>\n");
762 fprintf(p->out,"</TR>\n");
766 if( p->cnt++==0 && p->showHeader ){
767 for(i=0; i<nArg; i++){
768 output_c_string(p->out,azCol[i] ? azCol[i] : "");
769 fprintf(p->out, "%s", p->separator);
771 fprintf(p->out,"\n");
773 if( azArg==0 ) break;
774 for(i=0; i<nArg; i++){
775 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
776 fprintf(p->out, "%s", p->separator);
778 fprintf(p->out,"\n");
782 if( p->cnt++==0 && p->showHeader ){
783 for(i=0; i<nArg; i++){
784 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
786 fprintf(p->out,"\n");
788 if( azArg==0 ) break;
789 for(i=0; i<nArg; i++){
790 output_csv(p, azArg[i], i<nArg-1);
792 fprintf(p->out,"\n");
797 if( azArg==0 ) break;
798 fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
799 for(i=0; i<nArg; i++){
800 char *zSep = i>0 ? ",": "";
801 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
802 fprintf(p->out,"%sNULL",zSep);
803 }else if( aiType && aiType[i]==SQLITE_TEXT ){
804 if( zSep[0] ) fprintf(p->out,"%s",zSep);
805 output_quoted_string(p->out, azArg[i]);
806 }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){
807 fprintf(p->out,"%s%s",zSep, azArg[i]);
808 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
809 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
810 int nBlob = sqlite3_column_bytes(p->pStmt, i);
811 if( zSep[0] ) fprintf(p->out,"%s",zSep);
812 output_hex_blob(p->out, pBlob, nBlob);
813 }else if( isNumber(azArg[i], 0) ){
814 fprintf(p->out,"%s%s",zSep, azArg[i]);
816 if( zSep[0] ) fprintf(p->out,"%s",zSep);
817 output_quoted_string(p->out, azArg[i]);
820 fprintf(p->out,");\n");
828 ** This is the callback routine that the SQLite library
829 ** invokes for each row of a query result.
831 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
832 /* since we don't have type info, call the shell_callback with a NULL value */
833 return shell_callback(pArg, nArg, azArg, azCol, NULL);
837 ** Set the destination table field of the callback_data structure to
838 ** the name of the table given. Escape any quote characters in the
841 static void set_table_name(struct callback_data *p, const char *zName){
850 if( zName==0 ) return;
851 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
852 for(i=n=0; zName[i]; i++, n++){
853 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
855 if( zName[i]=='\'' ) n++;
858 if( needQuote ) n += 2;
859 z = p->zDestTable = malloc( n+1 );
861 fprintf(stderr,"Error: out of memory\n");
865 if( needQuote ) z[n++] = '\'';
866 for(i=0; zName[i]; i++){
868 if( zName[i]=='\'' ) z[n++] = '\'';
870 if( needQuote ) z[n++] = '\'';
874 /* zIn is either a pointer to a NULL-terminated string in memory obtained
875 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
876 ** added to zIn, and the result returned in memory obtained from malloc().
877 ** zIn, if it was not NULL, is freed.
879 ** If the third argument, quote, is not '\0', then it is used as a
880 ** quote character for zAppend.
882 static char *appendText(char *zIn, char const *zAppend, char quote){
885 int nAppend = strlen30(zAppend);
886 int nIn = (zIn?strlen30(zIn):0);
891 for(i=0; i<nAppend; i++){
892 if( zAppend[i]==quote ) len++;
896 zIn = (char *)realloc(zIn, len);
902 char *zCsr = &zIn[nIn];
904 for(i=0; i<nAppend; i++){
905 *zCsr++ = zAppend[i];
906 if( zAppend[i]==quote ) *zCsr++ = quote;
910 assert( (zCsr-zIn)==len );
912 memcpy(&zIn[nIn], zAppend, nAppend);
921 ** Execute a query statement that has a single result column. Print
922 ** that result column on a line by itself with a semicolon terminator.
924 ** This is used, for example, to show the schema of the database by
925 ** querying the SQLITE_MASTER table.
927 static int run_table_dump_query(
928 FILE *out, /* Send output here */
929 sqlite3 *db, /* Database to query */
930 const char *zSelect, /* SELECT statement to extract content */
931 const char *zFirstRow /* Print before first row, if not NULL */
933 sqlite3_stmt *pSelect;
935 rc = sqlite3_prepare(db, zSelect, -1, &pSelect, 0);
936 if( rc!=SQLITE_OK || !pSelect ){
939 rc = sqlite3_step(pSelect);
940 while( rc==SQLITE_ROW ){
942 fprintf(out, "%s", zFirstRow);
945 fprintf(out, "%s;\n", sqlite3_column_text(pSelect, 0));
946 rc = sqlite3_step(pSelect);
948 return sqlite3_finalize(pSelect);
952 ** Allocate space and save off current error string.
954 static char *save_err_msg(
955 sqlite3 *db /* Database to query */
957 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
958 char *zErrMsg = sqlite3_malloc(nErrMsg);
960 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
966 ** Display memory stats.
968 static int display_stats(
969 sqlite3 *db, /* Database to query */
970 struct callback_data *pArg, /* Pointer to struct callback_data */
971 int bReset /* True to reset the stats */
976 if( pArg && pArg->out ){
979 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
980 fprintf(pArg->out, "Memory Used: %d (max %d) bytes\n", iCur, iHiwtr);
982 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
983 fprintf(pArg->out, "Number of Allocations: %d (max %d)\n", iCur, iHiwtr);
985 ** Not currently used by the CLI.
986 ** iHiwtr = iCur = -1;
987 ** sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
988 ** fprintf(pArg->out, "Number of Pcache Pages Used: %d (max %d) pages\n", iCur, iHiwtr);
991 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
992 fprintf(pArg->out, "Number of Pcache Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
994 ** Not currently used by the CLI.
995 ** iHiwtr = iCur = -1;
996 ** sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
997 ** fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n", iCur, iHiwtr);
1000 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1001 fprintf(pArg->out, "Number of Scratch Overflow Bytes: %d (max %d) bytes\n", iCur, iHiwtr);
1003 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1004 fprintf(pArg->out, "Largest Allocation: %d bytes\n", iHiwtr);
1006 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1007 fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n", iHiwtr);
1009 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1010 fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n", iHiwtr);
1011 #ifdef YYTRACKMAXSTACKDEPTH
1013 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1014 fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n", iCur, iHiwtr);
1018 if( pArg && pArg->out && db ){
1020 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHiwtr, bReset);
1021 fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n", iCur, iHiwtr);
1023 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1024 fprintf(pArg->out, "Pager Heap Usage: %d bytes\n", iCur);
1026 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1027 fprintf(pArg->out, "Schema Heap Usage: %d bytes\n", iCur);
1029 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1030 fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", iCur);
1033 if( pArg && pArg->out && db && pArg->pStmt ){
1034 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, bReset);
1035 fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1036 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1037 fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1038 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX, bReset);
1039 fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1046 ** Execute a statement or set of statements. Print
1047 ** any result rows/columns depending on the current mode
1048 ** set via the supplied callback.
1050 ** This is very similar to SQLite's built-in sqlite3_exec()
1051 ** function except it takes a slightly different callback
1052 ** and callback data argument.
1054 static int shell_exec(
1055 sqlite3 *db, /* An open database */
1056 const char *zSql, /* SQL to be evaluated */
1057 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1058 /* (not the same as sqlite3_exec) */
1059 struct callback_data *pArg, /* Pointer to struct callback_data */
1060 char **pzErrMsg /* Error msg written here */
1062 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1063 int rc = SQLITE_OK; /* Return Code */
1064 const char *zLeftover; /* Tail of unprocessed SQL */
1070 while( zSql[0] && (SQLITE_OK == rc) ){
1071 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1072 if( SQLITE_OK != rc ){
1074 *pzErrMsg = save_err_msg(db);
1078 /* this happens for a comment or white-space */
1080 while( isspace(zSql[0]) ) zSql++;
1084 /* save off the prepared statment handle and reset row count */
1086 pArg->pStmt = pStmt;
1090 /* echo the sql statement if echo on */
1091 if( pArg && pArg->echoOn ){
1092 const char *zStmtSql = sqlite3_sql(pStmt);
1093 fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1096 /* perform the first step. this will tell us if we
1097 ** have a result set or not and how wide it is.
1099 rc = sqlite3_step(pStmt);
1100 /* if we have a result set... */
1101 if( SQLITE_ROW == rc ){
1102 /* if we have a callback... */
1104 /* allocate space for col name ptr, value ptr, and type */
1105 int nCol = sqlite3_column_count(pStmt);
1106 void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1110 char **azCols = (char **)pData; /* Names of result columns */
1111 char **azVals = &azCols[nCol]; /* Results */
1112 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1114 assert(sizeof(int) <= sizeof(char *));
1115 /* save off ptrs to column names */
1116 for(i=0; i<nCol; i++){
1117 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1120 /* extract the data and data types */
1121 for(i=0; i<nCol; i++){
1122 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
1123 aiTypes[i] = sqlite3_column_type(pStmt, i);
1124 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1126 break; /* from for */
1130 /* if data and types extracted successfully... */
1131 if( SQLITE_ROW == rc ){
1132 /* call the supplied callback with the result row data */
1133 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1136 rc = sqlite3_step(pStmt);
1139 } while( SQLITE_ROW == rc );
1140 sqlite3_free(pData);
1144 rc = sqlite3_step(pStmt);
1145 } while( rc == SQLITE_ROW );
1149 /* print usage stats if stats on */
1150 if( pArg && pArg->statsOn ){
1151 display_stats(db, pArg, 0);
1154 /* Finalize the statement just executed. If this fails, save a
1155 ** copy of the error message. Otherwise, set zSql to point to the
1156 ** next statement to execute. */
1157 rc = sqlite3_finalize(pStmt);
1158 if( rc==SQLITE_OK ){
1160 while( isspace(zSql[0]) ) zSql++;
1161 }else if( pzErrMsg ){
1162 *pzErrMsg = save_err_msg(db);
1165 /* clear saved stmt handle */
1177 ** This is a different callback routine used for dumping the database.
1178 ** Each row received by this callback consists of a table name,
1179 ** the table type ("index" or "table") and SQL to create the table.
1180 ** This routine should print text sufficient to recreate the table.
1182 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1187 const char *zPrepStmt = 0;
1188 struct callback_data *p = (struct callback_data *)pArg;
1190 UNUSED_PARAMETER(azCol);
1191 if( nArg!=3 ) return 1;
1196 if( strcmp(zTable, "sqlite_sequence")==0 ){
1197 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1198 }else if( strcmp(zTable, "sqlite_stat1")==0 ){
1199 fprintf(p->out, "ANALYZE sqlite_master;\n");
1200 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1202 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1204 if( !p->writableSchema ){
1205 fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1206 p->writableSchema = 1;
1208 zIns = sqlite3_mprintf(
1209 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1210 "VALUES('table','%q','%q',0,'%q');",
1211 zTable, zTable, zSql);
1212 fprintf(p->out, "%s\n", zIns);
1216 fprintf(p->out, "%s;\n", zSql);
1219 if( strcmp(zType, "table")==0 ){
1220 sqlite3_stmt *pTableInfo = 0;
1222 char *zTableInfo = 0;
1226 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1227 zTableInfo = appendText(zTableInfo, zTable, '"');
1228 zTableInfo = appendText(zTableInfo, ");", 0);
1230 rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1232 if( rc!=SQLITE_OK || !pTableInfo ){
1236 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1237 zTmp = appendText(zTmp, zTable, '"');
1239 zSelect = appendText(zSelect, zTmp, '\'');
1241 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1242 rc = sqlite3_step(pTableInfo);
1243 while( rc==SQLITE_ROW ){
1244 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1245 zSelect = appendText(zSelect, "quote(", 0);
1246 zSelect = appendText(zSelect, zText, '"');
1247 rc = sqlite3_step(pTableInfo);
1248 if( rc==SQLITE_ROW ){
1249 zSelect = appendText(zSelect, ") || ',' || ", 0);
1251 zSelect = appendText(zSelect, ") ", 0);
1255 rc = sqlite3_finalize(pTableInfo);
1256 if( rc!=SQLITE_OK || nRow==0 ){
1260 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1261 zSelect = appendText(zSelect, zTable, '"');
1263 rc = run_table_dump_query(p->out, p->db, zSelect, zPrepStmt);
1264 if( rc==SQLITE_CORRUPT ){
1265 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1266 rc = run_table_dump_query(p->out, p->db, zSelect, 0);
1268 if( zSelect ) free(zSelect);
1274 ** Run zQuery. Use dump_callback() as the callback routine so that
1275 ** the contents of the query are output as SQL statements.
1277 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1278 ** "ORDER BY rowid DESC" to the end.
1280 static int run_schema_dump_query(
1281 struct callback_data *p,
1286 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg);
1287 if( rc==SQLITE_CORRUPT ){
1289 int len = strlen30(zQuery);
1290 if( pzErrMsg ) sqlite3_free(*pzErrMsg);
1291 zQ2 = malloc( len+100 );
1292 if( zQ2==0 ) return rc;
1293 sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery);
1294 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg);
1301 ** Text of a help message
1303 static char zHelp[] =
1304 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1305 ".bail ON|OFF Stop after hitting an error. Default OFF\n"
1306 ".databases List names and files of attached databases\n"
1307 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1308 " If TABLE specified, only dump tables matching\n"
1309 " LIKE pattern TABLE.\n"
1310 ".echo ON|OFF Turn command echo on or off\n"
1311 ".exit Exit this program\n"
1312 ".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.\n"
1313 " With no args, it turns EXPLAIN on.\n"
1314 ".header(s) ON|OFF Turn display of headers on or off\n"
1315 ".help Show this message\n"
1316 ".import FILE TABLE Import data from FILE into TABLE\n"
1317 ".indices ?TABLE? Show names of all indices\n"
1318 " If TABLE specified, only show indices for tables\n"
1319 " matching LIKE pattern TABLE.\n"
1320 #ifdef SQLITE_ENABLE_IOTRACE
1321 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1323 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1324 ".load FILE ?ENTRY? Load an extension library\n"
1326 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1327 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1328 " csv Comma-separated values\n"
1329 " column Left-aligned columns. (See .width)\n"
1330 " html HTML <table> code\n"
1331 " insert SQL insert statements for TABLE\n"
1332 " line One value per line\n"
1333 " list Values delimited by .separator string\n"
1334 " tabs Tab-separated values\n"
1335 " tcl TCL list elements\n"
1336 ".nullvalue STRING Print STRING in place of NULL values\n"
1337 ".output FILENAME Send output to FILENAME\n"
1338 ".output stdout Send output to the screen\n"
1339 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1340 ".quit Exit this program\n"
1341 ".read FILENAME Execute SQL in FILENAME\n"
1342 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1343 ".schema ?TABLE? Show the CREATE statements\n"
1344 " If TABLE specified, only show tables matching\n"
1345 " LIKE pattern TABLE.\n"
1346 ".separator STRING Change separator used by output mode and .import\n"
1347 ".show Show the current values for various settings\n"
1348 ".stats ON|OFF Turn stats on or off\n"
1349 ".tables ?TABLE? List names of tables\n"
1350 " If TABLE specified, only list tables matching\n"
1351 " LIKE pattern TABLE.\n"
1352 ".timeout MS Try opening locked tables for MS milliseconds\n"
1353 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1356 static char zTimerHelp[] =
1357 ".timer ON|OFF Turn the CPU timer measurement on or off\n"
1360 /* Forward reference */
1361 static int process_input(struct callback_data *p, FILE *in);
1364 ** Make sure the database is open. If it is not, then open it. If
1365 ** the database fails to open, print an error message and exit.
1367 static void open_db(struct callback_data *p){
1369 sqlite3_open(p->zDbFilename, &p->db);
1371 if( db && sqlite3_errcode(db)==SQLITE_OK ){
1372 sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1373 shellstaticFunc, 0, 0);
1375 if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1376 fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1377 p->zDbFilename, sqlite3_errmsg(db));
1380 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1381 sqlite3_enable_load_extension(p->db, 1);
1387 ** Do C-language style dequoting.
1391 ** \r -> carriage return
1392 ** \NNN -> ascii character NNN in octal
1395 static void resolve_backslashes(char *z){
1398 for(i=j=0; (c = z[i])!=0; i++, j++){
1407 }else if( c>='0' && c<='7' ){
1409 if( z[i+1]>='0' && z[i+1]<='7' ){
1411 c = (c<<3) + z[i] - '0';
1412 if( z[i+1]>='0' && z[i+1]<='7' ){
1414 c = (c<<3) + z[i] - '0';
1425 ** Interpret zArg as a boolean value. Return either 0 or 1.
1427 static int booleanValue(char *zArg){
1428 int val = atoi(zArg);
1430 for(j=0; zArg[j]; j++){
1431 zArg[j] = (char)tolower(zArg[j]);
1433 if( strcmp(zArg,"on")==0 ){
1435 }else if( strcmp(zArg,"yes")==0 ){
1442 ** If an input line begins with "." then invoke this routine to
1443 ** process that line.
1445 ** Return 1 on error, 2 to exit, and 0 otherwise.
1447 static int do_meta_command(char *zLine, struct callback_data *p){
1454 /* Parse the input line into tokens.
1456 while( zLine[i] && nArg<ArraySize(azArg) ){
1457 while( isspace((unsigned char)zLine[i]) ){ i++; }
1458 if( zLine[i]==0 ) break;
1459 if( zLine[i]=='\'' || zLine[i]=='"' ){
1460 int delim = zLine[i++];
1461 azArg[nArg++] = &zLine[i];
1462 while( zLine[i] && zLine[i]!=delim ){ i++; }
1463 if( zLine[i]==delim ){
1466 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1468 azArg[nArg++] = &zLine[i];
1469 while( zLine[i] && !isspace((unsigned char)zLine[i]) ){ i++; }
1470 if( zLine[i] ) zLine[i++] = 0;
1471 resolve_backslashes(azArg[nArg-1]);
1475 /* Process the input line.
1477 if( nArg==0 ) return 0; /* no tokens, no error */
1478 n = strlen30(azArg[0]);
1480 if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 && nArg>1 && nArg<4){
1481 const char *zDestFile;
1484 sqlite3_backup *pBackup;
1486 zDestFile = azArg[1];
1489 zDestFile = azArg[2];
1492 rc = sqlite3_open(zDestFile, &pDest);
1493 if( rc!=SQLITE_OK ){
1494 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
1495 sqlite3_close(pDest);
1499 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
1501 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1502 sqlite3_close(pDest);
1505 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
1506 sqlite3_backup_finish(pBackup);
1507 if( rc==SQLITE_DONE ){
1510 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1513 sqlite3_close(pDest);
1516 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){
1517 bail_on_error = booleanValue(azArg[1]);
1520 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
1521 struct callback_data data;
1524 memcpy(&data, p, sizeof(data));
1525 data.showHeader = 1;
1526 data.mode = MODE_Column;
1527 data.colWidth[0] = 3;
1528 data.colWidth[1] = 15;
1529 data.colWidth[2] = 58;
1531 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
1533 fprintf(stderr,"Error: %s\n", zErrMsg);
1534 sqlite3_free(zErrMsg);
1539 if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
1542 /* When playing back a "dump", the content might appear in an order
1543 ** which causes immediate foreign key constraints to be violated.
1544 ** So disable foreign-key constraint enforcement to prevent problems. */
1545 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
1546 fprintf(p->out, "BEGIN TRANSACTION;\n");
1547 p->writableSchema = 0;
1548 sqlite3_exec(p->db, "PRAGMA writable_schema=ON", 0, 0, 0);
1550 run_schema_dump_query(p,
1551 "SELECT name, type, sql FROM sqlite_master "
1552 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'", 0
1554 run_schema_dump_query(p,
1555 "SELECT name, type, sql FROM sqlite_master "
1556 "WHERE name=='sqlite_sequence'", 0
1558 run_table_dump_query(p->out, p->db,
1559 "SELECT sql FROM sqlite_master "
1560 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
1564 for(i=1; i<nArg; i++){
1565 zShellStatic = azArg[i];
1566 run_schema_dump_query(p,
1567 "SELECT name, type, sql FROM sqlite_master "
1568 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
1569 " AND sql NOT NULL", 0);
1570 run_table_dump_query(p->out, p->db,
1571 "SELECT sql FROM sqlite_master "
1572 "WHERE sql NOT NULL"
1573 " AND type IN ('index','trigger','view')"
1574 " AND tbl_name LIKE shellstatic()", 0
1579 if( p->writableSchema ){
1580 fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
1581 p->writableSchema = 0;
1583 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF", 0, 0, 0);
1585 fprintf(stderr,"Error: %s\n", zErrMsg);
1586 sqlite3_free(zErrMsg);
1588 fprintf(p->out, "COMMIT;\n");
1592 if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){
1593 p->echoOn = booleanValue(azArg[1]);
1596 if( c=='e' && strncmp(azArg[0], "exit", n)==0 && nArg==1 ){
1600 if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){
1601 int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
1603 if(!p->explainPrev.valid) {
1604 p->explainPrev.valid = 1;
1605 p->explainPrev.mode = p->mode;
1606 p->explainPrev.showHeader = p->showHeader;
1607 memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
1609 /* We could put this code under the !p->explainValid
1610 ** condition so that it does not execute if we are already in
1611 ** explain mode. However, always executing it allows us an easy
1612 ** was to reset to explain mode in case the user previously
1613 ** did an .explain followed by a .width, .mode or .header
1616 p->mode = MODE_Explain;
1618 memset(p->colWidth,0,ArraySize(p->colWidth));
1619 p->colWidth[0] = 4; /* addr */
1620 p->colWidth[1] = 13; /* opcode */
1621 p->colWidth[2] = 4; /* P1 */
1622 p->colWidth[3] = 4; /* P2 */
1623 p->colWidth[4] = 4; /* P3 */
1624 p->colWidth[5] = 13; /* P4 */
1625 p->colWidth[6] = 2; /* P5 */
1626 p->colWidth[7] = 13; /* Comment */
1627 }else if (p->explainPrev.valid) {
1628 p->explainPrev.valid = 0;
1629 p->mode = p->explainPrev.mode;
1630 p->showHeader = p->explainPrev.showHeader;
1631 memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
1635 if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
1636 strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){
1637 p->showHeader = booleanValue(azArg[1]);
1640 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1641 fprintf(stderr,"%s",zHelp);
1643 fprintf(stderr,"%s",zTimerHelp);
1647 if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1648 char *zTable = azArg[2]; /* Insert data into this table */
1649 char *zFile = azArg[1]; /* The file from which to extract data */
1650 sqlite3_stmt *pStmt = NULL; /* A statement */
1651 int nCol; /* Number of columns in the table */
1652 int nByte; /* Number of bytes in an SQL string */
1653 int i, j; /* Loop counters */
1654 int nSep; /* Number of bytes in p->separator[] */
1655 char *zSql; /* An SQL statement */
1656 char *zLine; /* A single line of input from the file */
1657 char **azCol; /* zLine[] broken up into columns */
1658 char *zCommit; /* How to commit changes */
1659 FILE *in; /* The input file */
1660 int lineno = 0; /* Line number of input file */
1663 nSep = strlen30(p->separator);
1665 fprintf(stderr, "Error: non-null separator required for import\n");
1668 zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
1670 fprintf(stderr, "Error: out of memory\n");
1673 nByte = strlen30(zSql);
1674 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1677 if (pStmt) sqlite3_finalize(pStmt);
1678 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1681 nCol = sqlite3_column_count(pStmt);
1682 sqlite3_finalize(pStmt);
1684 if( nCol==0 ) return 0; /* no columns, no error */
1685 zSql = malloc( nByte + 20 + nCol*2 );
1687 fprintf(stderr, "Error: out of memory\n");
1690 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable);
1692 for(i=1; i<nCol; i++){
1698 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1701 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
1702 if (pStmt) sqlite3_finalize(pStmt);
1705 in = fopen(zFile, "rb");
1707 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1708 sqlite3_finalize(pStmt);
1711 azCol = malloc( sizeof(azCol[0])*(nCol+1) );
1713 fprintf(stderr, "Error: out of memory\n");
1715 sqlite3_finalize(pStmt);
1718 sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
1720 while( (zLine = local_getline(0, in))!=0 ){
1725 for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){
1726 if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){
1730 azCol[i] = &z[nSep];
1738 "Error: %s line %d: expected %d columns of data but found %d\n",
1739 zFile, lineno, nCol, i+1);
1740 zCommit = "ROLLBACK";
1743 break; /* from while */
1745 for(i=0; i<nCol; i++){
1746 sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
1748 sqlite3_step(pStmt);
1749 rc = sqlite3_reset(pStmt);
1751 if( rc!=SQLITE_OK ){
1752 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1753 zCommit = "ROLLBACK";
1755 break; /* from while */
1760 sqlite3_finalize(pStmt);
1761 sqlite3_exec(p->db, zCommit, 0, 0, 0);
1764 if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){
1765 struct callback_data data;
1768 memcpy(&data, p, sizeof(data));
1769 data.showHeader = 0;
1770 data.mode = MODE_List;
1772 rc = sqlite3_exec(p->db,
1773 "SELECT name FROM sqlite_master "
1774 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
1776 "SELECT name FROM sqlite_temp_master "
1777 "WHERE type='index' "
1779 callback, &data, &zErrMsg
1782 zShellStatic = azArg[1];
1783 rc = sqlite3_exec(p->db,
1784 "SELECT name FROM sqlite_master "
1785 "WHERE type='index' AND tbl_name LIKE shellstatic() "
1787 "SELECT name FROM sqlite_temp_master "
1788 "WHERE type='index' AND tbl_name LIKE shellstatic() "
1790 callback, &data, &zErrMsg
1795 fprintf(stderr,"Error: %s\n", zErrMsg);
1796 sqlite3_free(zErrMsg);
1798 }else if( rc != SQLITE_OK ){
1799 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
1804 #ifdef SQLITE_ENABLE_IOTRACE
1805 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
1806 extern void (*sqlite3IoTrace)(const char*, ...);
1807 if( iotrace && iotrace!=stdout ) fclose(iotrace);
1811 }else if( strcmp(azArg[1], "-")==0 ){
1812 sqlite3IoTrace = iotracePrintf;
1815 iotrace = fopen(azArg[1], "w");
1817 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
1821 sqlite3IoTrace = iotracePrintf;
1827 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1828 if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
1829 const char *zFile, *zProc;
1832 zProc = nArg>=3 ? azArg[2] : 0;
1834 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
1835 if( rc!=SQLITE_OK ){
1836 fprintf(stderr, "Error: %s\n", zErrMsg);
1837 sqlite3_free(zErrMsg);
1843 if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=1 ){
1844 const char *zFile = azArg[1];
1845 if( p->pLog && p->pLog!=stdout && p->pLog!=stderr ){
1849 if( strcmp(zFile,"stdout")==0 ){
1851 }else if( strcmp(zFile, "stderr")==0 ){
1853 }else if( strcmp(zFile, "off")==0 ){
1856 p->pLog = fopen(zFile, "w");
1858 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1863 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){
1864 int n2 = strlen30(azArg[1]);
1865 if( (n2==4 && strncmp(azArg[1],"line",n2)==0)
1867 (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){
1868 p->mode = MODE_Line;
1869 }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0)
1871 (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){
1872 p->mode = MODE_Column;
1873 }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){
1874 p->mode = MODE_List;
1875 }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){
1876 p->mode = MODE_Html;
1877 }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){
1879 }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){
1881 sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
1882 }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){
1883 p->mode = MODE_List;
1884 sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
1885 }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
1886 p->mode = MODE_Insert;
1887 set_table_name(p, "table");
1889 fprintf(stderr,"Error: mode should be one of: "
1890 "column csv html insert line list tabs tcl\n");
1895 if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){
1896 int n2 = strlen30(azArg[1]);
1897 if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
1898 p->mode = MODE_Insert;
1899 set_table_name(p, azArg[2]);
1901 fprintf(stderr, "Error: invalid arguments: "
1902 " \"%s\". Enter \".help\" for help\n", azArg[2]);
1907 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
1908 sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
1909 "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
1912 if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
1913 if( p->out!=stdout ){
1916 if( strcmp(azArg[1],"stdout")==0 ){
1918 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "stdout");
1920 p->out = fopen(azArg[1], "wb");
1922 fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]);
1926 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
1931 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
1933 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
1936 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
1940 if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){
1944 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
1945 FILE *alt = fopen(azArg[1], "rb");
1947 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
1950 rc = process_input(p, alt);
1955 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){
1956 const char *zSrcFile;
1959 sqlite3_backup *pBackup;
1963 zSrcFile = azArg[1];
1966 zSrcFile = azArg[2];
1969 rc = sqlite3_open(zSrcFile, &pSrc);
1970 if( rc!=SQLITE_OK ){
1971 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
1972 sqlite3_close(pSrc);
1976 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
1978 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
1979 sqlite3_close(pSrc);
1982 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
1983 || rc==SQLITE_BUSY ){
1984 if( rc==SQLITE_BUSY ){
1985 if( nTimeout++ >= 3 ) break;
1989 sqlite3_backup_finish(pBackup);
1990 if( rc==SQLITE_DONE ){
1992 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
1993 fprintf(stderr, "Error: source database is busy\n");
1996 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
1999 sqlite3_close(pSrc);
2002 if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){
2003 struct callback_data data;
2006 memcpy(&data, p, sizeof(data));
2007 data.showHeader = 0;
2008 data.mode = MODE_Semi;
2011 for(i=0; azArg[1][i]; i++) azArg[1][i] = (char)tolower(azArg[1][i]);
2012 if( strcmp(azArg[1],"sqlite_master")==0 ){
2013 char *new_argv[2], *new_colv[2];
2014 new_argv[0] = "CREATE TABLE sqlite_master (\n"
2018 " rootpage integer,\n"
2022 new_colv[0] = "sql";
2024 callback(&data, 1, new_argv, new_colv);
2026 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
2027 char *new_argv[2], *new_colv[2];
2028 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
2032 " rootpage integer,\n"
2036 new_colv[0] = "sql";
2038 callback(&data, 1, new_argv, new_colv);
2041 zShellStatic = azArg[1];
2042 rc = sqlite3_exec(p->db,
2044 " (SELECT sql sql, type type, tbl_name tbl_name, name name"
2045 " FROM sqlite_master UNION ALL"
2046 " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) "
2047 "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL "
2048 "ORDER BY substr(type,2,1), name",
2049 callback, &data, &zErrMsg);
2053 rc = sqlite3_exec(p->db,
2055 " (SELECT sql sql, type type, tbl_name tbl_name, name name"
2056 " FROM sqlite_master UNION ALL"
2057 " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) "
2058 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
2059 "ORDER BY substr(type,2,1), name",
2060 callback, &data, &zErrMsg
2064 fprintf(stderr,"Error: %s\n", zErrMsg);
2065 sqlite3_free(zErrMsg);
2067 }else if( rc != SQLITE_OK ){
2068 fprintf(stderr,"Error: querying schema information\n");
2075 if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2076 sqlite3_snprintf(sizeof(p->separator), p->separator,
2077 "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2080 if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){
2082 fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
2083 fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
2084 fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
2085 fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
2086 fprintf(p->out,"%9.9s: ", "nullvalue");
2087 output_c_string(p->out, p->nullvalue);
2088 fprintf(p->out, "\n");
2089 fprintf(p->out,"%9.9s: %s\n","output",
2090 strlen30(p->outfile) ? p->outfile : "stdout");
2091 fprintf(p->out,"%9.9s: ", "separator");
2092 output_c_string(p->out, p->separator);
2093 fprintf(p->out, "\n");
2094 fprintf(p->out,"%9.9s: %s\n","stats", p->statsOn ? "on" : "off");
2095 fprintf(p->out,"%9.9s: ","width");
2096 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
2097 fprintf(p->out,"%d ",p->colWidth[i]);
2099 fprintf(p->out,"\n");
2102 if( c=='s' && strncmp(azArg[0], "stats", n)==0 && nArg>1 && nArg<3 ){
2103 p->statsOn = booleanValue(azArg[1]);
2106 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){
2112 rc = sqlite3_get_table(p->db,
2113 "SELECT name FROM sqlite_master "
2114 "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' "
2116 "SELECT name FROM sqlite_temp_master "
2117 "WHERE type IN ('table','view') "
2119 &azResult, &nRow, 0, &zErrMsg
2122 zShellStatic = azArg[1];
2123 rc = sqlite3_get_table(p->db,
2124 "SELECT name FROM sqlite_master "
2125 "WHERE type IN ('table','view') AND name LIKE shellstatic() "
2127 "SELECT name FROM sqlite_temp_master "
2128 "WHERE type IN ('table','view') AND name LIKE shellstatic() "
2130 &azResult, &nRow, 0, &zErrMsg
2135 fprintf(stderr,"Error: %s\n", zErrMsg);
2136 sqlite3_free(zErrMsg);
2138 }else if( rc != SQLITE_OK ){
2139 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
2142 int len, maxlen = 0;
2144 int nPrintCol, nPrintRow;
2145 for(i=1; i<=nRow; i++){
2146 if( azResult[i]==0 ) continue;
2147 len = strlen30(azResult[i]);
2148 if( len>maxlen ) maxlen = len;
2150 nPrintCol = 80/(maxlen+2);
2151 if( nPrintCol<1 ) nPrintCol = 1;
2152 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
2153 for(i=0; i<nPrintRow; i++){
2154 for(j=i+1; j<=nRow; j+=nPrintRow){
2155 char *zSp = j<=nPrintRow ? "" : " ";
2156 printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
2161 sqlite3_free_table(azResult);
2164 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){
2166 sqlite3_busy_timeout(p->db, atoi(azArg[1]));
2169 if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg==2 ){
2170 enableTimer = booleanValue(azArg[1]);
2173 if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){
2175 assert( nArg<=ArraySize(azArg) );
2176 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
2177 p->colWidth[j-1] = atoi(azArg[j]);
2182 fprintf(stderr, "Error: unknown command or invalid arguments: "
2183 " \"%s\". Enter \".help\" for help\n", azArg[0]);
2191 ** Return TRUE if a semicolon occurs anywhere in the first N characters
2194 static int _contains_semicolon(const char *z, int N){
2196 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
2201 ** Test to see if a line consists entirely of whitespace.
2203 static int _all_whitespace(const char *z){
2205 if( isspace(*(unsigned char*)z) ) continue;
2206 if( *z=='/' && z[1]=='*' ){
2208 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
2209 if( *z==0 ) return 0;
2213 if( *z=='-' && z[1]=='-' ){
2215 while( *z && *z!='\n' ){ z++; }
2216 if( *z==0 ) return 1;
2225 ** Return TRUE if the line typed in is an SQL command terminator other
2226 ** than a semi-colon. The SQL Server style "go" command is understood
2227 ** as is the Oracle "/".
2229 static int _is_command_terminator(const char *zLine){
2230 while( isspace(*(unsigned char*)zLine) ){ zLine++; };
2231 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
2232 return 1; /* Oracle */
2234 if( tolower(zLine[0])=='g' && tolower(zLine[1])=='o'
2235 && _all_whitespace(&zLine[2]) ){
2236 return 1; /* SQL Server */
2242 ** Return true if zSql is a complete SQL statement. Return false if it
2243 ** ends in the middle of a string literal or C-style comment.
2245 static int _is_complete(char *zSql, int nSql){
2247 if( zSql==0 ) return 1;
2250 rc = sqlite3_complete(zSql);
2256 ** Read input from *in and process it. If *in==0 then input
2257 ** is interactive - the user is typing it it. Otherwise, input
2258 ** is coming from a file or device. A prompt is issued and history
2259 ** is saved only if input is interactive. An interrupt signal will
2260 ** cause this routine to exit immediately, unless input is interactive.
2262 ** Return the number of errors.
2264 static int process_input(struct callback_data *p, FILE *in){
2275 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
2278 zLine = one_input_line(zSql, in);
2280 break; /* We have reached EOF */
2282 if( seenInterrupt ){
2287 if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
2288 if( zLine && zLine[0]=='.' && nSql==0 ){
2289 if( p->echoOn ) printf("%s\n", zLine);
2290 rc = do_meta_command(zLine, p);
2291 if( rc==2 ){ /* exit requested */
2298 if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){
2299 memcpy(zLine,";",2);
2304 for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){}
2306 nSql = strlen30(zLine);
2307 zSql = malloc( nSql+3 );
2309 fprintf(stderr, "Error: out of memory\n");
2312 memcpy(zSql, zLine, nSql+1);
2316 int len = strlen30(zLine);
2317 zSql = realloc( zSql, nSql + len + 4 );
2319 fprintf(stderr,"Error: out of memory\n");
2322 zSql[nSql++] = '\n';
2323 memcpy(&zSql[nSql], zLine, len+1);
2326 if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
2327 && sqlite3_complete(zSql) ){
2331 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
2333 if( rc || zErrMsg ){
2335 if( in!=0 || !stdin_is_interactive ){
2336 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
2337 "Error: near line %d:", startline);
2339 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
2342 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
2343 sqlite3_free(zErrMsg);
2346 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
2356 if( !_all_whitespace(zSql) ) fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
2364 ** Return a pathname which is the user's home directory. A
2365 ** 0 return indicates an error of some kind. Space to hold the
2366 ** resulting string is obtained from malloc(). The calling
2367 ** function should free the result.
2369 static char *find_home_dir(void){
2370 char *home_dir = NULL;
2372 #if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)
2373 struct passwd *pwent;
2374 uid_t uid = getuid();
2375 if( (pwent=getpwuid(uid)) != NULL) {
2376 home_dir = pwent->pw_dir;
2380 #if defined(_WIN32_WCE)
2381 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
2383 home_dir = strdup("/");
2386 #if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
2388 home_dir = getenv("USERPROFILE");
2393 home_dir = getenv("HOME");
2396 #if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
2398 char *zDrive, *zPath;
2400 zDrive = getenv("HOMEDRIVE");
2401 zPath = getenv("HOMEPATH");
2402 if( zDrive && zPath ){
2403 n = strlen30(zDrive) + strlen30(zPath) + 1;
2404 home_dir = malloc( n );
2405 if( home_dir==0 ) return 0;
2406 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
2413 #endif /* !_WIN32_WCE */
2416 int n = strlen30(home_dir) + 1;
2417 char *z = malloc( n );
2418 if( z ) memcpy(z, home_dir, n);
2426 ** Read input from the file given by sqliterc_override. Or if that
2427 ** parameter is NULL, take input from ~/.sqliterc
2429 ** Returns the number of errors.
2431 static int process_sqliterc(
2432 struct callback_data *p, /* Configuration data */
2433 const char *sqliterc_override /* Name of config file. NULL to use default */
2435 char *home_dir = NULL;
2436 const char *sqliterc = sqliterc_override;
2442 if (sqliterc == NULL) {
2443 home_dir = find_home_dir();
2445 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
2446 fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
2450 nBuf = strlen30(home_dir) + 16;
2451 zBuf = malloc( nBuf );
2453 fprintf(stderr,"%s: Error: out of memory\n",Argv0);
2456 sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir);
2458 sqliterc = (const char*)zBuf;
2460 in = fopen(sqliterc,"rb");
2462 if( stdin_is_interactive ){
2463 fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
2465 rc = process_input(p,in);
2473 ** Show available command line options
2475 static const char zOptions[] =
2476 " -help show this message\n"
2477 " -init filename read/process named file\n"
2478 " -echo print commands before execution\n"
2479 " -[no]header turn headers on or off\n"
2480 " -bail stop after hitting an error\n"
2481 " -interactive force interactive I/O\n"
2482 " -batch force batch I/O\n"
2483 " -column set output mode to 'column'\n"
2484 " -csv set output mode to 'csv'\n"
2485 " -html set output mode to HTML\n"
2486 " -line set output mode to 'line'\n"
2487 " -list set output mode to 'list'\n"
2488 " -separator 'x' set output field separator (|)\n"
2489 " -stats print memory stats before each finalize\n"
2490 " -nullvalue 'text' set text string for NULL values\n"
2491 " -version show SQLite version\n"
2493 static void usage(int showDetail){
2495 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
2496 "FILENAME is the name of an SQLite database. A new database is created\n"
2497 "if the file does not previously exist.\n", Argv0);
2499 fprintf(stderr, "OPTIONS include:\n%s", zOptions);
2501 fprintf(stderr, "Use the -help option for additional information\n");
2507 ** Initialize the state information in data
2509 static void main_init(struct callback_data *data) {
2510 memset(data, 0, sizeof(*data));
2511 data->mode = MODE_List;
2512 memcpy(data->separator,"|", 2);
2513 data->showHeader = 0;
2514 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
2515 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
2516 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
2517 sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
2520 int main(int argc, char **argv){
2522 struct callback_data data;
2523 const char *zInitFile = 0;
2524 char *zFirstCmd = 0;
2530 stdin_is_interactive = isatty(0);
2532 /* Make sure we have a valid signal handler early, before anything
2536 signal(SIGINT, interrupt_handler);
2539 /* Do an initial pass through the command-line argument to locate
2540 ** the name of the database file, the name of the initialization file,
2541 ** and the first command to execute.
2543 for(i=1; i<argc-1; i++){
2545 if( argv[i][0]!='-' ) break;
2547 if( z[0]=='-' && z[1]=='-' ) z++;
2548 if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){
2550 }else if( strcmp(argv[i],"-init")==0 ){
2552 zInitFile = argv[i];
2553 /* Need to check for batch mode here to so we can avoid printing
2554 ** informational messages (like from process_sqliterc) before
2555 ** we do the actual processing of arguments later in a second pass.
2557 }else if( strcmp(argv[i],"-batch")==0 ){
2558 stdin_is_interactive = 0;
2562 #if defined(SQLITE_OS_OS2) && SQLITE_OS_OS2
2563 data.zDbFilename = (const char *)convertCpPathToUtf8( argv[i++] );
2565 data.zDbFilename = argv[i++];
2568 #ifndef SQLITE_OMIT_MEMORYDB
2569 data.zDbFilename = ":memory:";
2571 data.zDbFilename = 0;
2575 zFirstCmd = argv[i++];
2578 fprintf(stderr,"%s: Error: too many options: \"%s\"\n", Argv0, argv[i]);
2579 fprintf(stderr,"Use -help for a list of options.\n");
2584 #ifdef SQLITE_OMIT_MEMORYDB
2585 if( data.zDbFilename==0 ){
2586 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
2591 /* Go ahead and open the database file if it already exists. If the
2592 ** file does not exist, delay opening it. This prevents empty database
2593 ** files from being created if a user mistypes the database name argument
2594 ** to the sqlite command-line tool.
2596 if( access(data.zDbFilename, 0)==0 ){
2600 /* Process the initialization file if there is one. If no -init option
2601 ** is given on the command line, look for a file named ~/.sqliterc and
2602 ** try to process it.
2604 rc = process_sqliterc(&data,zInitFile);
2609 /* Make a second pass through the command-line argument and set
2610 ** options. This second pass is delayed until after the initialization
2611 ** file is processed so that the command-line arguments will override
2612 ** settings in the initialization file.
2614 for(i=1; i<argc && argv[i][0]=='-'; i++){
2616 if( z[1]=='-' ){ z++; }
2617 if( strcmp(z,"-init")==0 ){
2619 }else if( strcmp(z,"-html")==0 ){
2620 data.mode = MODE_Html;
2621 }else if( strcmp(z,"-list")==0 ){
2622 data.mode = MODE_List;
2623 }else if( strcmp(z,"-line")==0 ){
2624 data.mode = MODE_Line;
2625 }else if( strcmp(z,"-column")==0 ){
2626 data.mode = MODE_Column;
2627 }else if( strcmp(z,"-csv")==0 ){
2628 data.mode = MODE_Csv;
2629 memcpy(data.separator,",",2);
2630 }else if( strcmp(z,"-separator")==0 ){
2633 fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z);
2634 fprintf(stderr,"Use -help for a list of options.\n");
2637 sqlite3_snprintf(sizeof(data.separator), data.separator,
2638 "%.*s",(int)sizeof(data.separator)-1,argv[i]);
2639 }else if( strcmp(z,"-nullvalue")==0 ){
2642 fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z);
2643 fprintf(stderr,"Use -help for a list of options.\n");
2646 sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
2647 "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]);
2648 }else if( strcmp(z,"-header")==0 ){
2649 data.showHeader = 1;
2650 }else if( strcmp(z,"-noheader")==0 ){
2651 data.showHeader = 0;
2652 }else if( strcmp(z,"-echo")==0 ){
2654 }else if( strcmp(z,"-stats")==0 ){
2656 }else if( strcmp(z,"-bail")==0 ){
2658 }else if( strcmp(z,"-version")==0 ){
2659 printf("%s\n", sqlite3_libversion());
2661 }else if( strcmp(z,"-interactive")==0 ){
2662 stdin_is_interactive = 1;
2663 }else if( strcmp(z,"-batch")==0 ){
2664 stdin_is_interactive = 0;
2665 }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){
2668 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
2669 fprintf(stderr,"Use -help for a list of options.\n");
2675 /* Run just the command that follows the database name
2677 if( zFirstCmd[0]=='.' ){
2678 rc = do_meta_command(zFirstCmd, &data);
2681 rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
2683 fprintf(stderr,"Error: %s\n", zErrMsg);
2684 return rc!=0 ? rc : 1;
2686 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd);
2691 /* Run commands received from standard input
2693 if( stdin_is_interactive ){
2698 "SQLite version %s\n"
2699 "Enter \".help\" for instructions\n"
2700 "Enter SQL statements terminated with a \";\"\n",
2701 sqlite3_libversion()
2703 zHome = find_home_dir();
2705 nHistory = strlen30(zHome) + 20;
2706 if( (zHistory = malloc(nHistory))!=0 ){
2707 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
2710 #if defined(HAVE_READLINE) && HAVE_READLINE==1
2711 if( zHistory ) read_history(zHistory);
2713 rc = process_input(&data, 0);
2715 stifle_history(100);
2716 write_history(zHistory);
2721 rc = process_input(&data, stdin);
2724 set_table_name(&data, 0);
2726 if( sqlite3_close(data.db)!=SQLITE_OK ){
2727 fprintf(stderr,"Error: cannot close database \"%s\"\n",
2728 sqlite3_errmsg(db));