xref: /freebsd/contrib/sqlite3/shell.c (revision 3b8f08459569bf0faa21473e5cec2491e95c9349)
1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code.  In place of
5 ** a legal notice, here is a blessing:
6 **
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.
10 **
11 *************************************************************************
12 ** This file contains code to implement the "sqlite" command line
13 ** utility for accessing SQLite databases.
14 */
15 #if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
16 /* This needs to come before any includes for MSVC compiler */
17 #define _CRT_SECURE_NO_WARNINGS
18 #endif
19 
20 /*
21 ** Enable large-file support for fopen() and friends on unix.
22 */
23 #ifndef SQLITE_DISABLE_LFS
24 # define _LARGE_FILE       1
25 # ifndef _FILE_OFFSET_BITS
26 #   define _FILE_OFFSET_BITS 64
27 # endif
28 # define _LARGEFILE_SOURCE 1
29 #endif
30 
31 #include <stdlib.h>
32 #include <string.h>
33 #include <stdio.h>
34 #include <assert.h>
35 #include "sqlite3.h"
36 #include <ctype.h>
37 #include <stdarg.h>
38 
39 #if !defined(_WIN32) && !defined(WIN32)
40 # include <signal.h>
41 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
42 #  include <pwd.h>
43 # endif
44 # include <unistd.h>
45 # include <sys/types.h>
46 #endif
47 
48 #ifdef HAVE_EDITLINE
49 # include <editline/editline.h>
50 #endif
51 #if defined(HAVE_READLINE) && HAVE_READLINE==1
52 # include <readline/readline.h>
53 # include <readline/history.h>
54 #endif
55 #if !defined(HAVE_EDITLINE) && (!defined(HAVE_READLINE) || HAVE_READLINE!=1)
56 # define readline(p) local_getline(p,stdin,0)
57 # define add_history(X)
58 # define read_history(X)
59 # define write_history(X)
60 # define stifle_history(X)
61 #endif
62 
63 #if defined(_WIN32) || defined(WIN32)
64 # include <io.h>
65 #define isatty(h) _isatty(h)
66 #define access(f,m) _access((f),(m))
67 #undef popen
68 #define popen(a,b) _popen((a),(b))
69 #undef pclose
70 #define pclose(x) _pclose(x)
71 #else
72 /* Make sure isatty() has a prototype.
73 */
74 extern int isatty(int);
75 #endif
76 
77 #if defined(_WIN32_WCE)
78 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
79  * thus we always assume that we have a console. That can be
80  * overridden with the -batch command line option.
81  */
82 #define isatty(x) 1
83 #endif
84 
85 /* True if the timer is enabled */
86 static int enableTimer = 0;
87 
88 /* ctype macros that work with signed characters */
89 #define IsSpace(X)  isspace((unsigned char)X)
90 #define IsDigit(X)  isdigit((unsigned char)X)
91 #define ToLower(X)  (char)tolower((unsigned char)X)
92 
93 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL) \
94  && !defined(__minux)
95 #include <sys/time.h>
96 #include <sys/resource.h>
97 
98 /* Saved resource information for the beginning of an operation */
99 static struct rusage sBegin;
100 
101 /*
102 ** Begin timing an operation
103 */
104 static void beginTimer(void){
105   if( enableTimer ){
106     getrusage(RUSAGE_SELF, &sBegin);
107   }
108 }
109 
110 /* Return the difference of two time_structs in seconds */
111 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
112   return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
113          (double)(pEnd->tv_sec - pStart->tv_sec);
114 }
115 
116 /*
117 ** Print the timing results.
118 */
119 static void endTimer(void){
120   if( enableTimer ){
121     struct rusage sEnd;
122     getrusage(RUSAGE_SELF, &sEnd);
123     printf("CPU Time: user %f sys %f\n",
124        timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
125        timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
126   }
127 }
128 
129 #define BEGIN_TIMER beginTimer()
130 #define END_TIMER endTimer()
131 #define HAS_TIMER 1
132 
133 #elif (defined(_WIN32) || defined(WIN32))
134 
135 #include <windows.h>
136 
137 /* Saved resource information for the beginning of an operation */
138 static HANDLE hProcess;
139 static FILETIME ftKernelBegin;
140 static FILETIME ftUserBegin;
141 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
142 static GETPROCTIMES getProcessTimesAddr = NULL;
143 
144 /*
145 ** Check to see if we have timer support.  Return 1 if necessary
146 ** support found (or found previously).
147 */
148 static int hasTimer(void){
149   if( getProcessTimesAddr ){
150     return 1;
151   } else {
152     /* GetProcessTimes() isn't supported in WIN95 and some other Windows versions.
153     ** See if the version we are running on has it, and if it does, save off
154     ** a pointer to it and the current process handle.
155     */
156     hProcess = GetCurrentProcess();
157     if( hProcess ){
158       HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
159       if( NULL != hinstLib ){
160         getProcessTimesAddr = (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
161         if( NULL != getProcessTimesAddr ){
162           return 1;
163         }
164         FreeLibrary(hinstLib);
165       }
166     }
167   }
168   return 0;
169 }
170 
171 /*
172 ** Begin timing an operation
173 */
174 static void beginTimer(void){
175   if( enableTimer && getProcessTimesAddr ){
176     FILETIME ftCreation, ftExit;
177     getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin);
178   }
179 }
180 
181 /* Return the difference of two FILETIME structs in seconds */
182 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
183   sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
184   sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
185   return (double) ((i64End - i64Start) / 10000000.0);
186 }
187 
188 /*
189 ** Print the timing results.
190 */
191 static void endTimer(void){
192   if( enableTimer && getProcessTimesAddr){
193     FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
194     getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd);
195     printf("CPU Time: user %f sys %f\n",
196        timeDiff(&ftUserBegin, &ftUserEnd),
197        timeDiff(&ftKernelBegin, &ftKernelEnd));
198   }
199 }
200 
201 #define BEGIN_TIMER beginTimer()
202 #define END_TIMER endTimer()
203 #define HAS_TIMER hasTimer()
204 
205 #else
206 #define BEGIN_TIMER
207 #define END_TIMER
208 #define HAS_TIMER 0
209 #endif
210 
211 /*
212 ** Used to prevent warnings about unused parameters
213 */
214 #define UNUSED_PARAMETER(x) (void)(x)
215 
216 /*
217 ** If the following flag is set, then command execution stops
218 ** at an error if we are not interactive.
219 */
220 static int bail_on_error = 0;
221 
222 /*
223 ** Threat stdin as an interactive input if the following variable
224 ** is true.  Otherwise, assume stdin is connected to a file or pipe.
225 */
226 static int stdin_is_interactive = 1;
227 
228 /*
229 ** The following is the open SQLite database.  We make a pointer
230 ** to this database a static variable so that it can be accessed
231 ** by the SIGINT handler to interrupt database processing.
232 */
233 static sqlite3 *db = 0;
234 
235 /*
236 ** True if an interrupt (Control-C) has been received.
237 */
238 static volatile int seenInterrupt = 0;
239 
240 /*
241 ** This is the name of our program. It is set in main(), used
242 ** in a number of other places, mostly for error messages.
243 */
244 static char *Argv0;
245 
246 /*
247 ** Prompt strings. Initialized in main. Settable with
248 **   .prompt main continue
249 */
250 static char mainPrompt[20];     /* First line prompt. default: "sqlite> "*/
251 static char continuePrompt[20]; /* Continuation prompt. default: "   ...> " */
252 
253 /*
254 ** Write I/O traces to the following stream.
255 */
256 #ifdef SQLITE_ENABLE_IOTRACE
257 static FILE *iotrace = 0;
258 #endif
259 
260 /*
261 ** This routine works like printf in that its first argument is a
262 ** format string and subsequent arguments are values to be substituted
263 ** in place of % fields.  The result of formatting this string
264 ** is written to iotrace.
265 */
266 #ifdef SQLITE_ENABLE_IOTRACE
267 static void iotracePrintf(const char *zFormat, ...){
268   va_list ap;
269   char *z;
270   if( iotrace==0 ) return;
271   va_start(ap, zFormat);
272   z = sqlite3_vmprintf(zFormat, ap);
273   va_end(ap);
274   fprintf(iotrace, "%s", z);
275   sqlite3_free(z);
276 }
277 #endif
278 
279 
280 /*
281 ** Determines if a string is a number of not.
282 */
283 static int isNumber(const char *z, int *realnum){
284   if( *z=='-' || *z=='+' ) z++;
285   if( !IsDigit(*z) ){
286     return 0;
287   }
288   z++;
289   if( realnum ) *realnum = 0;
290   while( IsDigit(*z) ){ z++; }
291   if( *z=='.' ){
292     z++;
293     if( !IsDigit(*z) ) return 0;
294     while( IsDigit(*z) ){ z++; }
295     if( realnum ) *realnum = 1;
296   }
297   if( *z=='e' || *z=='E' ){
298     z++;
299     if( *z=='+' || *z=='-' ) z++;
300     if( !IsDigit(*z) ) return 0;
301     while( IsDigit(*z) ){ z++; }
302     if( realnum ) *realnum = 1;
303   }
304   return *z==0;
305 }
306 
307 /*
308 ** A global char* and an SQL function to access its current value
309 ** from within an SQL statement. This program used to use the
310 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
311 ** The correct way to do this with sqlite3 is to use the bind API, but
312 ** since the shell is built around the callback paradigm it would be a lot
313 ** of work. Instead just use this hack, which is quite harmless.
314 */
315 static const char *zShellStatic = 0;
316 static void shellstaticFunc(
317   sqlite3_context *context,
318   int argc,
319   sqlite3_value **argv
320 ){
321   assert( 0==argc );
322   assert( zShellStatic );
323   UNUSED_PARAMETER(argc);
324   UNUSED_PARAMETER(argv);
325   sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
326 }
327 
328 
329 /*
330 ** This routine reads a line of text from FILE in, stores
331 ** the text in memory obtained from malloc() and returns a pointer
332 ** to the text.  NULL is returned at end of file, or if malloc()
333 ** fails.
334 **
335 ** The interface is like "readline" but no command-line editing
336 ** is done.
337 */
338 static char *local_getline(char *zPrompt, FILE *in, int csvFlag){
339   char *zLine;
340   int nLine;
341   int n;
342   int inQuote = 0;
343 
344   if( zPrompt && *zPrompt ){
345     printf("%s",zPrompt);
346     fflush(stdout);
347   }
348   nLine = 100;
349   zLine = malloc( nLine );
350   if( zLine==0 ) return 0;
351   n = 0;
352   while( 1 ){
353     if( n+100>nLine ){
354       nLine = nLine*2 + 100;
355       zLine = realloc(zLine, nLine);
356       if( zLine==0 ) return 0;
357     }
358     if( fgets(&zLine[n], nLine - n, in)==0 ){
359       if( n==0 ){
360         free(zLine);
361         return 0;
362       }
363       zLine[n] = 0;
364       break;
365     }
366     while( zLine[n] ){
367       if( zLine[n]=='"' ) inQuote = !inQuote;
368       n++;
369     }
370     if( n>0 && zLine[n-1]=='\n' && (!inQuote || !csvFlag) ){
371       n--;
372       if( n>0 && zLine[n-1]=='\r' ) n--;
373       zLine[n] = 0;
374       break;
375     }
376   }
377   zLine = realloc( zLine, n+1 );
378   return zLine;
379 }
380 
381 /*
382 ** Retrieve a single line of input text.
383 **
384 ** zPrior is a string of prior text retrieved.  If not the empty
385 ** string, then issue a continuation prompt.
386 */
387 static char *one_input_line(const char *zPrior, FILE *in){
388   char *zPrompt;
389   char *zResult;
390   if( in!=0 ){
391     return local_getline(0, in, 0);
392   }
393   if( zPrior && zPrior[0] ){
394     zPrompt = continuePrompt;
395   }else{
396     zPrompt = mainPrompt;
397   }
398   zResult = readline(zPrompt);
399 #if defined(HAVE_READLINE) && HAVE_READLINE==1
400   if( zResult && *zResult ) add_history(zResult);
401 #endif
402   return zResult;
403 }
404 
405 struct previous_mode_data {
406   int valid;        /* Is there legit data in here? */
407   int mode;
408   int showHeader;
409   int colWidth[100];
410 };
411 
412 /*
413 ** An pointer to an instance of this structure is passed from
414 ** the main program to the callback.  This is used to communicate
415 ** state and mode information.
416 */
417 struct callback_data {
418   sqlite3 *db;           /* The database */
419   int echoOn;            /* True to echo input commands */
420   int statsOn;           /* True to display memory stats before each finalize */
421   int cnt;               /* Number of records displayed so far */
422   FILE *out;             /* Write results here */
423   FILE *traceOut;        /* Output for sqlite3_trace() */
424   int nErr;              /* Number of errors seen */
425   int mode;              /* An output mode setting */
426   int writableSchema;    /* True if PRAGMA writable_schema=ON */
427   int showHeader;        /* True to show column names in List or Column mode */
428   char *zDestTable;      /* Name of destination table when MODE_Insert */
429   char separator[20];    /* Separator character for MODE_List */
430   int colWidth[100];     /* Requested width of each column when in column mode*/
431   int actualWidth[100];  /* Actual width of each column */
432   char nullvalue[20];    /* The text to print when a NULL comes back from
433                          ** the database */
434   struct previous_mode_data explainPrev;
435                          /* Holds the mode information just before
436                          ** .explain ON */
437   char outfile[FILENAME_MAX]; /* Filename for *out */
438   const char *zDbFilename;    /* name of the database file */
439   const char *zVfs;           /* Name of VFS to use */
440   sqlite3_stmt *pStmt;   /* Current statement if any. */
441   FILE *pLog;            /* Write log output here */
442 };
443 
444 /*
445 ** These are the allowed modes.
446 */
447 #define MODE_Line     0  /* One column per line.  Blank line between records */
448 #define MODE_Column   1  /* One record per line in neat columns */
449 #define MODE_List     2  /* One record per line with a separator */
450 #define MODE_Semi     3  /* Same as MODE_List but append ";" to each line */
451 #define MODE_Html     4  /* Generate an XHTML table */
452 #define MODE_Insert   5  /* Generate SQL "insert" statements */
453 #define MODE_Tcl      6  /* Generate ANSI-C or TCL quoted elements */
454 #define MODE_Csv      7  /* Quote strings, numbers are plain */
455 #define MODE_Explain  8  /* Like MODE_Column, but do not truncate data */
456 
457 static const char *modeDescr[] = {
458   "line",
459   "column",
460   "list",
461   "semi",
462   "html",
463   "insert",
464   "tcl",
465   "csv",
466   "explain",
467 };
468 
469 /*
470 ** Number of elements in an array
471 */
472 #define ArraySize(X)  (int)(sizeof(X)/sizeof(X[0]))
473 
474 /*
475 ** Compute a string length that is limited to what can be stored in
476 ** lower 30 bits of a 32-bit signed integer.
477 */
478 static int strlen30(const char *z){
479   const char *z2 = z;
480   while( *z2 ){ z2++; }
481   return 0x3fffffff & (int)(z2 - z);
482 }
483 
484 /*
485 ** A callback for the sqlite3_log() interface.
486 */
487 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
488   struct callback_data *p = (struct callback_data*)pArg;
489   if( p->pLog==0 ) return;
490   fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
491   fflush(p->pLog);
492 }
493 
494 /*
495 ** Output the given string as a hex-encoded blob (eg. X'1234' )
496 */
497 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
498   int i;
499   char *zBlob = (char *)pBlob;
500   fprintf(out,"X'");
501   for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
502   fprintf(out,"'");
503 }
504 
505 /*
506 ** Output the given string as a quoted string using SQL quoting conventions.
507 */
508 static void output_quoted_string(FILE *out, const char *z){
509   int i;
510   int nSingle = 0;
511   for(i=0; z[i]; i++){
512     if( z[i]=='\'' ) nSingle++;
513   }
514   if( nSingle==0 ){
515     fprintf(out,"'%s'",z);
516   }else{
517     fprintf(out,"'");
518     while( *z ){
519       for(i=0; z[i] && z[i]!='\''; i++){}
520       if( i==0 ){
521         fprintf(out,"''");
522         z++;
523       }else if( z[i]=='\'' ){
524         fprintf(out,"%.*s''",i,z);
525         z += i+1;
526       }else{
527         fprintf(out,"%s",z);
528         break;
529       }
530     }
531     fprintf(out,"'");
532   }
533 }
534 
535 /*
536 ** Output the given string as a quoted according to C or TCL quoting rules.
537 */
538 static void output_c_string(FILE *out, const char *z){
539   unsigned int c;
540   fputc('"', out);
541   while( (c = *(z++))!=0 ){
542     if( c=='\\' ){
543       fputc(c, out);
544       fputc(c, out);
545     }else if( c=='"' ){
546       fputc('\\', out);
547       fputc('"', out);
548     }else if( c=='\t' ){
549       fputc('\\', out);
550       fputc('t', out);
551     }else if( c=='\n' ){
552       fputc('\\', out);
553       fputc('n', out);
554     }else if( c=='\r' ){
555       fputc('\\', out);
556       fputc('r', out);
557     }else if( !isprint(c) ){
558       fprintf(out, "\\%03o", c&0xff);
559     }else{
560       fputc(c, out);
561     }
562   }
563   fputc('"', out);
564 }
565 
566 /*
567 ** Output the given string with characters that are special to
568 ** HTML escaped.
569 */
570 static void output_html_string(FILE *out, const char *z){
571   int i;
572   while( *z ){
573     for(i=0;   z[i]
574             && z[i]!='<'
575             && z[i]!='&'
576             && z[i]!='>'
577             && z[i]!='\"'
578             && z[i]!='\'';
579         i++){}
580     if( i>0 ){
581       fprintf(out,"%.*s",i,z);
582     }
583     if( z[i]=='<' ){
584       fprintf(out,"&lt;");
585     }else if( z[i]=='&' ){
586       fprintf(out,"&amp;");
587     }else if( z[i]=='>' ){
588       fprintf(out,"&gt;");
589     }else if( z[i]=='\"' ){
590       fprintf(out,"&quot;");
591     }else if( z[i]=='\'' ){
592       fprintf(out,"&#39;");
593     }else{
594       break;
595     }
596     z += i + 1;
597   }
598 }
599 
600 /*
601 ** If a field contains any character identified by a 1 in the following
602 ** array, then the string must be quoted for CSV.
603 */
604 static const char needCsvQuote[] = {
605   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
606   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
607   1, 0, 1, 0, 0, 0, 0, 1,   0, 0, 0, 0, 0, 0, 0, 0,
608   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
609   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
610   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
611   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
612   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 1,
613   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
614   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
615   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
616   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
617   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
618   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
619   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
620   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
621 };
622 
623 /*
624 ** Output a single term of CSV.  Actually, p->separator is used for
625 ** the separator, which may or may not be a comma.  p->nullvalue is
626 ** the null value.  Strings are quoted if necessary.
627 */
628 static void output_csv(struct callback_data *p, const char *z, int bSep){
629   FILE *out = p->out;
630   if( z==0 ){
631     fprintf(out,"%s",p->nullvalue);
632   }else{
633     int i;
634     int nSep = strlen30(p->separator);
635     for(i=0; z[i]; i++){
636       if( needCsvQuote[((unsigned char*)z)[i]]
637          || (z[i]==p->separator[0] &&
638              (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
639         i = 0;
640         break;
641       }
642     }
643     if( i==0 ){
644       putc('"', out);
645       for(i=0; z[i]; i++){
646         if( z[i]=='"' ) putc('"', out);
647         putc(z[i], out);
648       }
649       putc('"', out);
650     }else{
651       fprintf(out, "%s", z);
652     }
653   }
654   if( bSep ){
655     fprintf(p->out, "%s", p->separator);
656   }
657 }
658 
659 #ifdef SIGINT
660 /*
661 ** This routine runs when the user presses Ctrl-C
662 */
663 static void interrupt_handler(int NotUsed){
664   UNUSED_PARAMETER(NotUsed);
665   seenInterrupt = 1;
666   if( db ) sqlite3_interrupt(db);
667 }
668 #endif
669 
670 /*
671 ** This is the callback routine that the shell
672 ** invokes for each row of a query result.
673 */
674 static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){
675   int i;
676   struct callback_data *p = (struct callback_data*)pArg;
677 
678   switch( p->mode ){
679     case MODE_Line: {
680       int w = 5;
681       if( azArg==0 ) break;
682       for(i=0; i<nArg; i++){
683         int len = strlen30(azCol[i] ? azCol[i] : "");
684         if( len>w ) w = len;
685       }
686       if( p->cnt++>0 ) fprintf(p->out,"\n");
687       for(i=0; i<nArg; i++){
688         fprintf(p->out,"%*s = %s\n", w, azCol[i],
689                 azArg[i] ? azArg[i] : p->nullvalue);
690       }
691       break;
692     }
693     case MODE_Explain:
694     case MODE_Column: {
695       if( p->cnt++==0 ){
696         for(i=0; i<nArg; i++){
697           int w, n;
698           if( i<ArraySize(p->colWidth) ){
699             w = p->colWidth[i];
700           }else{
701             w = 0;
702           }
703           if( w==0 ){
704             w = strlen30(azCol[i] ? azCol[i] : "");
705             if( w<10 ) w = 10;
706             n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);
707             if( w<n ) w = n;
708           }
709           if( i<ArraySize(p->actualWidth) ){
710             p->actualWidth[i] = w;
711           }
712           if( p->showHeader ){
713             if( w<0 ){
714               fprintf(p->out,"%*.*s%s",-w,-w,azCol[i], i==nArg-1 ? "\n": "  ");
715             }else{
716               fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": "  ");
717             }
718           }
719         }
720         if( p->showHeader ){
721           for(i=0; i<nArg; i++){
722             int w;
723             if( i<ArraySize(p->actualWidth) ){
724                w = p->actualWidth[i];
725                if( w<0 ) w = -w;
726             }else{
727                w = 10;
728             }
729             fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
730                    "----------------------------------------------------------",
731                     i==nArg-1 ? "\n": "  ");
732           }
733         }
734       }
735       if( azArg==0 ) break;
736       for(i=0; i<nArg; i++){
737         int w;
738         if( i<ArraySize(p->actualWidth) ){
739            w = p->actualWidth[i];
740         }else{
741            w = 10;
742         }
743         if( p->mode==MODE_Explain && azArg[i] &&
744            strlen30(azArg[i])>w ){
745           w = strlen30(azArg[i]);
746         }
747         if( w<0 ){
748           fprintf(p->out,"%*.*s%s",-w,-w,
749               azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": "  ");
750         }else{
751           fprintf(p->out,"%-*.*s%s",w,w,
752               azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": "  ");
753         }
754       }
755       break;
756     }
757     case MODE_Semi:
758     case MODE_List: {
759       if( p->cnt++==0 && p->showHeader ){
760         for(i=0; i<nArg; i++){
761           fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
762         }
763       }
764       if( azArg==0 ) break;
765       for(i=0; i<nArg; i++){
766         char *z = azArg[i];
767         if( z==0 ) z = p->nullvalue;
768         fprintf(p->out, "%s", z);
769         if( i<nArg-1 ){
770           fprintf(p->out, "%s", p->separator);
771         }else if( p->mode==MODE_Semi ){
772           fprintf(p->out, ";\n");
773         }else{
774           fprintf(p->out, "\n");
775         }
776       }
777       break;
778     }
779     case MODE_Html: {
780       if( p->cnt++==0 && p->showHeader ){
781         fprintf(p->out,"<TR>");
782         for(i=0; i<nArg; i++){
783           fprintf(p->out,"<TH>");
784           output_html_string(p->out, azCol[i]);
785           fprintf(p->out,"</TH>\n");
786         }
787         fprintf(p->out,"</TR>\n");
788       }
789       if( azArg==0 ) break;
790       fprintf(p->out,"<TR>");
791       for(i=0; i<nArg; i++){
792         fprintf(p->out,"<TD>");
793         output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
794         fprintf(p->out,"</TD>\n");
795       }
796       fprintf(p->out,"</TR>\n");
797       break;
798     }
799     case MODE_Tcl: {
800       if( p->cnt++==0 && p->showHeader ){
801         for(i=0; i<nArg; i++){
802           output_c_string(p->out,azCol[i] ? azCol[i] : "");
803           if(i<nArg-1) fprintf(p->out, "%s", p->separator);
804         }
805         fprintf(p->out,"\n");
806       }
807       if( azArg==0 ) break;
808       for(i=0; i<nArg; i++){
809         output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
810         if(i<nArg-1) fprintf(p->out, "%s", p->separator);
811       }
812       fprintf(p->out,"\n");
813       break;
814     }
815     case MODE_Csv: {
816       if( p->cnt++==0 && p->showHeader ){
817         for(i=0; i<nArg; i++){
818           output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
819         }
820         fprintf(p->out,"\n");
821       }
822       if( azArg==0 ) break;
823       for(i=0; i<nArg; i++){
824         output_csv(p, azArg[i], i<nArg-1);
825       }
826       fprintf(p->out,"\n");
827       break;
828     }
829     case MODE_Insert: {
830       p->cnt++;
831       if( azArg==0 ) break;
832       fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
833       for(i=0; i<nArg; i++){
834         char *zSep = i>0 ? ",": "";
835         if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
836           fprintf(p->out,"%sNULL",zSep);
837         }else if( aiType && aiType[i]==SQLITE_TEXT ){
838           if( zSep[0] ) fprintf(p->out,"%s",zSep);
839           output_quoted_string(p->out, azArg[i]);
840         }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){
841           fprintf(p->out,"%s%s",zSep, azArg[i]);
842         }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
843           const void *pBlob = sqlite3_column_blob(p->pStmt, i);
844           int nBlob = sqlite3_column_bytes(p->pStmt, i);
845           if( zSep[0] ) fprintf(p->out,"%s",zSep);
846           output_hex_blob(p->out, pBlob, nBlob);
847         }else if( isNumber(azArg[i], 0) ){
848           fprintf(p->out,"%s%s",zSep, azArg[i]);
849         }else{
850           if( zSep[0] ) fprintf(p->out,"%s",zSep);
851           output_quoted_string(p->out, azArg[i]);
852         }
853       }
854       fprintf(p->out,");\n");
855       break;
856     }
857   }
858   return 0;
859 }
860 
861 /*
862 ** This is the callback routine that the SQLite library
863 ** invokes for each row of a query result.
864 */
865 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
866   /* since we don't have type info, call the shell_callback with a NULL value */
867   return shell_callback(pArg, nArg, azArg, azCol, NULL);
868 }
869 
870 /*
871 ** Set the destination table field of the callback_data structure to
872 ** the name of the table given.  Escape any quote characters in the
873 ** table name.
874 */
875 static void set_table_name(struct callback_data *p, const char *zName){
876   int i, n;
877   int needQuote;
878   char *z;
879 
880   if( p->zDestTable ){
881     free(p->zDestTable);
882     p->zDestTable = 0;
883   }
884   if( zName==0 ) return;
885   needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
886   for(i=n=0; zName[i]; i++, n++){
887     if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
888       needQuote = 1;
889       if( zName[i]=='\'' ) n++;
890     }
891   }
892   if( needQuote ) n += 2;
893   z = p->zDestTable = malloc( n+1 );
894   if( z==0 ){
895     fprintf(stderr,"Error: out of memory\n");
896     exit(1);
897   }
898   n = 0;
899   if( needQuote ) z[n++] = '\'';
900   for(i=0; zName[i]; i++){
901     z[n++] = zName[i];
902     if( zName[i]=='\'' ) z[n++] = '\'';
903   }
904   if( needQuote ) z[n++] = '\'';
905   z[n] = 0;
906 }
907 
908 /* zIn is either a pointer to a NULL-terminated string in memory obtained
909 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
910 ** added to zIn, and the result returned in memory obtained from malloc().
911 ** zIn, if it was not NULL, is freed.
912 **
913 ** If the third argument, quote, is not '\0', then it is used as a
914 ** quote character for zAppend.
915 */
916 static char *appendText(char *zIn, char const *zAppend, char quote){
917   int len;
918   int i;
919   int nAppend = strlen30(zAppend);
920   int nIn = (zIn?strlen30(zIn):0);
921 
922   len = nAppend+nIn+1;
923   if( quote ){
924     len += 2;
925     for(i=0; i<nAppend; i++){
926       if( zAppend[i]==quote ) len++;
927     }
928   }
929 
930   zIn = (char *)realloc(zIn, len);
931   if( !zIn ){
932     return 0;
933   }
934 
935   if( quote ){
936     char *zCsr = &zIn[nIn];
937     *zCsr++ = quote;
938     for(i=0; i<nAppend; i++){
939       *zCsr++ = zAppend[i];
940       if( zAppend[i]==quote ) *zCsr++ = quote;
941     }
942     *zCsr++ = quote;
943     *zCsr++ = '\0';
944     assert( (zCsr-zIn)==len );
945   }else{
946     memcpy(&zIn[nIn], zAppend, nAppend);
947     zIn[len-1] = '\0';
948   }
949 
950   return zIn;
951 }
952 
953 
954 /*
955 ** Execute a query statement that will generate SQL output.  Print
956 ** the result columns, comma-separated, on a line and then add a
957 ** semicolon terminator to the end of that line.
958 **
959 ** If the number of columns is 1 and that column contains text "--"
960 ** then write the semicolon on a separate line.  That way, if a
961 ** "--" comment occurs at the end of the statement, the comment
962 ** won't consume the semicolon terminator.
963 */
964 static int run_table_dump_query(
965   struct callback_data *p, /* Query context */
966   const char *zSelect,     /* SELECT statement to extract content */
967   const char *zFirstRow    /* Print before first row, if not NULL */
968 ){
969   sqlite3_stmt *pSelect;
970   int rc;
971   int nResult;
972   int i;
973   const char *z;
974   rc = sqlite3_prepare(p->db, zSelect, -1, &pSelect, 0);
975   if( rc!=SQLITE_OK || !pSelect ){
976     fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
977     p->nErr++;
978     return rc;
979   }
980   rc = sqlite3_step(pSelect);
981   nResult = sqlite3_column_count(pSelect);
982   while( rc==SQLITE_ROW ){
983     if( zFirstRow ){
984       fprintf(p->out, "%s", zFirstRow);
985       zFirstRow = 0;
986     }
987     z = (const char*)sqlite3_column_text(pSelect, 0);
988     fprintf(p->out, "%s", z);
989     for(i=1; i<nResult; i++){
990       fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
991     }
992     if( z==0 ) z = "";
993     while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
994     if( z[0] ){
995       fprintf(p->out, "\n;\n");
996     }else{
997       fprintf(p->out, ";\n");
998     }
999     rc = sqlite3_step(pSelect);
1000   }
1001   rc = sqlite3_finalize(pSelect);
1002   if( rc!=SQLITE_OK ){
1003     fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1004     p->nErr++;
1005   }
1006   return rc;
1007 }
1008 
1009 /*
1010 ** Allocate space and save off current error string.
1011 */
1012 static char *save_err_msg(
1013   sqlite3 *db            /* Database to query */
1014 ){
1015   int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1016   char *zErrMsg = sqlite3_malloc(nErrMsg);
1017   if( zErrMsg ){
1018     memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1019   }
1020   return zErrMsg;
1021 }
1022 
1023 /*
1024 ** Display memory stats.
1025 */
1026 static int display_stats(
1027   sqlite3 *db,                /* Database to query */
1028   struct callback_data *pArg, /* Pointer to struct callback_data */
1029   int bReset                  /* True to reset the stats */
1030 ){
1031   int iCur;
1032   int iHiwtr;
1033 
1034   if( pArg && pArg->out ){
1035 
1036     iHiwtr = iCur = -1;
1037     sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1038     fprintf(pArg->out, "Memory Used:                         %d (max %d) bytes\n", iCur, iHiwtr);
1039     iHiwtr = iCur = -1;
1040     sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1041     fprintf(pArg->out, "Number of Outstanding Allocations:   %d (max %d)\n", iCur, iHiwtr);
1042 /*
1043 ** Not currently used by the CLI.
1044 **    iHiwtr = iCur = -1;
1045 **    sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1046 **    fprintf(pArg->out, "Number of Pcache Pages Used:         %d (max %d) pages\n", iCur, iHiwtr);
1047 */
1048     iHiwtr = iCur = -1;
1049     sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1050     fprintf(pArg->out, "Number of Pcache Overflow Bytes:     %d (max %d) bytes\n", iCur, iHiwtr);
1051 /*
1052 ** Not currently used by the CLI.
1053 **    iHiwtr = iCur = -1;
1054 **    sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1055 **    fprintf(pArg->out, "Number of Scratch Allocations Used:  %d (max %d)\n", iCur, iHiwtr);
1056 */
1057     iHiwtr = iCur = -1;
1058     sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1059     fprintf(pArg->out, "Number of Scratch Overflow Bytes:    %d (max %d) bytes\n", iCur, iHiwtr);
1060     iHiwtr = iCur = -1;
1061     sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1062     fprintf(pArg->out, "Largest Allocation:                  %d bytes\n", iHiwtr);
1063     iHiwtr = iCur = -1;
1064     sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1065     fprintf(pArg->out, "Largest Pcache Allocation:           %d bytes\n", iHiwtr);
1066     iHiwtr = iCur = -1;
1067     sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1068     fprintf(pArg->out, "Largest Scratch Allocation:          %d bytes\n", iHiwtr);
1069 #ifdef YYTRACKMAXSTACKDEPTH
1070     iHiwtr = iCur = -1;
1071     sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1072     fprintf(pArg->out, "Deepest Parser Stack:                %d (max %d)\n", iCur, iHiwtr);
1073 #endif
1074   }
1075 
1076   if( pArg && pArg->out && db ){
1077     iHiwtr = iCur = -1;
1078     sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHiwtr, bReset);
1079     fprintf(pArg->out, "Lookaside Slots Used:                %d (max %d)\n", iCur, iHiwtr);
1080     sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, &iCur, &iHiwtr, bReset);
1081     fprintf(pArg->out, "Successful lookaside attempts:       %d\n", iHiwtr);
1082     sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, &iCur, &iHiwtr, bReset);
1083     fprintf(pArg->out, "Lookaside failures due to size:      %d\n", iHiwtr);
1084     sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, &iCur, &iHiwtr, bReset);
1085     fprintf(pArg->out, "Lookaside failures due to OOM:       %d\n", iHiwtr);
1086     iHiwtr = iCur = -1;
1087     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1088     fprintf(pArg->out, "Pager Heap Usage:                    %d bytes\n", iCur);    iHiwtr = iCur = -1;
1089     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1090     fprintf(pArg->out, "Page cache hits:                     %d\n", iCur);
1091     iHiwtr = iCur = -1;
1092     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1093     fprintf(pArg->out, "Page cache misses:                   %d\n", iCur);
1094     iHiwtr = iCur = -1;
1095     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1096     fprintf(pArg->out, "Page cache writes:                   %d\n", iCur);
1097     iHiwtr = iCur = -1;
1098     sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1099     fprintf(pArg->out, "Schema Heap Usage:                   %d bytes\n", iCur);
1100     iHiwtr = iCur = -1;
1101     sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1102     fprintf(pArg->out, "Statement Heap/Lookaside Usage:      %d bytes\n", iCur);
1103   }
1104 
1105   if( pArg && pArg->out && db && pArg->pStmt ){
1106     iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, bReset);
1107     fprintf(pArg->out, "Fullscan Steps:                      %d\n", iCur);
1108     iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1109     fprintf(pArg->out, "Sort Operations:                     %d\n", iCur);
1110     iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX, bReset);
1111     fprintf(pArg->out, "Autoindex Inserts:                   %d\n", iCur);
1112   }
1113 
1114   return 0;
1115 }
1116 
1117 /*
1118 ** Execute a statement or set of statements.  Print
1119 ** any result rows/columns depending on the current mode
1120 ** set via the supplied callback.
1121 **
1122 ** This is very similar to SQLite's built-in sqlite3_exec()
1123 ** function except it takes a slightly different callback
1124 ** and callback data argument.
1125 */
1126 static int shell_exec(
1127   sqlite3 *db,                                /* An open database */
1128   const char *zSql,                           /* SQL to be evaluated */
1129   int (*xCallback)(void*,int,char**,char**,int*),   /* Callback function */
1130                                               /* (not the same as sqlite3_exec) */
1131   struct callback_data *pArg,                 /* Pointer to struct callback_data */
1132   char **pzErrMsg                             /* Error msg written here */
1133 ){
1134   sqlite3_stmt *pStmt = NULL;     /* Statement to execute. */
1135   int rc = SQLITE_OK;             /* Return Code */
1136   int rc2;
1137   const char *zLeftover;          /* Tail of unprocessed SQL */
1138 
1139   if( pzErrMsg ){
1140     *pzErrMsg = NULL;
1141   }
1142 
1143   while( zSql[0] && (SQLITE_OK == rc) ){
1144     rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1145     if( SQLITE_OK != rc ){
1146       if( pzErrMsg ){
1147         *pzErrMsg = save_err_msg(db);
1148       }
1149     }else{
1150       if( !pStmt ){
1151         /* this happens for a comment or white-space */
1152         zSql = zLeftover;
1153         while( IsSpace(zSql[0]) ) zSql++;
1154         continue;
1155       }
1156 
1157       /* save off the prepared statment handle and reset row count */
1158       if( pArg ){
1159         pArg->pStmt = pStmt;
1160         pArg->cnt = 0;
1161       }
1162 
1163       /* echo the sql statement if echo on */
1164       if( pArg && pArg->echoOn ){
1165         const char *zStmtSql = sqlite3_sql(pStmt);
1166         fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1167       }
1168 
1169       /* Output TESTCTRL_EXPLAIN text of requested */
1170       if( pArg && pArg->mode==MODE_Explain ){
1171         const char *zExplain = 0;
1172         sqlite3_test_control(SQLITE_TESTCTRL_EXPLAIN_STMT, pStmt, &zExplain);
1173         if( zExplain && zExplain[0] ){
1174           fprintf(pArg->out, "%s", zExplain);
1175         }
1176       }
1177 
1178       /* perform the first step.  this will tell us if we
1179       ** have a result set or not and how wide it is.
1180       */
1181       rc = sqlite3_step(pStmt);
1182       /* if we have a result set... */
1183       if( SQLITE_ROW == rc ){
1184         /* if we have a callback... */
1185         if( xCallback ){
1186           /* allocate space for col name ptr, value ptr, and type */
1187           int nCol = sqlite3_column_count(pStmt);
1188           void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1189           if( !pData ){
1190             rc = SQLITE_NOMEM;
1191           }else{
1192             char **azCols = (char **)pData;      /* Names of result columns */
1193             char **azVals = &azCols[nCol];       /* Results */
1194             int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1195             int i;
1196             assert(sizeof(int) <= sizeof(char *));
1197             /* save off ptrs to column names */
1198             for(i=0; i<nCol; i++){
1199               azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1200             }
1201             do{
1202               /* extract the data and data types */
1203               for(i=0; i<nCol; i++){
1204                 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
1205                 aiTypes[i] = sqlite3_column_type(pStmt, i);
1206                 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1207                   rc = SQLITE_NOMEM;
1208                   break; /* from for */
1209                 }
1210               } /* end for */
1211 
1212               /* if data and types extracted successfully... */
1213               if( SQLITE_ROW == rc ){
1214                 /* call the supplied callback with the result row data */
1215                 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1216                   rc = SQLITE_ABORT;
1217                 }else{
1218                   rc = sqlite3_step(pStmt);
1219                 }
1220               }
1221             } while( SQLITE_ROW == rc );
1222             sqlite3_free(pData);
1223           }
1224         }else{
1225           do{
1226             rc = sqlite3_step(pStmt);
1227           } while( rc == SQLITE_ROW );
1228         }
1229       }
1230 
1231       /* print usage stats if stats on */
1232       if( pArg && pArg->statsOn ){
1233         display_stats(db, pArg, 0);
1234       }
1235 
1236       /* Finalize the statement just executed. If this fails, save a
1237       ** copy of the error message. Otherwise, set zSql to point to the
1238       ** next statement to execute. */
1239       rc2 = sqlite3_finalize(pStmt);
1240       if( rc!=SQLITE_NOMEM ) rc = rc2;
1241       if( rc==SQLITE_OK ){
1242         zSql = zLeftover;
1243         while( IsSpace(zSql[0]) ) zSql++;
1244       }else if( pzErrMsg ){
1245         *pzErrMsg = save_err_msg(db);
1246       }
1247 
1248       /* clear saved stmt handle */
1249       if( pArg ){
1250         pArg->pStmt = NULL;
1251       }
1252     }
1253   } /* end while */
1254 
1255   return rc;
1256 }
1257 
1258 
1259 /*
1260 ** This is a different callback routine used for dumping the database.
1261 ** Each row received by this callback consists of a table name,
1262 ** the table type ("index" or "table") and SQL to create the table.
1263 ** This routine should print text sufficient to recreate the table.
1264 */
1265 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1266   int rc;
1267   const char *zTable;
1268   const char *zType;
1269   const char *zSql;
1270   const char *zPrepStmt = 0;
1271   struct callback_data *p = (struct callback_data *)pArg;
1272 
1273   UNUSED_PARAMETER(azCol);
1274   if( nArg!=3 ) return 1;
1275   zTable = azArg[0];
1276   zType = azArg[1];
1277   zSql = azArg[2];
1278 
1279   if( strcmp(zTable, "sqlite_sequence")==0 ){
1280     zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1281   }else if( strcmp(zTable, "sqlite_stat1")==0 ){
1282     fprintf(p->out, "ANALYZE sqlite_master;\n");
1283   }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1284     return 0;
1285   }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1286     char *zIns;
1287     if( !p->writableSchema ){
1288       fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1289       p->writableSchema = 1;
1290     }
1291     zIns = sqlite3_mprintf(
1292        "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1293        "VALUES('table','%q','%q',0,'%q');",
1294        zTable, zTable, zSql);
1295     fprintf(p->out, "%s\n", zIns);
1296     sqlite3_free(zIns);
1297     return 0;
1298   }else{
1299     fprintf(p->out, "%s;\n", zSql);
1300   }
1301 
1302   if( strcmp(zType, "table")==0 ){
1303     sqlite3_stmt *pTableInfo = 0;
1304     char *zSelect = 0;
1305     char *zTableInfo = 0;
1306     char *zTmp = 0;
1307     int nRow = 0;
1308 
1309     zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1310     zTableInfo = appendText(zTableInfo, zTable, '"');
1311     zTableInfo = appendText(zTableInfo, ");", 0);
1312 
1313     rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1314     free(zTableInfo);
1315     if( rc!=SQLITE_OK || !pTableInfo ){
1316       return 1;
1317     }
1318 
1319     zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1320     /* Always quote the table name, even if it appears to be pure ascii,
1321     ** in case it is a keyword. Ex:  INSERT INTO "table" ... */
1322     zTmp = appendText(zTmp, zTable, '"');
1323     if( zTmp ){
1324       zSelect = appendText(zSelect, zTmp, '\'');
1325       free(zTmp);
1326     }
1327     zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1328     rc = sqlite3_step(pTableInfo);
1329     while( rc==SQLITE_ROW ){
1330       const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1331       zSelect = appendText(zSelect, "quote(", 0);
1332       zSelect = appendText(zSelect, zText, '"');
1333       rc = sqlite3_step(pTableInfo);
1334       if( rc==SQLITE_ROW ){
1335         zSelect = appendText(zSelect, "), ", 0);
1336       }else{
1337         zSelect = appendText(zSelect, ") ", 0);
1338       }
1339       nRow++;
1340     }
1341     rc = sqlite3_finalize(pTableInfo);
1342     if( rc!=SQLITE_OK || nRow==0 ){
1343       free(zSelect);
1344       return 1;
1345     }
1346     zSelect = appendText(zSelect, "|| ')' FROM  ", 0);
1347     zSelect = appendText(zSelect, zTable, '"');
1348 
1349     rc = run_table_dump_query(p, zSelect, zPrepStmt);
1350     if( rc==SQLITE_CORRUPT ){
1351       zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1352       run_table_dump_query(p, zSelect, 0);
1353     }
1354     free(zSelect);
1355   }
1356   return 0;
1357 }
1358 
1359 /*
1360 ** Run zQuery.  Use dump_callback() as the callback routine so that
1361 ** the contents of the query are output as SQL statements.
1362 **
1363 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1364 ** "ORDER BY rowid DESC" to the end.
1365 */
1366 static int run_schema_dump_query(
1367   struct callback_data *p,
1368   const char *zQuery
1369 ){
1370   int rc;
1371   char *zErr = 0;
1372   rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1373   if( rc==SQLITE_CORRUPT ){
1374     char *zQ2;
1375     int len = strlen30(zQuery);
1376     fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1377     if( zErr ){
1378       fprintf(p->out, "/****** %s ******/\n", zErr);
1379       sqlite3_free(zErr);
1380       zErr = 0;
1381     }
1382     zQ2 = malloc( len+100 );
1383     if( zQ2==0 ) return rc;
1384     sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1385     rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1386     if( rc ){
1387       fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1388     }else{
1389       rc = SQLITE_CORRUPT;
1390     }
1391     sqlite3_free(zErr);
1392     free(zQ2);
1393   }
1394   return rc;
1395 }
1396 
1397 /*
1398 ** Text of a help message
1399 */
1400 static char zHelp[] =
1401   ".backup ?DB? FILE      Backup DB (default \"main\") to FILE\n"
1402   ".bail ON|OFF           Stop after hitting an error.  Default OFF\n"
1403   ".databases             List names and files of attached databases\n"
1404   ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
1405   "                         If TABLE specified, only dump tables matching\n"
1406   "                         LIKE pattern TABLE.\n"
1407   ".echo ON|OFF           Turn command echo on or off\n"
1408   ".exit                  Exit this program\n"
1409   ".explain ?ON|OFF?      Turn output mode suitable for EXPLAIN on or off.\n"
1410   "                         With no args, it turns EXPLAIN on.\n"
1411   ".header(s) ON|OFF      Turn display of headers on or off\n"
1412   ".help                  Show this message\n"
1413   ".import FILE TABLE     Import data from FILE into TABLE\n"
1414   ".indices ?TABLE?       Show names of all indices\n"
1415   "                         If TABLE specified, only show indices for tables\n"
1416   "                         matching LIKE pattern TABLE.\n"
1417 #ifdef SQLITE_ENABLE_IOTRACE
1418   ".iotrace FILE          Enable I/O diagnostic logging to FILE\n"
1419 #endif
1420 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1421   ".load FILE ?ENTRY?     Load an extension library\n"
1422 #endif
1423   ".log FILE|off          Turn logging on or off.  FILE can be stderr/stdout\n"
1424   ".mode MODE ?TABLE?     Set output mode where MODE is one of:\n"
1425   "                         csv      Comma-separated values\n"
1426   "                         column   Left-aligned columns.  (See .width)\n"
1427   "                         html     HTML <table> code\n"
1428   "                         insert   SQL insert statements for TABLE\n"
1429   "                         line     One value per line\n"
1430   "                         list     Values delimited by .separator string\n"
1431   "                         tabs     Tab-separated values\n"
1432   "                         tcl      TCL list elements\n"
1433   ".nullvalue STRING      Use STRING in place of NULL values\n"
1434   ".output FILENAME       Send output to FILENAME\n"
1435   ".output stdout         Send output to the screen\n"
1436   ".print STRING...       Print literal STRING\n"
1437   ".prompt MAIN CONTINUE  Replace the standard prompts\n"
1438   ".quit                  Exit this program\n"
1439   ".read FILENAME         Execute SQL in FILENAME\n"
1440   ".restore ?DB? FILE     Restore content of DB (default \"main\") from FILE\n"
1441   ".schema ?TABLE?        Show the CREATE statements\n"
1442   "                         If TABLE specified, only show tables matching\n"
1443   "                         LIKE pattern TABLE.\n"
1444   ".separator STRING      Change separator used by output mode and .import\n"
1445   ".show                  Show the current values for various settings\n"
1446   ".stats ON|OFF          Turn stats on or off\n"
1447   ".tables ?TABLE?        List names of tables\n"
1448   "                         If TABLE specified, only list tables matching\n"
1449   "                         LIKE pattern TABLE.\n"
1450   ".timeout MS            Try opening locked tables for MS milliseconds\n"
1451   ".trace FILE|off        Output each SQL statement as it is run\n"
1452   ".vfsname ?AUX?         Print the name of the VFS stack\n"
1453   ".width NUM1 NUM2 ...   Set column widths for \"column\" mode\n"
1454 ;
1455 
1456 static char zTimerHelp[] =
1457   ".timer ON|OFF          Turn the CPU timer measurement on or off\n"
1458 ;
1459 
1460 /* Forward reference */
1461 static int process_input(struct callback_data *p, FILE *in);
1462 
1463 /*
1464 ** Make sure the database is open.  If it is not, then open it.  If
1465 ** the database fails to open, print an error message and exit.
1466 */
1467 static void open_db(struct callback_data *p){
1468   if( p->db==0 ){
1469     sqlite3_initialize();
1470     sqlite3_open(p->zDbFilename, &p->db);
1471     db = p->db;
1472     if( db && sqlite3_errcode(db)==SQLITE_OK ){
1473       sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1474           shellstaticFunc, 0, 0);
1475     }
1476     if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1477       fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1478           p->zDbFilename, sqlite3_errmsg(db));
1479       exit(1);
1480     }
1481 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1482     sqlite3_enable_load_extension(p->db, 1);
1483 #endif
1484   }
1485 }
1486 
1487 /*
1488 ** Do C-language style dequoting.
1489 **
1490 **    \t    -> tab
1491 **    \n    -> newline
1492 **    \r    -> carriage return
1493 **    \NNN  -> ascii character NNN in octal
1494 **    \\    -> backslash
1495 */
1496 static void resolve_backslashes(char *z){
1497   int i, j;
1498   char c;
1499   for(i=j=0; (c = z[i])!=0; i++, j++){
1500     if( c=='\\' ){
1501       c = z[++i];
1502       if( c=='n' ){
1503         c = '\n';
1504       }else if( c=='t' ){
1505         c = '\t';
1506       }else if( c=='r' ){
1507         c = '\r';
1508       }else if( c>='0' && c<='7' ){
1509         c -= '0';
1510         if( z[i+1]>='0' && z[i+1]<='7' ){
1511           i++;
1512           c = (c<<3) + z[i] - '0';
1513           if( z[i+1]>='0' && z[i+1]<='7' ){
1514             i++;
1515             c = (c<<3) + z[i] - '0';
1516           }
1517         }
1518       }
1519     }
1520     z[j] = c;
1521   }
1522   z[j] = 0;
1523 }
1524 
1525 /*
1526 ** Interpret zArg as a boolean value.  Return either 0 or 1.
1527 */
1528 static int booleanValue(char *zArg){
1529   int i;
1530   for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
1531   if( i>0 && zArg[i]==0 ) return atoi(zArg);
1532   if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
1533     return 1;
1534   }
1535   if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
1536     return 0;
1537   }
1538   fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
1539           zArg);
1540   return 0;
1541 }
1542 
1543 /*
1544 ** Interpret zArg as an integer value, possibly with suffixes.
1545 */
1546 static sqlite3_int64 integerValue(const char *zArg){
1547   sqlite3_int64 v = 0;
1548   static const struct { char *zSuffix; int iMult; } aMult[] = {
1549     { "KiB", 1024 },
1550     { "MiB", 1024*1024 },
1551     { "GiB", 1024*1024*1024 },
1552     { "KB",  1000 },
1553     { "MB",  1000000 },
1554     { "GB",  1000000000 },
1555     { "K",   1000 },
1556     { "M",   1000000 },
1557     { "G",   1000000000 },
1558   };
1559   int i;
1560   int isNeg = 0;
1561   if( zArg[0]=='-' ){
1562     isNeg = 1;
1563     zArg++;
1564   }else if( zArg[0]=='+' ){
1565     zArg++;
1566   }
1567   while( isdigit(zArg[0]) ){
1568     v = v*10 + zArg[0] - '0';
1569     zArg++;
1570   }
1571   for(i=0; i<sizeof(aMult)/sizeof(aMult[0]); i++){
1572     if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
1573       v *= aMult[i].iMult;
1574       break;
1575     }
1576   }
1577   return isNeg? -v : v;
1578 }
1579 
1580 /*
1581 ** Close an output file, assuming it is not stderr or stdout
1582 */
1583 static void output_file_close(FILE *f){
1584   if( f && f!=stdout && f!=stderr ) fclose(f);
1585 }
1586 
1587 /*
1588 ** Try to open an output file.   The names "stdout" and "stderr" are
1589 ** recognized and do the right thing.  NULL is returned if the output
1590 ** filename is "off".
1591 */
1592 static FILE *output_file_open(const char *zFile){
1593   FILE *f;
1594   if( strcmp(zFile,"stdout")==0 ){
1595     f = stdout;
1596   }else if( strcmp(zFile, "stderr")==0 ){
1597     f = stderr;
1598   }else if( strcmp(zFile, "off")==0 ){
1599     f = 0;
1600   }else{
1601     f = fopen(zFile, "wb");
1602     if( f==0 ){
1603       fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1604     }
1605   }
1606   return f;
1607 }
1608 
1609 /*
1610 ** A routine for handling output from sqlite3_trace().
1611 */
1612 static void sql_trace_callback(void *pArg, const char *z){
1613   FILE *f = (FILE*)pArg;
1614   if( f ) fprintf(f, "%s\n", z);
1615 }
1616 
1617 /*
1618 ** A no-op routine that runs with the ".breakpoint" doc-command.  This is
1619 ** a useful spot to set a debugger breakpoint.
1620 */
1621 static void test_breakpoint(void){
1622   static int nCall = 0;
1623   nCall++;
1624 }
1625 
1626 /*
1627 ** If an input line begins with "." then invoke this routine to
1628 ** process that line.
1629 **
1630 ** Return 1 on error, 2 to exit, and 0 otherwise.
1631 */
1632 static int do_meta_command(char *zLine, struct callback_data *p){
1633   int i = 1;
1634   int nArg = 0;
1635   int n, c;
1636   int rc = 0;
1637   char *azArg[50];
1638 
1639   /* Parse the input line into tokens.
1640   */
1641   while( zLine[i] && nArg<ArraySize(azArg) ){
1642     while( IsSpace(zLine[i]) ){ i++; }
1643     if( zLine[i]==0 ) break;
1644     if( zLine[i]=='\'' || zLine[i]=='"' ){
1645       int delim = zLine[i++];
1646       azArg[nArg++] = &zLine[i];
1647       while( zLine[i] && zLine[i]!=delim ){ i++; }
1648       if( zLine[i]==delim ){
1649         zLine[i++] = 0;
1650       }
1651       if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1652     }else{
1653       azArg[nArg++] = &zLine[i];
1654       while( zLine[i] && !IsSpace(zLine[i]) ){ i++; }
1655       if( zLine[i] ) zLine[i++] = 0;
1656       resolve_backslashes(azArg[nArg-1]);
1657     }
1658   }
1659 
1660   /* Process the input line.
1661   */
1662   if( nArg==0 ) return 0; /* no tokens, no error */
1663   n = strlen30(azArg[0]);
1664   c = azArg[0][0];
1665   if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 ){
1666     const char *zDestFile = 0;
1667     const char *zDb = 0;
1668     const char *zKey = 0;
1669     sqlite3 *pDest;
1670     sqlite3_backup *pBackup;
1671     int j;
1672     for(j=1; j<nArg; j++){
1673       const char *z = azArg[j];
1674       if( z[0]=='-' ){
1675         while( z[0]=='-' ) z++;
1676         if( strcmp(z,"key")==0 && j<nArg-1 ){
1677           zKey = azArg[++j];
1678         }else
1679         {
1680           fprintf(stderr, "unknown option: %s\n", azArg[j]);
1681           return 1;
1682         }
1683       }else if( zDestFile==0 ){
1684         zDestFile = azArg[j];
1685       }else if( zDb==0 ){
1686         zDb = zDestFile;
1687         zDestFile = azArg[j];
1688       }else{
1689         fprintf(stderr, "too many arguments to .backup\n");
1690         return 1;
1691       }
1692     }
1693     if( zDestFile==0 ){
1694       fprintf(stderr, "missing FILENAME argument on .backup\n");
1695       return 1;
1696     }
1697     if( zDb==0 ) zDb = "main";
1698     rc = sqlite3_open(zDestFile, &pDest);
1699     if( rc!=SQLITE_OK ){
1700       fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
1701       sqlite3_close(pDest);
1702       return 1;
1703     }
1704 #ifdef SQLITE_HAS_CODEC
1705     sqlite3_key(pDest, zKey, (int)strlen(zKey));
1706 #else
1707     (void)zKey;
1708 #endif
1709     open_db(p);
1710     pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
1711     if( pBackup==0 ){
1712       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1713       sqlite3_close(pDest);
1714       return 1;
1715     }
1716     while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
1717     sqlite3_backup_finish(pBackup);
1718     if( rc==SQLITE_DONE ){
1719       rc = 0;
1720     }else{
1721       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1722       rc = 1;
1723     }
1724     sqlite3_close(pDest);
1725   }else
1726 
1727   if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){
1728     bail_on_error = booleanValue(azArg[1]);
1729   }else
1730 
1731   /* The undocumented ".breakpoint" command causes a call to the no-op
1732   ** routine named test_breakpoint().
1733   */
1734   if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
1735     test_breakpoint();
1736   }else
1737 
1738   if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
1739     struct callback_data data;
1740     char *zErrMsg = 0;
1741     open_db(p);
1742     memcpy(&data, p, sizeof(data));
1743     data.showHeader = 1;
1744     data.mode = MODE_Column;
1745     data.colWidth[0] = 3;
1746     data.colWidth[1] = 15;
1747     data.colWidth[2] = 58;
1748     data.cnt = 0;
1749     sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
1750     if( zErrMsg ){
1751       fprintf(stderr,"Error: %s\n", zErrMsg);
1752       sqlite3_free(zErrMsg);
1753       rc = 1;
1754     }
1755   }else
1756 
1757   if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
1758     open_db(p);
1759     /* When playing back a "dump", the content might appear in an order
1760     ** which causes immediate foreign key constraints to be violated.
1761     ** So disable foreign-key constraint enforcement to prevent problems. */
1762     fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
1763     fprintf(p->out, "BEGIN TRANSACTION;\n");
1764     p->writableSchema = 0;
1765     sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
1766     p->nErr = 0;
1767     if( nArg==1 ){
1768       run_schema_dump_query(p,
1769         "SELECT name, type, sql FROM sqlite_master "
1770         "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
1771       );
1772       run_schema_dump_query(p,
1773         "SELECT name, type, sql FROM sqlite_master "
1774         "WHERE name=='sqlite_sequence'"
1775       );
1776       run_table_dump_query(p,
1777         "SELECT sql FROM sqlite_master "
1778         "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
1779       );
1780     }else{
1781       int i;
1782       for(i=1; i<nArg; i++){
1783         zShellStatic = azArg[i];
1784         run_schema_dump_query(p,
1785           "SELECT name, type, sql FROM sqlite_master "
1786           "WHERE tbl_name LIKE shellstatic() AND type=='table'"
1787           "  AND sql NOT NULL");
1788         run_table_dump_query(p,
1789           "SELECT sql FROM sqlite_master "
1790           "WHERE sql NOT NULL"
1791           "  AND type IN ('index','trigger','view')"
1792           "  AND tbl_name LIKE shellstatic()", 0
1793         );
1794         zShellStatic = 0;
1795       }
1796     }
1797     if( p->writableSchema ){
1798       fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
1799       p->writableSchema = 0;
1800     }
1801     sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
1802     sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
1803     fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
1804   }else
1805 
1806   if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){
1807     p->echoOn = booleanValue(azArg[1]);
1808   }else
1809 
1810   if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
1811     if( nArg>1 && (rc = atoi(azArg[1]))!=0 ) exit(rc);
1812     rc = 2;
1813   }else
1814 
1815   if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){
1816     int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
1817     if(val == 1) {
1818       if(!p->explainPrev.valid) {
1819         p->explainPrev.valid = 1;
1820         p->explainPrev.mode = p->mode;
1821         p->explainPrev.showHeader = p->showHeader;
1822         memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
1823       }
1824       /* We could put this code under the !p->explainValid
1825       ** condition so that it does not execute if we are already in
1826       ** explain mode. However, always executing it allows us an easy
1827       ** was to reset to explain mode in case the user previously
1828       ** did an .explain followed by a .width, .mode or .header
1829       ** command.
1830       */
1831       p->mode = MODE_Explain;
1832       p->showHeader = 1;
1833       memset(p->colWidth,0,ArraySize(p->colWidth));
1834       p->colWidth[0] = 4;                  /* addr */
1835       p->colWidth[1] = 13;                 /* opcode */
1836       p->colWidth[2] = 4;                  /* P1 */
1837       p->colWidth[3] = 4;                  /* P2 */
1838       p->colWidth[4] = 4;                  /* P3 */
1839       p->colWidth[5] = 13;                 /* P4 */
1840       p->colWidth[6] = 2;                  /* P5 */
1841       p->colWidth[7] = 13;                  /* Comment */
1842     }else if (p->explainPrev.valid) {
1843       p->explainPrev.valid = 0;
1844       p->mode = p->explainPrev.mode;
1845       p->showHeader = p->explainPrev.showHeader;
1846       memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
1847     }
1848   }else
1849 
1850   if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
1851                  strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){
1852     p->showHeader = booleanValue(azArg[1]);
1853   }else
1854 
1855   if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1856     fprintf(stderr,"%s",zHelp);
1857     if( HAS_TIMER ){
1858       fprintf(stderr,"%s",zTimerHelp);
1859     }
1860   }else
1861 
1862   if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1863     char *zTable = azArg[2];    /* Insert data into this table */
1864     char *zFile = azArg[1];     /* The file from which to extract data */
1865     sqlite3_stmt *pStmt = NULL; /* A statement */
1866     int nCol;                   /* Number of columns in the table */
1867     int nByte;                  /* Number of bytes in an SQL string */
1868     int i, j;                   /* Loop counters */
1869     int nSep;                   /* Number of bytes in p->separator[] */
1870     char *zSql;                 /* An SQL statement */
1871     char *zLine;                /* A single line of input from the file */
1872     char **azCol;               /* zLine[] broken up into columns */
1873     char *zCommit;              /* How to commit changes */
1874     FILE *in;                   /* The input file */
1875     int lineno = 0;             /* Line number of input file */
1876 
1877     open_db(p);
1878     nSep = strlen30(p->separator);
1879     if( nSep==0 ){
1880       fprintf(stderr, "Error: non-null separator required for import\n");
1881       return 1;
1882     }
1883     zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
1884     if( zSql==0 ){
1885       fprintf(stderr, "Error: out of memory\n");
1886       return 1;
1887     }
1888     nByte = strlen30(zSql);
1889     rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1890     sqlite3_free(zSql);
1891     if( rc ){
1892       if (pStmt) sqlite3_finalize(pStmt);
1893       fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1894       return 1;
1895     }
1896     nCol = sqlite3_column_count(pStmt);
1897     sqlite3_finalize(pStmt);
1898     pStmt = 0;
1899     if( nCol==0 ) return 0; /* no columns, no error */
1900     zSql = malloc( nByte + 20 + nCol*2 );
1901     if( zSql==0 ){
1902       fprintf(stderr, "Error: out of memory\n");
1903       return 1;
1904     }
1905     sqlite3_snprintf(nByte+20, zSql, "INSERT INTO %s VALUES(?", zTable);
1906     j = strlen30(zSql);
1907     for(i=1; i<nCol; i++){
1908       zSql[j++] = ',';
1909       zSql[j++] = '?';
1910     }
1911     zSql[j++] = ')';
1912     zSql[j] = 0;
1913     rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1914     free(zSql);
1915     if( rc ){
1916       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
1917       if (pStmt) sqlite3_finalize(pStmt);
1918       return 1;
1919     }
1920     in = fopen(zFile, "rb");
1921     if( in==0 ){
1922       fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
1923       sqlite3_finalize(pStmt);
1924       return 1;
1925     }
1926     azCol = malloc( sizeof(azCol[0])*(nCol+1) );
1927     if( azCol==0 ){
1928       fprintf(stderr, "Error: out of memory\n");
1929       fclose(in);
1930       sqlite3_finalize(pStmt);
1931       return 1;
1932     }
1933     sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
1934     zCommit = "COMMIT";
1935     while( (zLine = local_getline(0, in, 1))!=0 ){
1936       char *z, c;
1937       int inQuote = 0;
1938       lineno++;
1939       azCol[0] = zLine;
1940       for(i=0, z=zLine; (c = *z)!=0; z++){
1941         if( c=='"' ) inQuote = !inQuote;
1942         if( c=='\n' ) lineno++;
1943         if( !inQuote && c==p->separator[0] && strncmp(z,p->separator,nSep)==0 ){
1944           *z = 0;
1945           i++;
1946           if( i<nCol ){
1947             azCol[i] = &z[nSep];
1948             z += nSep-1;
1949           }
1950         }
1951       } /* end for */
1952       *z = 0;
1953       if( i+1!=nCol ){
1954         fprintf(stderr,
1955                 "Error: %s line %d: expected %d columns of data but found %d\n",
1956                 zFile, lineno, nCol, i+1);
1957         zCommit = "ROLLBACK";
1958         free(zLine);
1959         rc = 1;
1960         break; /* from while */
1961       }
1962       for(i=0; i<nCol; i++){
1963         if( azCol[i][0]=='"' ){
1964           int k;
1965           for(z=azCol[i], j=1, k=0; z[j]; j++){
1966             if( z[j]=='"' ){ j++; if( z[j]==0 ) break; }
1967             z[k++] = z[j];
1968           }
1969           z[k] = 0;
1970         }
1971         sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
1972       }
1973       sqlite3_step(pStmt);
1974       rc = sqlite3_reset(pStmt);
1975       free(zLine);
1976       if( rc!=SQLITE_OK ){
1977         fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1978         zCommit = "ROLLBACK";
1979         rc = 1;
1980         break; /* from while */
1981       }
1982     } /* end while */
1983     free(azCol);
1984     fclose(in);
1985     sqlite3_finalize(pStmt);
1986     sqlite3_exec(p->db, zCommit, 0, 0, 0);
1987   }else
1988 
1989   if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){
1990     struct callback_data data;
1991     char *zErrMsg = 0;
1992     open_db(p);
1993     memcpy(&data, p, sizeof(data));
1994     data.showHeader = 0;
1995     data.mode = MODE_List;
1996     if( nArg==1 ){
1997       rc = sqlite3_exec(p->db,
1998         "SELECT name FROM sqlite_master "
1999         "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
2000         "UNION ALL "
2001         "SELECT name FROM sqlite_temp_master "
2002         "WHERE type='index' "
2003         "ORDER BY 1",
2004         callback, &data, &zErrMsg
2005       );
2006     }else{
2007       zShellStatic = azArg[1];
2008       rc = sqlite3_exec(p->db,
2009         "SELECT name FROM sqlite_master "
2010         "WHERE type='index' AND tbl_name LIKE shellstatic() "
2011         "UNION ALL "
2012         "SELECT name FROM sqlite_temp_master "
2013         "WHERE type='index' AND tbl_name LIKE shellstatic() "
2014         "ORDER BY 1",
2015         callback, &data, &zErrMsg
2016       );
2017       zShellStatic = 0;
2018     }
2019     if( zErrMsg ){
2020       fprintf(stderr,"Error: %s\n", zErrMsg);
2021       sqlite3_free(zErrMsg);
2022       rc = 1;
2023     }else if( rc != SQLITE_OK ){
2024       fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
2025       rc = 1;
2026     }
2027   }else
2028 
2029 #ifdef SQLITE_ENABLE_IOTRACE
2030   if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
2031     extern void (*sqlite3IoTrace)(const char*, ...);
2032     if( iotrace && iotrace!=stdout ) fclose(iotrace);
2033     iotrace = 0;
2034     if( nArg<2 ){
2035       sqlite3IoTrace = 0;
2036     }else if( strcmp(azArg[1], "-")==0 ){
2037       sqlite3IoTrace = iotracePrintf;
2038       iotrace = stdout;
2039     }else{
2040       iotrace = fopen(azArg[1], "w");
2041       if( iotrace==0 ){
2042         fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
2043         sqlite3IoTrace = 0;
2044         rc = 1;
2045       }else{
2046         sqlite3IoTrace = iotracePrintf;
2047       }
2048     }
2049   }else
2050 #endif
2051 
2052 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2053   if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
2054     const char *zFile, *zProc;
2055     char *zErrMsg = 0;
2056     zFile = azArg[1];
2057     zProc = nArg>=3 ? azArg[2] : 0;
2058     open_db(p);
2059     rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
2060     if( rc!=SQLITE_OK ){
2061       fprintf(stderr, "Error: %s\n", zErrMsg);
2062       sqlite3_free(zErrMsg);
2063       rc = 1;
2064     }
2065   }else
2066 #endif
2067 
2068   if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=2 ){
2069     const char *zFile = azArg[1];
2070     output_file_close(p->pLog);
2071     p->pLog = output_file_open(zFile);
2072   }else
2073 
2074   if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){
2075     int n2 = strlen30(azArg[1]);
2076     if( (n2==4 && strncmp(azArg[1],"line",n2)==0)
2077         ||
2078         (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){
2079       p->mode = MODE_Line;
2080     }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0)
2081               ||
2082               (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){
2083       p->mode = MODE_Column;
2084     }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){
2085       p->mode = MODE_List;
2086     }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){
2087       p->mode = MODE_Html;
2088     }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){
2089       p->mode = MODE_Tcl;
2090       sqlite3_snprintf(sizeof(p->separator), p->separator, " ");
2091     }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){
2092       p->mode = MODE_Csv;
2093       sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
2094     }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){
2095       p->mode = MODE_List;
2096       sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
2097     }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2098       p->mode = MODE_Insert;
2099       set_table_name(p, "table");
2100     }else {
2101       fprintf(stderr,"Error: mode should be one of: "
2102          "column csv html insert line list tabs tcl\n");
2103       rc = 1;
2104     }
2105   }else
2106 
2107   if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){
2108     int n2 = strlen30(azArg[1]);
2109     if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){
2110       p->mode = MODE_Insert;
2111       set_table_name(p, azArg[2]);
2112     }else {
2113       fprintf(stderr, "Error: invalid arguments: "
2114         " \"%s\". Enter \".help\" for help\n", azArg[2]);
2115       rc = 1;
2116     }
2117   }else
2118 
2119   if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
2120     sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
2121                      "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
2122   }else
2123 
2124   if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
2125     if( p->outfile[0]=='|' ){
2126       pclose(p->out);
2127     }else{
2128       output_file_close(p->out);
2129     }
2130     p->outfile[0] = 0;
2131     if( azArg[1][0]=='|' ){
2132       p->out = popen(&azArg[1][1], "w");
2133       if( p->out==0 ){
2134         fprintf(stderr,"Error: cannot open pipe \"%s\"\n", &azArg[1][1]);
2135         p->out = stdout;
2136         rc = 1;
2137       }else{
2138         sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2139       }
2140     }else{
2141       p->out = output_file_open(azArg[1]);
2142       if( p->out==0 ){
2143         if( strcmp(azArg[1],"off")!=0 ){
2144           fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]);
2145         }
2146         p->out = stdout;
2147         rc = 1;
2148       } else {
2149         sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
2150       }
2151     }
2152   }else
2153 
2154   if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
2155     int i;
2156     for(i=1; i<nArg; i++){
2157       if( i>1 ) fprintf(p->out, " ");
2158       fprintf(p->out, "%s", azArg[i]);
2159     }
2160     fprintf(p->out, "\n");
2161   }else
2162 
2163   if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
2164     if( nArg >= 2) {
2165       strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
2166     }
2167     if( nArg >= 3) {
2168       strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
2169     }
2170   }else
2171 
2172   if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){
2173     rc = 2;
2174   }else
2175 
2176   if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
2177     FILE *alt = fopen(azArg[1], "rb");
2178     if( alt==0 ){
2179       fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
2180       rc = 1;
2181     }else{
2182       rc = process_input(p, alt);
2183       fclose(alt);
2184     }
2185   }else
2186 
2187   if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){
2188     const char *zSrcFile;
2189     const char *zDb;
2190     sqlite3 *pSrc;
2191     sqlite3_backup *pBackup;
2192     int nTimeout = 0;
2193 
2194     if( nArg==2 ){
2195       zSrcFile = azArg[1];
2196       zDb = "main";
2197     }else{
2198       zSrcFile = azArg[2];
2199       zDb = azArg[1];
2200     }
2201     rc = sqlite3_open(zSrcFile, &pSrc);
2202     if( rc!=SQLITE_OK ){
2203       fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
2204       sqlite3_close(pSrc);
2205       return 1;
2206     }
2207     open_db(p);
2208     pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
2209     if( pBackup==0 ){
2210       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2211       sqlite3_close(pSrc);
2212       return 1;
2213     }
2214     while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
2215           || rc==SQLITE_BUSY  ){
2216       if( rc==SQLITE_BUSY ){
2217         if( nTimeout++ >= 3 ) break;
2218         sqlite3_sleep(100);
2219       }
2220     }
2221     sqlite3_backup_finish(pBackup);
2222     if( rc==SQLITE_DONE ){
2223       rc = 0;
2224     }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
2225       fprintf(stderr, "Error: source database is busy\n");
2226       rc = 1;
2227     }else{
2228       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
2229       rc = 1;
2230     }
2231     sqlite3_close(pSrc);
2232   }else
2233 
2234   if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){
2235     struct callback_data data;
2236     char *zErrMsg = 0;
2237     open_db(p);
2238     memcpy(&data, p, sizeof(data));
2239     data.showHeader = 0;
2240     data.mode = MODE_Semi;
2241     if( nArg>1 ){
2242       int i;
2243       for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
2244       if( strcmp(azArg[1],"sqlite_master")==0 ){
2245         char *new_argv[2], *new_colv[2];
2246         new_argv[0] = "CREATE TABLE sqlite_master (\n"
2247                       "  type text,\n"
2248                       "  name text,\n"
2249                       "  tbl_name text,\n"
2250                       "  rootpage integer,\n"
2251                       "  sql text\n"
2252                       ")";
2253         new_argv[1] = 0;
2254         new_colv[0] = "sql";
2255         new_colv[1] = 0;
2256         callback(&data, 1, new_argv, new_colv);
2257         rc = SQLITE_OK;
2258       }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
2259         char *new_argv[2], *new_colv[2];
2260         new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
2261                       "  type text,\n"
2262                       "  name text,\n"
2263                       "  tbl_name text,\n"
2264                       "  rootpage integer,\n"
2265                       "  sql text\n"
2266                       ")";
2267         new_argv[1] = 0;
2268         new_colv[0] = "sql";
2269         new_colv[1] = 0;
2270         callback(&data, 1, new_argv, new_colv);
2271         rc = SQLITE_OK;
2272       }else{
2273         zShellStatic = azArg[1];
2274         rc = sqlite3_exec(p->db,
2275           "SELECT sql FROM "
2276           "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2277           "     FROM sqlite_master UNION ALL"
2278           "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2279           "WHERE lower(tbl_name) LIKE shellstatic()"
2280           "  AND type!='meta' AND sql NOTNULL "
2281           "ORDER BY rowid",
2282           callback, &data, &zErrMsg);
2283         zShellStatic = 0;
2284       }
2285     }else{
2286       rc = sqlite3_exec(p->db,
2287          "SELECT sql FROM "
2288          "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2289          "     FROM sqlite_master UNION ALL"
2290          "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2291          "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
2292          "ORDER BY rowid",
2293          callback, &data, &zErrMsg
2294       );
2295     }
2296     if( zErrMsg ){
2297       fprintf(stderr,"Error: %s\n", zErrMsg);
2298       sqlite3_free(zErrMsg);
2299       rc = 1;
2300     }else if( rc != SQLITE_OK ){
2301       fprintf(stderr,"Error: querying schema information\n");
2302       rc = 1;
2303     }else{
2304       rc = 0;
2305     }
2306   }else
2307 
2308   if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2309     sqlite3_snprintf(sizeof(p->separator), p->separator,
2310                      "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2311   }else
2312 
2313   if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){
2314     int i;
2315     fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
2316     fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
2317     fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
2318     fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
2319     fprintf(p->out,"%9.9s: ", "nullvalue");
2320       output_c_string(p->out, p->nullvalue);
2321       fprintf(p->out, "\n");
2322     fprintf(p->out,"%9.9s: %s\n","output",
2323             strlen30(p->outfile) ? p->outfile : "stdout");
2324     fprintf(p->out,"%9.9s: ", "separator");
2325       output_c_string(p->out, p->separator);
2326       fprintf(p->out, "\n");
2327     fprintf(p->out,"%9.9s: %s\n","stats", p->statsOn ? "on" : "off");
2328     fprintf(p->out,"%9.9s: ","width");
2329     for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
2330       fprintf(p->out,"%d ",p->colWidth[i]);
2331     }
2332     fprintf(p->out,"\n");
2333   }else
2334 
2335   if( c=='s' && strncmp(azArg[0], "stats", n)==0 && nArg>1 && nArg<3 ){
2336     p->statsOn = booleanValue(azArg[1]);
2337   }else
2338 
2339   if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){
2340     sqlite3_stmt *pStmt;
2341     char **azResult;
2342     int nRow, nAlloc;
2343     char *zSql = 0;
2344     int ii;
2345     open_db(p);
2346     rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
2347     if( rc ) return rc;
2348     zSql = sqlite3_mprintf(
2349         "SELECT name FROM sqlite_master"
2350         " WHERE type IN ('table','view')"
2351         "   AND name NOT LIKE 'sqlite_%%'"
2352         "   AND name LIKE ?1");
2353     while( sqlite3_step(pStmt)==SQLITE_ROW ){
2354       const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
2355       if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
2356       if( strcmp(zDbName,"temp")==0 ){
2357         zSql = sqlite3_mprintf(
2358                  "%z UNION ALL "
2359                  "SELECT 'temp.' || name FROM sqlite_temp_master"
2360                  " WHERE type IN ('table','view')"
2361                  "   AND name NOT LIKE 'sqlite_%%'"
2362                  "   AND name LIKE ?1", zSql);
2363       }else{
2364         zSql = sqlite3_mprintf(
2365                  "%z UNION ALL "
2366                  "SELECT '%q.' || name FROM \"%w\".sqlite_master"
2367                  " WHERE type IN ('table','view')"
2368                  "   AND name NOT LIKE 'sqlite_%%'"
2369                  "   AND name LIKE ?1", zSql, zDbName, zDbName);
2370       }
2371     }
2372     sqlite3_finalize(pStmt);
2373     zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
2374     rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2375     sqlite3_free(zSql);
2376     if( rc ) return rc;
2377     nRow = nAlloc = 0;
2378     azResult = 0;
2379     if( nArg>1 ){
2380       sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
2381     }else{
2382       sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
2383     }
2384     while( sqlite3_step(pStmt)==SQLITE_ROW ){
2385       if( nRow>=nAlloc ){
2386         char **azNew;
2387         int n = nAlloc*2 + 10;
2388         azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n);
2389         if( azNew==0 ){
2390           fprintf(stderr, "Error: out of memory\n");
2391           break;
2392         }
2393         nAlloc = n;
2394         azResult = azNew;
2395       }
2396       azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
2397       if( azResult[nRow] ) nRow++;
2398     }
2399     sqlite3_finalize(pStmt);
2400     if( nRow>0 ){
2401       int len, maxlen = 0;
2402       int i, j;
2403       int nPrintCol, nPrintRow;
2404       for(i=0; i<nRow; i++){
2405         len = strlen30(azResult[i]);
2406         if( len>maxlen ) maxlen = len;
2407       }
2408       nPrintCol = 80/(maxlen+2);
2409       if( nPrintCol<1 ) nPrintCol = 1;
2410       nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
2411       for(i=0; i<nPrintRow; i++){
2412         for(j=i; j<nRow; j+=nPrintRow){
2413           char *zSp = j<nPrintRow ? "" : "  ";
2414           fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
2415         }
2416         fprintf(p->out, "\n");
2417       }
2418     }
2419     for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
2420     sqlite3_free(azResult);
2421   }else
2422 
2423   if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
2424     static const struct {
2425        const char *zCtrlName;   /* Name of a test-control option */
2426        int ctrlCode;            /* Integer code for that option */
2427     } aCtrl[] = {
2428       { "prng_save",             SQLITE_TESTCTRL_PRNG_SAVE              },
2429       { "prng_restore",          SQLITE_TESTCTRL_PRNG_RESTORE           },
2430       { "prng_reset",            SQLITE_TESTCTRL_PRNG_RESET             },
2431       { "bitvec_test",           SQLITE_TESTCTRL_BITVEC_TEST            },
2432       { "fault_install",         SQLITE_TESTCTRL_FAULT_INSTALL          },
2433       { "benign_malloc_hooks",   SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS    },
2434       { "pending_byte",          SQLITE_TESTCTRL_PENDING_BYTE           },
2435       { "assert",                SQLITE_TESTCTRL_ASSERT                 },
2436       { "always",                SQLITE_TESTCTRL_ALWAYS                 },
2437       { "reserve",               SQLITE_TESTCTRL_RESERVE                },
2438       { "optimizations",         SQLITE_TESTCTRL_OPTIMIZATIONS          },
2439       { "iskeyword",             SQLITE_TESTCTRL_ISKEYWORD              },
2440       { "scratchmalloc",         SQLITE_TESTCTRL_SCRATCHMALLOC          },
2441     };
2442     int testctrl = -1;
2443     int rc = 0;
2444     int i, n;
2445     open_db(p);
2446 
2447     /* convert testctrl text option to value. allow any unique prefix
2448     ** of the option name, or a numerical value. */
2449     n = strlen30(azArg[1]);
2450     for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){
2451       if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){
2452         if( testctrl<0 ){
2453           testctrl = aCtrl[i].ctrlCode;
2454         }else{
2455           fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
2456           testctrl = -1;
2457           break;
2458         }
2459       }
2460     }
2461     if( testctrl<0 ) testctrl = atoi(azArg[1]);
2462     if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
2463       fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
2464     }else{
2465       switch(testctrl){
2466 
2467         /* sqlite3_test_control(int, db, int) */
2468         case SQLITE_TESTCTRL_OPTIMIZATIONS:
2469         case SQLITE_TESTCTRL_RESERVE:
2470           if( nArg==3 ){
2471             int opt = (int)strtol(azArg[2], 0, 0);
2472             rc = sqlite3_test_control(testctrl, p->db, opt);
2473             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2474           } else {
2475             fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2476                     azArg[1]);
2477           }
2478           break;
2479 
2480         /* sqlite3_test_control(int) */
2481         case SQLITE_TESTCTRL_PRNG_SAVE:
2482         case SQLITE_TESTCTRL_PRNG_RESTORE:
2483         case SQLITE_TESTCTRL_PRNG_RESET:
2484           if( nArg==2 ){
2485             rc = sqlite3_test_control(testctrl);
2486             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2487           } else {
2488             fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
2489           }
2490           break;
2491 
2492         /* sqlite3_test_control(int, uint) */
2493         case SQLITE_TESTCTRL_PENDING_BYTE:
2494           if( nArg==3 ){
2495             unsigned int opt = (unsigned int)integerValue(azArg[2]);
2496             rc = sqlite3_test_control(testctrl, opt);
2497             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2498           } else {
2499             fprintf(stderr,"Error: testctrl %s takes a single unsigned"
2500                            " int option\n", azArg[1]);
2501           }
2502           break;
2503 
2504         /* sqlite3_test_control(int, int) */
2505         case SQLITE_TESTCTRL_ASSERT:
2506         case SQLITE_TESTCTRL_ALWAYS:
2507           if( nArg==3 ){
2508             int opt = atoi(azArg[2]);
2509             rc = sqlite3_test_control(testctrl, opt);
2510             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2511           } else {
2512             fprintf(stderr,"Error: testctrl %s takes a single int option\n",
2513                             azArg[1]);
2514           }
2515           break;
2516 
2517         /* sqlite3_test_control(int, char *) */
2518 #ifdef SQLITE_N_KEYWORD
2519         case SQLITE_TESTCTRL_ISKEYWORD:
2520           if( nArg==3 ){
2521             const char *opt = azArg[2];
2522             rc = sqlite3_test_control(testctrl, opt);
2523             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
2524           } else {
2525             fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
2526                             azArg[1]);
2527           }
2528           break;
2529 #endif
2530 
2531         case SQLITE_TESTCTRL_BITVEC_TEST:
2532         case SQLITE_TESTCTRL_FAULT_INSTALL:
2533         case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
2534         case SQLITE_TESTCTRL_SCRATCHMALLOC:
2535         default:
2536           fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
2537                   azArg[1]);
2538           break;
2539       }
2540     }
2541   }else
2542 
2543   if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){
2544     open_db(p);
2545     sqlite3_busy_timeout(p->db, atoi(azArg[1]));
2546   }else
2547 
2548   if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0
2549    && nArg==2
2550   ){
2551     enableTimer = booleanValue(azArg[1]);
2552   }else
2553 
2554   if( c=='t' && strncmp(azArg[0], "trace", n)==0 && nArg>1 ){
2555     open_db(p);
2556     output_file_close(p->traceOut);
2557     p->traceOut = output_file_open(azArg[1]);
2558 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
2559     if( p->traceOut==0 ){
2560       sqlite3_trace(p->db, 0, 0);
2561     }else{
2562       sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
2563     }
2564 #endif
2565   }else
2566 
2567   if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
2568     fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
2569         sqlite3_libversion(), sqlite3_sourceid());
2570   }else
2571 
2572   if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
2573     const char *zDbName = nArg==2 ? azArg[1] : "main";
2574     char *zVfsName = 0;
2575     if( p->db ){
2576       sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
2577       if( zVfsName ){
2578         fprintf(p->out, "%s\n", zVfsName);
2579         sqlite3_free(zVfsName);
2580       }
2581     }
2582   }else
2583 
2584 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
2585   if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
2586     extern int sqlite3WhereTrace;
2587     sqlite3WhereTrace = booleanValue(azArg[1]);
2588   }else
2589 #endif
2590 
2591   if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){
2592     int j;
2593     assert( nArg<=ArraySize(azArg) );
2594     for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
2595       p->colWidth[j-1] = atoi(azArg[j]);
2596     }
2597   }else
2598 
2599   {
2600     fprintf(stderr, "Error: unknown command or invalid arguments: "
2601       " \"%s\". Enter \".help\" for help\n", azArg[0]);
2602     rc = 1;
2603   }
2604 
2605   return rc;
2606 }
2607 
2608 /*
2609 ** Return TRUE if a semicolon occurs anywhere in the first N characters
2610 ** of string z[].
2611 */
2612 static int _contains_semicolon(const char *z, int N){
2613   int i;
2614   for(i=0; i<N; i++){  if( z[i]==';' ) return 1; }
2615   return 0;
2616 }
2617 
2618 /*
2619 ** Test to see if a line consists entirely of whitespace.
2620 */
2621 static int _all_whitespace(const char *z){
2622   for(; *z; z++){
2623     if( IsSpace(z[0]) ) continue;
2624     if( *z=='/' && z[1]=='*' ){
2625       z += 2;
2626       while( *z && (*z!='*' || z[1]!='/') ){ z++; }
2627       if( *z==0 ) return 0;
2628       z++;
2629       continue;
2630     }
2631     if( *z=='-' && z[1]=='-' ){
2632       z += 2;
2633       while( *z && *z!='\n' ){ z++; }
2634       if( *z==0 ) return 1;
2635       continue;
2636     }
2637     return 0;
2638   }
2639   return 1;
2640 }
2641 
2642 /*
2643 ** Return TRUE if the line typed in is an SQL command terminator other
2644 ** than a semi-colon.  The SQL Server style "go" command is understood
2645 ** as is the Oracle "/".
2646 */
2647 static int _is_command_terminator(const char *zLine){
2648   while( IsSpace(zLine[0]) ){ zLine++; };
2649   if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
2650     return 1;  /* Oracle */
2651   }
2652   if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
2653          && _all_whitespace(&zLine[2]) ){
2654     return 1;  /* SQL Server */
2655   }
2656   return 0;
2657 }
2658 
2659 /*
2660 ** Return true if zSql is a complete SQL statement.  Return false if it
2661 ** ends in the middle of a string literal or C-style comment.
2662 */
2663 static int _is_complete(char *zSql, int nSql){
2664   int rc;
2665   if( zSql==0 ) return 1;
2666   zSql[nSql] = ';';
2667   zSql[nSql+1] = 0;
2668   rc = sqlite3_complete(zSql);
2669   zSql[nSql] = 0;
2670   return rc;
2671 }
2672 
2673 /*
2674 ** Read input from *in and process it.  If *in==0 then input
2675 ** is interactive - the user is typing it it.  Otherwise, input
2676 ** is coming from a file or device.  A prompt is issued and history
2677 ** is saved only if input is interactive.  An interrupt signal will
2678 ** cause this routine to exit immediately, unless input is interactive.
2679 **
2680 ** Return the number of errors.
2681 */
2682 static int process_input(struct callback_data *p, FILE *in){
2683   char *zLine = 0;
2684   char *zSql = 0;
2685   int nSql = 0;
2686   int nSqlPrior = 0;
2687   char *zErrMsg;
2688   int rc;
2689   int errCnt = 0;
2690   int lineno = 0;
2691   int startline = 0;
2692 
2693   while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
2694     fflush(p->out);
2695     free(zLine);
2696     zLine = one_input_line(zSql, in);
2697     if( zLine==0 ){
2698       /* End of input */
2699       if( stdin_is_interactive ) printf("\n");
2700       break;
2701     }
2702     if( seenInterrupt ){
2703       if( in!=0 ) break;
2704       seenInterrupt = 0;
2705     }
2706     lineno++;
2707     if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
2708     if( zLine && zLine[0]=='.' && nSql==0 ){
2709       if( p->echoOn ) printf("%s\n", zLine);
2710       rc = do_meta_command(zLine, p);
2711       if( rc==2 ){ /* exit requested */
2712         break;
2713       }else if( rc ){
2714         errCnt++;
2715       }
2716       continue;
2717     }
2718     if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){
2719       memcpy(zLine,";",2);
2720     }
2721     nSqlPrior = nSql;
2722     if( zSql==0 ){
2723       int i;
2724       for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
2725       if( zLine[i]!=0 ){
2726         nSql = strlen30(zLine);
2727         zSql = malloc( nSql+3 );
2728         if( zSql==0 ){
2729           fprintf(stderr, "Error: out of memory\n");
2730           exit(1);
2731         }
2732         memcpy(zSql, zLine, nSql+1);
2733         startline = lineno;
2734       }
2735     }else{
2736       int len = strlen30(zLine);
2737       zSql = realloc( zSql, nSql + len + 4 );
2738       if( zSql==0 ){
2739         fprintf(stderr,"Error: out of memory\n");
2740         exit(1);
2741       }
2742       zSql[nSql++] = '\n';
2743       memcpy(&zSql[nSql], zLine, len+1);
2744       nSql += len;
2745     }
2746     if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
2747                 && sqlite3_complete(zSql) ){
2748       p->cnt = 0;
2749       open_db(p);
2750       BEGIN_TIMER;
2751       rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
2752       END_TIMER;
2753       if( rc || zErrMsg ){
2754         char zPrefix[100];
2755         if( in!=0 || !stdin_is_interactive ){
2756           sqlite3_snprintf(sizeof(zPrefix), zPrefix,
2757                            "Error: near line %d:", startline);
2758         }else{
2759           sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
2760         }
2761         if( zErrMsg!=0 ){
2762           fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
2763           sqlite3_free(zErrMsg);
2764           zErrMsg = 0;
2765         }else{
2766           fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
2767         }
2768         errCnt++;
2769       }
2770       free(zSql);
2771       zSql = 0;
2772       nSql = 0;
2773     }else if( zSql && _all_whitespace(zSql) ){
2774       free(zSql);
2775       zSql = 0;
2776       nSql = 0;
2777     }
2778   }
2779   if( zSql ){
2780     if( !_all_whitespace(zSql) ){
2781       fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
2782     }
2783     free(zSql);
2784   }
2785   free(zLine);
2786   return errCnt>0;
2787 }
2788 
2789 /*
2790 ** Return a pathname which is the user's home directory.  A
2791 ** 0 return indicates an error of some kind.
2792 */
2793 static char *find_home_dir(void){
2794   static char *home_dir = NULL;
2795   if( home_dir ) return home_dir;
2796 
2797 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)
2798   {
2799     struct passwd *pwent;
2800     uid_t uid = getuid();
2801     if( (pwent=getpwuid(uid)) != NULL) {
2802       home_dir = pwent->pw_dir;
2803     }
2804   }
2805 #endif
2806 
2807 #if defined(_WIN32_WCE)
2808   /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
2809    */
2810   home_dir = "/";
2811 #else
2812 
2813 #if defined(_WIN32) || defined(WIN32)
2814   if (!home_dir) {
2815     home_dir = getenv("USERPROFILE");
2816   }
2817 #endif
2818 
2819   if (!home_dir) {
2820     home_dir = getenv("HOME");
2821   }
2822 
2823 #if defined(_WIN32) || defined(WIN32)
2824   if (!home_dir) {
2825     char *zDrive, *zPath;
2826     int n;
2827     zDrive = getenv("HOMEDRIVE");
2828     zPath = getenv("HOMEPATH");
2829     if( zDrive && zPath ){
2830       n = strlen30(zDrive) + strlen30(zPath) + 1;
2831       home_dir = malloc( n );
2832       if( home_dir==0 ) return 0;
2833       sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
2834       return home_dir;
2835     }
2836     home_dir = "c:\\";
2837   }
2838 #endif
2839 
2840 #endif /* !_WIN32_WCE */
2841 
2842   if( home_dir ){
2843     int n = strlen30(home_dir) + 1;
2844     char *z = malloc( n );
2845     if( z ) memcpy(z, home_dir, n);
2846     home_dir = z;
2847   }
2848 
2849   return home_dir;
2850 }
2851 
2852 /*
2853 ** Read input from the file given by sqliterc_override.  Or if that
2854 ** parameter is NULL, take input from ~/.sqliterc
2855 **
2856 ** Returns the number of errors.
2857 */
2858 static int process_sqliterc(
2859   struct callback_data *p,        /* Configuration data */
2860   const char *sqliterc_override   /* Name of config file. NULL to use default */
2861 ){
2862   char *home_dir = NULL;
2863   const char *sqliterc = sqliterc_override;
2864   char *zBuf = 0;
2865   FILE *in = NULL;
2866   int rc = 0;
2867 
2868   if (sqliterc == NULL) {
2869     home_dir = find_home_dir();
2870     if( home_dir==0 ){
2871 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
2872       fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
2873 #endif
2874       return 1;
2875     }
2876     sqlite3_initialize();
2877     zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
2878     sqliterc = zBuf;
2879   }
2880   in = fopen(sqliterc,"rb");
2881   if( in ){
2882     if( stdin_is_interactive ){
2883       fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
2884     }
2885     rc = process_input(p,in);
2886     fclose(in);
2887   }
2888   sqlite3_free(zBuf);
2889   return rc;
2890 }
2891 
2892 /*
2893 ** Show available command line options
2894 */
2895 static const char zOptions[] =
2896   "   -bail                stop after hitting an error\n"
2897   "   -batch               force batch I/O\n"
2898   "   -column              set output mode to 'column'\n"
2899   "   -cmd COMMAND         run \"COMMAND\" before reading stdin\n"
2900   "   -csv                 set output mode to 'csv'\n"
2901   "   -echo                print commands before execution\n"
2902   "   -init FILENAME       read/process named file\n"
2903   "   -[no]header          turn headers on or off\n"
2904 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
2905   "   -heap SIZE           Size of heap for memsys3 or memsys5\n"
2906 #endif
2907   "   -help                show this message\n"
2908   "   -html                set output mode to HTML\n"
2909   "   -interactive         force interactive I/O\n"
2910   "   -line                set output mode to 'line'\n"
2911   "   -list                set output mode to 'list'\n"
2912   "   -mmap N              default mmap size set to N\n"
2913 #ifdef SQLITE_ENABLE_MULTIPLEX
2914   "   -multiplex           enable the multiplexor VFS\n"
2915 #endif
2916   "   -nullvalue TEXT      set text string for NULL values. Default ''\n"
2917   "   -separator SEP       set output field separator. Default: '|'\n"
2918   "   -stats               print memory stats before each finalize\n"
2919   "   -version             show SQLite version\n"
2920   "   -vfs NAME            use NAME as the default VFS\n"
2921 #ifdef SQLITE_ENABLE_VFSTRACE
2922   "   -vfstrace            enable tracing of all VFS calls\n"
2923 #endif
2924 ;
2925 static void usage(int showDetail){
2926   fprintf(stderr,
2927       "Usage: %s [OPTIONS] FILENAME [SQL]\n"
2928       "FILENAME is the name of an SQLite database. A new database is created\n"
2929       "if the file does not previously exist.\n", Argv0);
2930   if( showDetail ){
2931     fprintf(stderr, "OPTIONS include:\n%s", zOptions);
2932   }else{
2933     fprintf(stderr, "Use the -help option for additional information\n");
2934   }
2935   exit(1);
2936 }
2937 
2938 /*
2939 ** Initialize the state information in data
2940 */
2941 static void main_init(struct callback_data *data) {
2942   memset(data, 0, sizeof(*data));
2943   data->mode = MODE_List;
2944   memcpy(data->separator,"|", 2);
2945   data->showHeader = 0;
2946   sqlite3_config(SQLITE_CONFIG_URI, 1);
2947   sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
2948   sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
2949   sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");
2950   sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
2951 }
2952 
2953 /*
2954 ** Get the argument to an --option.  Throw an error and die if no argument
2955 ** is available.
2956 */
2957 static char *cmdline_option_value(int argc, char **argv, int i){
2958   if( i==argc ){
2959     fprintf(stderr, "%s: Error: missing argument to %s\n",
2960             argv[0], argv[argc-1]);
2961     exit(1);
2962   }
2963   return argv[i];
2964 }
2965 
2966 int main(int argc, char **argv){
2967   char *zErrMsg = 0;
2968   struct callback_data data;
2969   const char *zInitFile = 0;
2970   char *zFirstCmd = 0;
2971   int i;
2972   int rc = 0;
2973 
2974   if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
2975     fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
2976             sqlite3_sourceid(), SQLITE_SOURCE_ID);
2977     exit(1);
2978   }
2979   Argv0 = argv[0];
2980   main_init(&data);
2981   stdin_is_interactive = isatty(0);
2982 
2983   /* Make sure we have a valid signal handler early, before anything
2984   ** else is done.
2985   */
2986 #ifdef SIGINT
2987   signal(SIGINT, interrupt_handler);
2988 #endif
2989 
2990   /* Do an initial pass through the command-line argument to locate
2991   ** the name of the database file, the name of the initialization file,
2992   ** the size of the alternative malloc heap,
2993   ** and the first command to execute.
2994   */
2995   for(i=1; i<argc; i++){
2996     char *z;
2997     z = argv[i];
2998     if( z[0]!='-' ){
2999       if( data.zDbFilename==0 ){
3000         data.zDbFilename = z;
3001         continue;
3002       }
3003       if( zFirstCmd==0 ){
3004         zFirstCmd = z;
3005         continue;
3006       }
3007       fprintf(stderr,"%s: Error: too many options: \"%s\"\n", Argv0, argv[i]);
3008       fprintf(stderr,"Use -help for a list of options.\n");
3009       return 1;
3010     }
3011     if( z[1]=='-' ) z++;
3012     if( strcmp(z,"-separator")==0
3013      || strcmp(z,"-nullvalue")==0
3014      || strcmp(z,"-cmd")==0
3015     ){
3016       (void)cmdline_option_value(argc, argv, ++i);
3017     }else if( strcmp(z,"-init")==0 ){
3018       zInitFile = cmdline_option_value(argc, argv, ++i);
3019     }else if( strcmp(z,"-batch")==0 ){
3020       /* Need to check for batch mode here to so we can avoid printing
3021       ** informational messages (like from process_sqliterc) before
3022       ** we do the actual processing of arguments later in a second pass.
3023       */
3024       stdin_is_interactive = 0;
3025     }else if( strcmp(z,"-heap")==0 ){
3026 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
3027       int j, c;
3028       const char *zSize;
3029       sqlite3_int64 szHeap;
3030 
3031       zSize = cmdline_option_value(argc, argv, ++i);
3032       szHeap = integerValue(zSize);
3033       if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
3034       sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
3035 #endif
3036 #ifdef SQLITE_ENABLE_VFSTRACE
3037     }else if( strcmp(z,"-vfstrace")==0 ){
3038       extern int vfstrace_register(
3039          const char *zTraceName,
3040          const char *zOldVfsName,
3041          int (*xOut)(const char*,void*),
3042          void *pOutArg,
3043          int makeDefault
3044       );
3045       vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
3046 #endif
3047 #ifdef SQLITE_ENABLE_MULTIPLEX
3048     }else if( strcmp(z,"-multiplex")==0 ){
3049       extern int sqlite3_multiple_initialize(const char*,int);
3050       sqlite3_multiplex_initialize(0, 1);
3051 #endif
3052     }else if( strcmp(z,"-mmap")==0 ){
3053       sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
3054       sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
3055     }else if( strcmp(z,"-vfs")==0 ){
3056       sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
3057       if( pVfs ){
3058         sqlite3_vfs_register(pVfs, 1);
3059       }else{
3060         fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
3061         exit(1);
3062       }
3063     }
3064   }
3065   if( data.zDbFilename==0 ){
3066 #ifndef SQLITE_OMIT_MEMORYDB
3067     data.zDbFilename = ":memory:";
3068 #else
3069     fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
3070     return 1;
3071 #endif
3072   }
3073   data.out = stdout;
3074 
3075   /* Go ahead and open the database file if it already exists.  If the
3076   ** file does not exist, delay opening it.  This prevents empty database
3077   ** files from being created if a user mistypes the database name argument
3078   ** to the sqlite command-line tool.
3079   */
3080   if( access(data.zDbFilename, 0)==0 ){
3081     open_db(&data);
3082   }
3083 
3084   /* Process the initialization file if there is one.  If no -init option
3085   ** is given on the command line, look for a file named ~/.sqliterc and
3086   ** try to process it.
3087   */
3088   rc = process_sqliterc(&data,zInitFile);
3089   if( rc>0 ){
3090     return rc;
3091   }
3092 
3093   /* Make a second pass through the command-line argument and set
3094   ** options.  This second pass is delayed until after the initialization
3095   ** file is processed so that the command-line arguments will override
3096   ** settings in the initialization file.
3097   */
3098   for(i=1; i<argc; i++){
3099     char *z = argv[i];
3100     if( z[0]!='-' ) continue;
3101     if( z[1]=='-' ){ z++; }
3102     if( strcmp(z,"-init")==0 ){
3103       i++;
3104     }else if( strcmp(z,"-html")==0 ){
3105       data.mode = MODE_Html;
3106     }else if( strcmp(z,"-list")==0 ){
3107       data.mode = MODE_List;
3108     }else if( strcmp(z,"-line")==0 ){
3109       data.mode = MODE_Line;
3110     }else if( strcmp(z,"-column")==0 ){
3111       data.mode = MODE_Column;
3112     }else if( strcmp(z,"-csv")==0 ){
3113       data.mode = MODE_Csv;
3114       memcpy(data.separator,",",2);
3115     }else if( strcmp(z,"-separator")==0 ){
3116       sqlite3_snprintf(sizeof(data.separator), data.separator,
3117                        "%s",cmdline_option_value(argc,argv,++i));
3118     }else if( strcmp(z,"-nullvalue")==0 ){
3119       sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
3120                        "%s",cmdline_option_value(argc,argv,++i));
3121     }else if( strcmp(z,"-header")==0 ){
3122       data.showHeader = 1;
3123     }else if( strcmp(z,"-noheader")==0 ){
3124       data.showHeader = 0;
3125     }else if( strcmp(z,"-echo")==0 ){
3126       data.echoOn = 1;
3127     }else if( strcmp(z,"-stats")==0 ){
3128       data.statsOn = 1;
3129     }else if( strcmp(z,"-bail")==0 ){
3130       bail_on_error = 1;
3131     }else if( strcmp(z,"-version")==0 ){
3132       printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
3133       return 0;
3134     }else if( strcmp(z,"-interactive")==0 ){
3135       stdin_is_interactive = 1;
3136     }else if( strcmp(z,"-batch")==0 ){
3137       stdin_is_interactive = 0;
3138     }else if( strcmp(z,"-heap")==0 ){
3139       i++;
3140     }else if( strcmp(z,"-mmap")==0 ){
3141       i++;
3142     }else if( strcmp(z,"-vfs")==0 ){
3143       i++;
3144 #ifdef SQLITE_ENABLE_VFSTRACE
3145     }else if( strcmp(z,"-vfstrace")==0 ){
3146       i++;
3147 #endif
3148 #ifdef SQLITE_ENABLE_MULTIPLEX
3149     }else if( strcmp(z,"-multiplex")==0 ){
3150       i++;
3151 #endif
3152     }else if( strcmp(z,"-help")==0 ){
3153       usage(1);
3154     }else if( strcmp(z,"-cmd")==0 ){
3155       if( i==argc-1 ) break;
3156       z = cmdline_option_value(argc,argv,++i);
3157       if( z[0]=='.' ){
3158         rc = do_meta_command(z, &data);
3159         if( rc && bail_on_error ) return rc==2 ? 0 : rc;
3160       }else{
3161         open_db(&data);
3162         rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
3163         if( zErrMsg!=0 ){
3164           fprintf(stderr,"Error: %s\n", zErrMsg);
3165           if( bail_on_error ) return rc!=0 ? rc : 1;
3166         }else if( rc!=0 ){
3167           fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
3168           if( bail_on_error ) return rc;
3169         }
3170       }
3171     }else{
3172       fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
3173       fprintf(stderr,"Use -help for a list of options.\n");
3174       return 1;
3175     }
3176   }
3177 
3178   if( zFirstCmd ){
3179     /* Run just the command that follows the database name
3180     */
3181     if( zFirstCmd[0]=='.' ){
3182       rc = do_meta_command(zFirstCmd, &data);
3183       if( rc==2 ) rc = 0;
3184     }else{
3185       open_db(&data);
3186       rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
3187       if( zErrMsg!=0 ){
3188         fprintf(stderr,"Error: %s\n", zErrMsg);
3189         return rc!=0 ? rc : 1;
3190       }else if( rc!=0 ){
3191         fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd);
3192         return rc;
3193       }
3194     }
3195   }else{
3196     /* Run commands received from standard input
3197     */
3198     if( stdin_is_interactive ){
3199       char *zHome;
3200       char *zHistory = 0;
3201       int nHistory;
3202       printf(
3203         "SQLite version %s %.19s\n" /*extra-version-info*/
3204         "Enter \".help\" for instructions\n"
3205         "Enter SQL statements terminated with a \";\"\n",
3206         sqlite3_libversion(), sqlite3_sourceid()
3207       );
3208       zHome = find_home_dir();
3209       if( zHome ){
3210         nHistory = strlen30(zHome) + 20;
3211         if( (zHistory = malloc(nHistory))!=0 ){
3212           sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
3213         }
3214       }
3215 #if defined(HAVE_READLINE) && HAVE_READLINE==1
3216       if( zHistory ) read_history(zHistory);
3217 #endif
3218       rc = process_input(&data, 0);
3219       if( zHistory ){
3220         stifle_history(100);
3221         write_history(zHistory);
3222         free(zHistory);
3223       }
3224     }else{
3225       rc = process_input(&data, stdin);
3226     }
3227   }
3228   set_table_name(&data, 0);
3229   if( data.db ){
3230     sqlite3_close(data.db);
3231   }
3232   return rc;
3233 }
3234