xref: /freebsd/contrib/sqlite3/shell.c (revision 3e5645b78f476816ca3b5acc28b29bbafbb9c444)
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 ** If requested, include the SQLite compiler options file for MSVC.
22 */
23 #if defined(INCLUDE_MSVC_H)
24 #include "msvc.h"
25 #endif
26 
27 /*
28 ** No support for loadable extensions in VxWorks.
29 */
30 #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
31 # define SQLITE_OMIT_LOAD_EXTENSION 1
32 #endif
33 
34 /*
35 ** Enable large-file support for fopen() and friends on unix.
36 */
37 #ifndef SQLITE_DISABLE_LFS
38 # define _LARGE_FILE       1
39 # ifndef _FILE_OFFSET_BITS
40 #   define _FILE_OFFSET_BITS 64
41 # endif
42 # define _LARGEFILE_SOURCE 1
43 #endif
44 
45 #include <stdlib.h>
46 #include <string.h>
47 #include <stdio.h>
48 #include <assert.h>
49 #include "sqlite3.h"
50 #if SQLITE_USER_AUTHENTICATION
51 # include "sqlite3userauth.h"
52 #endif
53 #include <ctype.h>
54 #include <stdarg.h>
55 
56 #if !defined(_WIN32) && !defined(WIN32)
57 # include <signal.h>
58 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
59 #  include <pwd.h>
60 # endif
61 # include <unistd.h>
62 # include <sys/types.h>
63 #endif
64 
65 #if HAVE_READLINE
66 # include <readline/readline.h>
67 # include <readline/history.h>
68 #endif
69 
70 #if HAVE_EDITLINE
71 # include <editline/readline.h>
72 #endif
73 
74 #if HAVE_EDITLINE || HAVE_READLINE
75 
76 # define shell_add_history(X) add_history(X)
77 # define shell_read_history(X) read_history(X)
78 # define shell_write_history(X) write_history(X)
79 # define shell_stifle_history(X) stifle_history(X)
80 # define shell_readline(X) readline(X)
81 
82 #elif HAVE_LINENOISE
83 
84 # include "linenoise.h"
85 # define shell_add_history(X) linenoiseHistoryAdd(X)
86 # define shell_read_history(X) linenoiseHistoryLoad(X)
87 # define shell_write_history(X) linenoiseHistorySave(X)
88 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
89 # define shell_readline(X) linenoise(X)
90 
91 #else
92 
93 # define shell_read_history(X)
94 # define shell_write_history(X)
95 # define shell_stifle_history(X)
96 
97 # define SHELL_USE_LOCAL_GETLINE 1
98 #endif
99 
100 
101 #if defined(_WIN32) || defined(WIN32)
102 # include <io.h>
103 # include <fcntl.h>
104 #define isatty(h) _isatty(h)
105 #ifndef access
106 # define access(f,m) _access((f),(m))
107 #endif
108 #undef popen
109 #define popen _popen
110 #undef pclose
111 #define pclose _pclose
112 #else
113 /* Make sure isatty() has a prototype.
114 */
115 extern int isatty(int);
116 
117 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
118   /* popen and pclose are not C89 functions and so are sometimes omitted from
119   ** the <stdio.h> header */
120   extern FILE *popen(const char*,const char*);
121   extern int pclose(FILE*);
122 #else
123 # define SQLITE_OMIT_POPEN 1
124 #endif
125 
126 #endif
127 
128 #if defined(_WIN32_WCE)
129 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
130  * thus we always assume that we have a console. That can be
131  * overridden with the -batch command line option.
132  */
133 #define isatty(x) 1
134 #endif
135 
136 /* ctype macros that work with signed characters */
137 #define IsSpace(X)  isspace((unsigned char)X)
138 #define IsDigit(X)  isdigit((unsigned char)X)
139 #define ToLower(X)  (char)tolower((unsigned char)X)
140 
141 /* On Windows, we normally run with output mode of TEXT so that \n characters
142 ** are automatically translated into \r\n.  However, this behavior needs
143 ** to be disabled in some cases (ex: when generating CSV output and when
144 ** rendering quoted strings that contain \n characters).  The following
145 ** routines take care of that.
146 */
147 #if defined(_WIN32) || defined(WIN32)
148 static void setBinaryMode(FILE *out){
149   fflush(out);
150   _setmode(_fileno(out), _O_BINARY);
151 }
152 static void setTextMode(FILE *out){
153   fflush(out);
154   _setmode(_fileno(out), _O_TEXT);
155 }
156 #else
157 # define setBinaryMode(X)
158 # define setTextMode(X)
159 #endif
160 
161 
162 /* True if the timer is enabled */
163 static int enableTimer = 0;
164 
165 /* Return the current wall-clock time */
166 static sqlite3_int64 timeOfDay(void){
167   static sqlite3_vfs *clockVfs = 0;
168   sqlite3_int64 t;
169   if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
170   if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
171     clockVfs->xCurrentTimeInt64(clockVfs, &t);
172   }else{
173     double r;
174     clockVfs->xCurrentTime(clockVfs, &r);
175     t = (sqlite3_int64)(r*86400000.0);
176   }
177   return t;
178 }
179 
180 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
181 #include <sys/time.h>
182 #include <sys/resource.h>
183 
184 /* VxWorks does not support getrusage() as far as we can determine */
185 #if defined(_WRS_KERNEL) || defined(__RTP__)
186 struct rusage {
187   struct timeval ru_utime; /* user CPU time used */
188   struct timeval ru_stime; /* system CPU time used */
189 };
190 #define getrusage(A,B) memset(B,0,sizeof(*B))
191 #endif
192 
193 /* Saved resource information for the beginning of an operation */
194 static struct rusage sBegin;  /* CPU time at start */
195 static sqlite3_int64 iBegin;  /* Wall-clock time at start */
196 
197 /*
198 ** Begin timing an operation
199 */
200 static void beginTimer(void){
201   if( enableTimer ){
202     getrusage(RUSAGE_SELF, &sBegin);
203     iBegin = timeOfDay();
204   }
205 }
206 
207 /* Return the difference of two time_structs in seconds */
208 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
209   return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
210          (double)(pEnd->tv_sec - pStart->tv_sec);
211 }
212 
213 /*
214 ** Print the timing results.
215 */
216 static void endTimer(void){
217   if( enableTimer ){
218     sqlite3_int64 iEnd = timeOfDay();
219     struct rusage sEnd;
220     getrusage(RUSAGE_SELF, &sEnd);
221     printf("Run Time: real %.3f user %f sys %f\n",
222        (iEnd - iBegin)*0.001,
223        timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
224        timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
225   }
226 }
227 
228 #define BEGIN_TIMER beginTimer()
229 #define END_TIMER endTimer()
230 #define HAS_TIMER 1
231 
232 #elif (defined(_WIN32) || defined(WIN32))
233 
234 #include <windows.h>
235 
236 /* Saved resource information for the beginning of an operation */
237 static HANDLE hProcess;
238 static FILETIME ftKernelBegin;
239 static FILETIME ftUserBegin;
240 static sqlite3_int64 ftWallBegin;
241 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
242                                     LPFILETIME, LPFILETIME);
243 static GETPROCTIMES getProcessTimesAddr = NULL;
244 
245 /*
246 ** Check to see if we have timer support.  Return 1 if necessary
247 ** support found (or found previously).
248 */
249 static int hasTimer(void){
250   if( getProcessTimesAddr ){
251     return 1;
252   } else {
253     /* GetProcessTimes() isn't supported in WIN95 and some other Windows
254     ** versions. See if the version we are running on has it, and if it
255     ** does, save off a pointer to it and the current process handle.
256     */
257     hProcess = GetCurrentProcess();
258     if( hProcess ){
259       HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
260       if( NULL != hinstLib ){
261         getProcessTimesAddr =
262             (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
263         if( NULL != getProcessTimesAddr ){
264           return 1;
265         }
266         FreeLibrary(hinstLib);
267       }
268     }
269   }
270   return 0;
271 }
272 
273 /*
274 ** Begin timing an operation
275 */
276 static void beginTimer(void){
277   if( enableTimer && getProcessTimesAddr ){
278     FILETIME ftCreation, ftExit;
279     getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
280                         &ftKernelBegin,&ftUserBegin);
281     ftWallBegin = timeOfDay();
282   }
283 }
284 
285 /* Return the difference of two FILETIME structs in seconds */
286 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
287   sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
288   sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
289   return (double) ((i64End - i64Start) / 10000000.0);
290 }
291 
292 /*
293 ** Print the timing results.
294 */
295 static void endTimer(void){
296   if( enableTimer && getProcessTimesAddr){
297     FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
298     sqlite3_int64 ftWallEnd = timeOfDay();
299     getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
300     printf("Run Time: real %.3f user %f sys %f\n",
301        (ftWallEnd - ftWallBegin)*0.001,
302        timeDiff(&ftUserBegin, &ftUserEnd),
303        timeDiff(&ftKernelBegin, &ftKernelEnd));
304   }
305 }
306 
307 #define BEGIN_TIMER beginTimer()
308 #define END_TIMER endTimer()
309 #define HAS_TIMER hasTimer()
310 
311 #else
312 #define BEGIN_TIMER
313 #define END_TIMER
314 #define HAS_TIMER 0
315 #endif
316 
317 /*
318 ** Used to prevent warnings about unused parameters
319 */
320 #define UNUSED_PARAMETER(x) (void)(x)
321 
322 /*
323 ** If the following flag is set, then command execution stops
324 ** at an error if we are not interactive.
325 */
326 static int bail_on_error = 0;
327 
328 /*
329 ** Threat stdin as an interactive input if the following variable
330 ** is true.  Otherwise, assume stdin is connected to a file or pipe.
331 */
332 static int stdin_is_interactive = 1;
333 
334 /*
335 ** The following is the open SQLite database.  We make a pointer
336 ** to this database a static variable so that it can be accessed
337 ** by the SIGINT handler to interrupt database processing.
338 */
339 static sqlite3 *db = 0;
340 
341 /*
342 ** True if an interrupt (Control-C) has been received.
343 */
344 static volatile int seenInterrupt = 0;
345 
346 /*
347 ** This is the name of our program. It is set in main(), used
348 ** in a number of other places, mostly for error messages.
349 */
350 static char *Argv0;
351 
352 /*
353 ** Prompt strings. Initialized in main. Settable with
354 **   .prompt main continue
355 */
356 static char mainPrompt[20];     /* First line prompt. default: "sqlite> "*/
357 static char continuePrompt[20]; /* Continuation prompt. default: "   ...> " */
358 
359 /*
360 ** Write I/O traces to the following stream.
361 */
362 #ifdef SQLITE_ENABLE_IOTRACE
363 static FILE *iotrace = 0;
364 #endif
365 
366 /*
367 ** This routine works like printf in that its first argument is a
368 ** format string and subsequent arguments are values to be substituted
369 ** in place of % fields.  The result of formatting this string
370 ** is written to iotrace.
371 */
372 #ifdef SQLITE_ENABLE_IOTRACE
373 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
374   va_list ap;
375   char *z;
376   if( iotrace==0 ) return;
377   va_start(ap, zFormat);
378   z = sqlite3_vmprintf(zFormat, ap);
379   va_end(ap);
380   fprintf(iotrace, "%s", z);
381   sqlite3_free(z);
382 }
383 #endif
384 
385 
386 /*
387 ** Determines if a string is a number of not.
388 */
389 static int isNumber(const char *z, int *realnum){
390   if( *z=='-' || *z=='+' ) z++;
391   if( !IsDigit(*z) ){
392     return 0;
393   }
394   z++;
395   if( realnum ) *realnum = 0;
396   while( IsDigit(*z) ){ z++; }
397   if( *z=='.' ){
398     z++;
399     if( !IsDigit(*z) ) return 0;
400     while( IsDigit(*z) ){ z++; }
401     if( realnum ) *realnum = 1;
402   }
403   if( *z=='e' || *z=='E' ){
404     z++;
405     if( *z=='+' || *z=='-' ) z++;
406     if( !IsDigit(*z) ) return 0;
407     while( IsDigit(*z) ){ z++; }
408     if( realnum ) *realnum = 1;
409   }
410   return *z==0;
411 }
412 
413 /*
414 ** A global char* and an SQL function to access its current value
415 ** from within an SQL statement. This program used to use the
416 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
417 ** The correct way to do this with sqlite3 is to use the bind API, but
418 ** since the shell is built around the callback paradigm it would be a lot
419 ** of work. Instead just use this hack, which is quite harmless.
420 */
421 static const char *zShellStatic = 0;
422 static void shellstaticFunc(
423   sqlite3_context *context,
424   int argc,
425   sqlite3_value **argv
426 ){
427   assert( 0==argc );
428   assert( zShellStatic );
429   UNUSED_PARAMETER(argc);
430   UNUSED_PARAMETER(argv);
431   sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
432 }
433 
434 
435 /*
436 ** This routine reads a line of text from FILE in, stores
437 ** the text in memory obtained from malloc() and returns a pointer
438 ** to the text.  NULL is returned at end of file, or if malloc()
439 ** fails.
440 **
441 ** If zLine is not NULL then it is a malloced buffer returned from
442 ** a previous call to this routine that may be reused.
443 */
444 static char *local_getline(char *zLine, FILE *in){
445   int nLine = zLine==0 ? 0 : 100;
446   int n = 0;
447 
448   while( 1 ){
449     if( n+100>nLine ){
450       nLine = nLine*2 + 100;
451       zLine = realloc(zLine, nLine);
452       if( zLine==0 ) return 0;
453     }
454     if( fgets(&zLine[n], nLine - n, in)==0 ){
455       if( n==0 ){
456         free(zLine);
457         return 0;
458       }
459       zLine[n] = 0;
460       break;
461     }
462     while( zLine[n] ) n++;
463     if( n>0 && zLine[n-1]=='\n' ){
464       n--;
465       if( n>0 && zLine[n-1]=='\r' ) n--;
466       zLine[n] = 0;
467       break;
468     }
469   }
470   return zLine;
471 }
472 
473 /*
474 ** Retrieve a single line of input text.
475 **
476 ** If in==0 then read from standard input and prompt before each line.
477 ** If isContinuation is true, then a continuation prompt is appropriate.
478 ** If isContinuation is zero, then the main prompt should be used.
479 **
480 ** If zPrior is not NULL then it is a buffer from a prior call to this
481 ** routine that can be reused.
482 **
483 ** The result is stored in space obtained from malloc() and must either
484 ** be freed by the caller or else passed back into this routine via the
485 ** zPrior argument for reuse.
486 */
487 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
488   char *zPrompt;
489   char *zResult;
490   if( in!=0 ){
491     zResult = local_getline(zPrior, in);
492   }else{
493     zPrompt = isContinuation ? continuePrompt : mainPrompt;
494 #if SHELL_USE_LOCAL_GETLINE
495     printf("%s", zPrompt);
496     fflush(stdout);
497     zResult = local_getline(zPrior, stdin);
498 #else
499     free(zPrior);
500     zResult = shell_readline(zPrompt);
501     if( zResult && *zResult ) shell_add_history(zResult);
502 #endif
503   }
504   return zResult;
505 }
506 
507 /*
508 ** Shell output mode information from before ".explain on",
509 ** saved so that it can be restored by ".explain off"
510 */
511 typedef struct SavedModeInfo SavedModeInfo;
512 struct SavedModeInfo {
513   int valid;          /* Is there legit data in here? */
514   int mode;           /* Mode prior to ".explain on" */
515   int showHeader;     /* The ".header" setting prior to ".explain on" */
516   int colWidth[100];  /* Column widths prior to ".explain on" */
517 };
518 
519 /*
520 ** State information about the database connection is contained in an
521 ** instance of the following structure.
522 */
523 typedef struct ShellState ShellState;
524 struct ShellState {
525   sqlite3 *db;           /* The database */
526   int echoOn;            /* True to echo input commands */
527   int autoEQP;           /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
528   int statsOn;           /* True to display memory stats before each finalize */
529   int scanstatsOn;       /* True to display scan stats before each finalize */
530   int outCount;          /* Revert to stdout when reaching zero */
531   int cnt;               /* Number of records displayed so far */
532   FILE *out;             /* Write results here */
533   FILE *traceOut;        /* Output for sqlite3_trace() */
534   int nErr;              /* Number of errors seen */
535   int mode;              /* An output mode setting */
536   int writableSchema;    /* True if PRAGMA writable_schema=ON */
537   int showHeader;        /* True to show column names in List or Column mode */
538   unsigned shellFlgs;    /* Various flags */
539   char *zDestTable;      /* Name of destination table when MODE_Insert */
540   char colSeparator[20]; /* Column separator character for several modes */
541   char rowSeparator[20]; /* Row separator character for MODE_Ascii */
542   int colWidth[100];     /* Requested width of each column when in column mode*/
543   int actualWidth[100];  /* Actual width of each column */
544   char nullValue[20];    /* The text to print when a NULL comes back from
545                          ** the database */
546   SavedModeInfo normalMode;/* Holds the mode just before .explain ON */
547   char outfile[FILENAME_MAX]; /* Filename for *out */
548   const char *zDbFilename;    /* name of the database file */
549   char *zFreeOnClose;         /* Filename to free when closing */
550   const char *zVfs;           /* Name of VFS to use */
551   sqlite3_stmt *pStmt;   /* Current statement if any. */
552   FILE *pLog;            /* Write log output here */
553   int *aiIndent;         /* Array of indents used in MODE_Explain */
554   int nIndent;           /* Size of array aiIndent[] */
555   int iIndent;           /* Index of current op in aiIndent[] */
556 };
557 
558 /*
559 ** These are the allowed shellFlgs values
560 */
561 #define SHFLG_Scratch     0x00001     /* The --scratch option is used */
562 #define SHFLG_Pagecache   0x00002     /* The --pagecache option is used */
563 #define SHFLG_Lookaside   0x00004     /* Lookaside memory is used */
564 
565 /*
566 ** These are the allowed modes.
567 */
568 #define MODE_Line     0  /* One column per line.  Blank line between records */
569 #define MODE_Column   1  /* One record per line in neat columns */
570 #define MODE_List     2  /* One record per line with a separator */
571 #define MODE_Semi     3  /* Same as MODE_List but append ";" to each line */
572 #define MODE_Html     4  /* Generate an XHTML table */
573 #define MODE_Insert   5  /* Generate SQL "insert" statements */
574 #define MODE_Tcl      6  /* Generate ANSI-C or TCL quoted elements */
575 #define MODE_Csv      7  /* Quote strings, numbers are plain */
576 #define MODE_Explain  8  /* Like MODE_Column, but do not truncate data */
577 #define MODE_Ascii    9  /* Use ASCII unit and record separators (0x1F/0x1E) */
578 
579 static const char *modeDescr[] = {
580   "line",
581   "column",
582   "list",
583   "semi",
584   "html",
585   "insert",
586   "tcl",
587   "csv",
588   "explain",
589   "ascii",
590 };
591 
592 /*
593 ** These are the column/row/line separators used by the various
594 ** import/export modes.
595 */
596 #define SEP_Column    "|"
597 #define SEP_Row       "\n"
598 #define SEP_Tab       "\t"
599 #define SEP_Space     " "
600 #define SEP_Comma     ","
601 #define SEP_CrLf      "\r\n"
602 #define SEP_Unit      "\x1F"
603 #define SEP_Record    "\x1E"
604 
605 /*
606 ** Number of elements in an array
607 */
608 #define ArraySize(X)  (int)(sizeof(X)/sizeof(X[0]))
609 
610 /*
611 ** Compute a string length that is limited to what can be stored in
612 ** lower 30 bits of a 32-bit signed integer.
613 */
614 static int strlen30(const char *z){
615   const char *z2 = z;
616   while( *z2 ){ z2++; }
617   return 0x3fffffff & (int)(z2 - z);
618 }
619 
620 /*
621 ** A callback for the sqlite3_log() interface.
622 */
623 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
624   ShellState *p = (ShellState*)pArg;
625   if( p->pLog==0 ) return;
626   fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
627   fflush(p->pLog);
628 }
629 
630 /*
631 ** Output the given string as a hex-encoded blob (eg. X'1234' )
632 */
633 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
634   int i;
635   char *zBlob = (char *)pBlob;
636   fprintf(out,"X'");
637   for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
638   fprintf(out,"'");
639 }
640 
641 /*
642 ** Output the given string as a quoted string using SQL quoting conventions.
643 */
644 static void output_quoted_string(FILE *out, const char *z){
645   int i;
646   int nSingle = 0;
647   setBinaryMode(out);
648   for(i=0; z[i]; i++){
649     if( z[i]=='\'' ) nSingle++;
650   }
651   if( nSingle==0 ){
652     fprintf(out,"'%s'",z);
653   }else{
654     fprintf(out,"'");
655     while( *z ){
656       for(i=0; z[i] && z[i]!='\''; i++){}
657       if( i==0 ){
658         fprintf(out,"''");
659         z++;
660       }else if( z[i]=='\'' ){
661         fprintf(out,"%.*s''",i,z);
662         z += i+1;
663       }else{
664         fprintf(out,"%s",z);
665         break;
666       }
667     }
668     fprintf(out,"'");
669   }
670   setTextMode(out);
671 }
672 
673 /*
674 ** Output the given string as a quoted according to C or TCL quoting rules.
675 */
676 static void output_c_string(FILE *out, const char *z){
677   unsigned int c;
678   fputc('"', out);
679   while( (c = *(z++))!=0 ){
680     if( c=='\\' ){
681       fputc(c, out);
682       fputc(c, out);
683     }else if( c=='"' ){
684       fputc('\\', out);
685       fputc('"', out);
686     }else if( c=='\t' ){
687       fputc('\\', out);
688       fputc('t', out);
689     }else if( c=='\n' ){
690       fputc('\\', out);
691       fputc('n', out);
692     }else if( c=='\r' ){
693       fputc('\\', out);
694       fputc('r', out);
695     }else if( !isprint(c&0xff) ){
696       fprintf(out, "\\%03o", c&0xff);
697     }else{
698       fputc(c, out);
699     }
700   }
701   fputc('"', out);
702 }
703 
704 /*
705 ** Output the given string with characters that are special to
706 ** HTML escaped.
707 */
708 static void output_html_string(FILE *out, const char *z){
709   int i;
710   if( z==0 ) z = "";
711   while( *z ){
712     for(i=0;   z[i]
713             && z[i]!='<'
714             && z[i]!='&'
715             && z[i]!='>'
716             && z[i]!='\"'
717             && z[i]!='\'';
718         i++){}
719     if( i>0 ){
720       fprintf(out,"%.*s",i,z);
721     }
722     if( z[i]=='<' ){
723       fprintf(out,"&lt;");
724     }else if( z[i]=='&' ){
725       fprintf(out,"&amp;");
726     }else if( z[i]=='>' ){
727       fprintf(out,"&gt;");
728     }else if( z[i]=='\"' ){
729       fprintf(out,"&quot;");
730     }else if( z[i]=='\'' ){
731       fprintf(out,"&#39;");
732     }else{
733       break;
734     }
735     z += i + 1;
736   }
737 }
738 
739 /*
740 ** If a field contains any character identified by a 1 in the following
741 ** array, then the string must be quoted for CSV.
742 */
743 static const char needCsvQuote[] = {
744   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
745   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
746   1, 0, 1, 0, 0, 0, 0, 1,   0, 0, 0, 0, 0, 0, 0, 0,
747   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
748   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
749   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
750   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
751   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 1,
752   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
753   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
754   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
755   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
756   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
757   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
758   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
759   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
760 };
761 
762 /*
763 ** Output a single term of CSV.  Actually, p->colSeparator is used for
764 ** the separator, which may or may not be a comma.  p->nullValue is
765 ** the null value.  Strings are quoted if necessary.  The separator
766 ** is only issued if bSep is true.
767 */
768 static void output_csv(ShellState *p, const char *z, int bSep){
769   FILE *out = p->out;
770   if( z==0 ){
771     fprintf(out,"%s",p->nullValue);
772   }else{
773     int i;
774     int nSep = strlen30(p->colSeparator);
775     for(i=0; z[i]; i++){
776       if( needCsvQuote[((unsigned char*)z)[i]]
777          || (z[i]==p->colSeparator[0] &&
778              (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
779         i = 0;
780         break;
781       }
782     }
783     if( i==0 ){
784       putc('"', out);
785       for(i=0; z[i]; i++){
786         if( z[i]=='"' ) putc('"', out);
787         putc(z[i], out);
788       }
789       putc('"', out);
790     }else{
791       fprintf(out, "%s", z);
792     }
793   }
794   if( bSep ){
795     fprintf(p->out, "%s", p->colSeparator);
796   }
797 }
798 
799 #ifdef SIGINT
800 /*
801 ** This routine runs when the user presses Ctrl-C
802 */
803 static void interrupt_handler(int NotUsed){
804   UNUSED_PARAMETER(NotUsed);
805   seenInterrupt++;
806   if( seenInterrupt>2 ) exit(1);
807   if( db ) sqlite3_interrupt(db);
808 }
809 #endif
810 
811 /*
812 ** This is the callback routine that the shell
813 ** invokes for each row of a query result.
814 */
815 static int shell_callback(
816   void *pArg,
817   int nArg,        /* Number of result columns */
818   char **azArg,    /* Text of each result column */
819   char **azCol,    /* Column names */
820   int *aiType      /* Column types */
821 ){
822   int i;
823   ShellState *p = (ShellState*)pArg;
824 
825   switch( p->mode ){
826     case MODE_Line: {
827       int w = 5;
828       if( azArg==0 ) break;
829       for(i=0; i<nArg; i++){
830         int len = strlen30(azCol[i] ? azCol[i] : "");
831         if( len>w ) w = len;
832       }
833       if( p->cnt++>0 ) fprintf(p->out, "%s", p->rowSeparator);
834       for(i=0; i<nArg; i++){
835         fprintf(p->out,"%*s = %s%s", w, azCol[i],
836                 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
837       }
838       break;
839     }
840     case MODE_Explain:
841     case MODE_Column: {
842       if( p->cnt++==0 ){
843         for(i=0; i<nArg; i++){
844           int w, n;
845           if( i<ArraySize(p->colWidth) ){
846             w = p->colWidth[i];
847           }else{
848             w = 0;
849           }
850           if( w==0 ){
851             w = strlen30(azCol[i] ? azCol[i] : "");
852             if( w<10 ) w = 10;
853             n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue);
854             if( w<n ) w = n;
855           }
856           if( i<ArraySize(p->actualWidth) ){
857             p->actualWidth[i] = w;
858           }
859           if( p->showHeader ){
860             if( w<0 ){
861               fprintf(p->out,"%*.*s%s",-w,-w,azCol[i],
862                       i==nArg-1 ? p->rowSeparator : "  ");
863             }else{
864               fprintf(p->out,"%-*.*s%s",w,w,azCol[i],
865                       i==nArg-1 ? p->rowSeparator : "  ");
866             }
867           }
868         }
869         if( p->showHeader ){
870           for(i=0; i<nArg; i++){
871             int w;
872             if( i<ArraySize(p->actualWidth) ){
873                w = p->actualWidth[i];
874                if( w<0 ) w = -w;
875             }else{
876                w = 10;
877             }
878             fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
879                    "----------------------------------------------------------",
880                     i==nArg-1 ? p->rowSeparator : "  ");
881           }
882         }
883       }
884       if( azArg==0 ) break;
885       for(i=0; i<nArg; i++){
886         int w;
887         if( i<ArraySize(p->actualWidth) ){
888            w = p->actualWidth[i];
889         }else{
890            w = 10;
891         }
892         if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
893           w = strlen30(azArg[i]);
894         }
895         if( i==1 && p->aiIndent && p->pStmt ){
896           if( p->iIndent<p->nIndent ){
897             fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
898           }
899           p->iIndent++;
900         }
901         if( w<0 ){
902           fprintf(p->out,"%*.*s%s",-w,-w,
903               azArg[i] ? azArg[i] : p->nullValue,
904               i==nArg-1 ? p->rowSeparator : "  ");
905         }else{
906           fprintf(p->out,"%-*.*s%s",w,w,
907               azArg[i] ? azArg[i] : p->nullValue,
908               i==nArg-1 ? p->rowSeparator : "  ");
909         }
910       }
911       break;
912     }
913     case MODE_Semi:
914     case MODE_List: {
915       if( p->cnt++==0 && p->showHeader ){
916         for(i=0; i<nArg; i++){
917           fprintf(p->out,"%s%s",azCol[i],
918                   i==nArg-1 ? p->rowSeparator : p->colSeparator);
919         }
920       }
921       if( azArg==0 ) break;
922       for(i=0; i<nArg; i++){
923         char *z = azArg[i];
924         if( z==0 ) z = p->nullValue;
925         fprintf(p->out, "%s", z);
926         if( i<nArg-1 ){
927           fprintf(p->out, "%s", p->colSeparator);
928         }else if( p->mode==MODE_Semi ){
929           fprintf(p->out, ";%s", p->rowSeparator);
930         }else{
931           fprintf(p->out, "%s", p->rowSeparator);
932         }
933       }
934       break;
935     }
936     case MODE_Html: {
937       if( p->cnt++==0 && p->showHeader ){
938         fprintf(p->out,"<TR>");
939         for(i=0; i<nArg; i++){
940           fprintf(p->out,"<TH>");
941           output_html_string(p->out, azCol[i]);
942           fprintf(p->out,"</TH>\n");
943         }
944         fprintf(p->out,"</TR>\n");
945       }
946       if( azArg==0 ) break;
947       fprintf(p->out,"<TR>");
948       for(i=0; i<nArg; i++){
949         fprintf(p->out,"<TD>");
950         output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
951         fprintf(p->out,"</TD>\n");
952       }
953       fprintf(p->out,"</TR>\n");
954       break;
955     }
956     case MODE_Tcl: {
957       if( p->cnt++==0 && p->showHeader ){
958         for(i=0; i<nArg; i++){
959           output_c_string(p->out,azCol[i] ? azCol[i] : "");
960           if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
961         }
962         fprintf(p->out, "%s", p->rowSeparator);
963       }
964       if( azArg==0 ) break;
965       for(i=0; i<nArg; i++){
966         output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
967         if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
968       }
969       fprintf(p->out, "%s", p->rowSeparator);
970       break;
971     }
972     case MODE_Csv: {
973       setBinaryMode(p->out);
974       if( p->cnt++==0 && p->showHeader ){
975         for(i=0; i<nArg; i++){
976           output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
977         }
978         fprintf(p->out, "%s", p->rowSeparator);
979       }
980       if( nArg>0 ){
981         for(i=0; i<nArg; i++){
982           output_csv(p, azArg[i], i<nArg-1);
983         }
984         fprintf(p->out, "%s", p->rowSeparator);
985       }
986       setTextMode(p->out);
987       break;
988     }
989     case MODE_Insert: {
990       p->cnt++;
991       if( azArg==0 ) break;
992       fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
993       for(i=0; i<nArg; i++){
994         char *zSep = i>0 ? ",": "";
995         if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
996           fprintf(p->out,"%sNULL",zSep);
997         }else if( aiType && aiType[i]==SQLITE_TEXT ){
998           if( zSep[0] ) fprintf(p->out,"%s",zSep);
999           output_quoted_string(p->out, azArg[i]);
1000         }else if( aiType && (aiType[i]==SQLITE_INTEGER
1001                              || aiType[i]==SQLITE_FLOAT) ){
1002           fprintf(p->out,"%s%s",zSep, azArg[i]);
1003         }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
1004           const void *pBlob = sqlite3_column_blob(p->pStmt, i);
1005           int nBlob = sqlite3_column_bytes(p->pStmt, i);
1006           if( zSep[0] ) fprintf(p->out,"%s",zSep);
1007           output_hex_blob(p->out, pBlob, nBlob);
1008         }else if( isNumber(azArg[i], 0) ){
1009           fprintf(p->out,"%s%s",zSep, azArg[i]);
1010         }else{
1011           if( zSep[0] ) fprintf(p->out,"%s",zSep);
1012           output_quoted_string(p->out, azArg[i]);
1013         }
1014       }
1015       fprintf(p->out,");\n");
1016       break;
1017     }
1018     case MODE_Ascii: {
1019       if( p->cnt++==0 && p->showHeader ){
1020         for(i=0; i<nArg; i++){
1021           if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1022           fprintf(p->out,"%s",azCol[i] ? azCol[i] : "");
1023         }
1024         fprintf(p->out, "%s", p->rowSeparator);
1025       }
1026       if( azArg==0 ) break;
1027       for(i=0; i<nArg; i++){
1028         if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1029         fprintf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
1030       }
1031       fprintf(p->out, "%s", p->rowSeparator);
1032       break;
1033     }
1034   }
1035   return 0;
1036 }
1037 
1038 /*
1039 ** This is the callback routine that the SQLite library
1040 ** invokes for each row of a query result.
1041 */
1042 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1043   /* since we don't have type info, call the shell_callback with a NULL value */
1044   return shell_callback(pArg, nArg, azArg, azCol, NULL);
1045 }
1046 
1047 /*
1048 ** Set the destination table field of the ShellState structure to
1049 ** the name of the table given.  Escape any quote characters in the
1050 ** table name.
1051 */
1052 static void set_table_name(ShellState *p, const char *zName){
1053   int i, n;
1054   int needQuote;
1055   char *z;
1056 
1057   if( p->zDestTable ){
1058     free(p->zDestTable);
1059     p->zDestTable = 0;
1060   }
1061   if( zName==0 ) return;
1062   needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1063   for(i=n=0; zName[i]; i++, n++){
1064     if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1065       needQuote = 1;
1066       if( zName[i]=='\'' ) n++;
1067     }
1068   }
1069   if( needQuote ) n += 2;
1070   z = p->zDestTable = malloc( n+1 );
1071   if( z==0 ){
1072     fprintf(stderr,"Error: out of memory\n");
1073     exit(1);
1074   }
1075   n = 0;
1076   if( needQuote ) z[n++] = '\'';
1077   for(i=0; zName[i]; i++){
1078     z[n++] = zName[i];
1079     if( zName[i]=='\'' ) z[n++] = '\'';
1080   }
1081   if( needQuote ) z[n++] = '\'';
1082   z[n] = 0;
1083 }
1084 
1085 /* zIn is either a pointer to a NULL-terminated string in memory obtained
1086 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1087 ** added to zIn, and the result returned in memory obtained from malloc().
1088 ** zIn, if it was not NULL, is freed.
1089 **
1090 ** If the third argument, quote, is not '\0', then it is used as a
1091 ** quote character for zAppend.
1092 */
1093 static char *appendText(char *zIn, char const *zAppend, char quote){
1094   int len;
1095   int i;
1096   int nAppend = strlen30(zAppend);
1097   int nIn = (zIn?strlen30(zIn):0);
1098 
1099   len = nAppend+nIn+1;
1100   if( quote ){
1101     len += 2;
1102     for(i=0; i<nAppend; i++){
1103       if( zAppend[i]==quote ) len++;
1104     }
1105   }
1106 
1107   zIn = (char *)realloc(zIn, len);
1108   if( !zIn ){
1109     return 0;
1110   }
1111 
1112   if( quote ){
1113     char *zCsr = &zIn[nIn];
1114     *zCsr++ = quote;
1115     for(i=0; i<nAppend; i++){
1116       *zCsr++ = zAppend[i];
1117       if( zAppend[i]==quote ) *zCsr++ = quote;
1118     }
1119     *zCsr++ = quote;
1120     *zCsr++ = '\0';
1121     assert( (zCsr-zIn)==len );
1122   }else{
1123     memcpy(&zIn[nIn], zAppend, nAppend);
1124     zIn[len-1] = '\0';
1125   }
1126 
1127   return zIn;
1128 }
1129 
1130 
1131 /*
1132 ** Execute a query statement that will generate SQL output.  Print
1133 ** the result columns, comma-separated, on a line and then add a
1134 ** semicolon terminator to the end of that line.
1135 **
1136 ** If the number of columns is 1 and that column contains text "--"
1137 ** then write the semicolon on a separate line.  That way, if a
1138 ** "--" comment occurs at the end of the statement, the comment
1139 ** won't consume the semicolon terminator.
1140 */
1141 static int run_table_dump_query(
1142   ShellState *p,           /* Query context */
1143   const char *zSelect,     /* SELECT statement to extract content */
1144   const char *zFirstRow    /* Print before first row, if not NULL */
1145 ){
1146   sqlite3_stmt *pSelect;
1147   int rc;
1148   int nResult;
1149   int i;
1150   const char *z;
1151   rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
1152   if( rc!=SQLITE_OK || !pSelect ){
1153     fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1154     if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1155     return rc;
1156   }
1157   rc = sqlite3_step(pSelect);
1158   nResult = sqlite3_column_count(pSelect);
1159   while( rc==SQLITE_ROW ){
1160     if( zFirstRow ){
1161       fprintf(p->out, "%s", zFirstRow);
1162       zFirstRow = 0;
1163     }
1164     z = (const char*)sqlite3_column_text(pSelect, 0);
1165     fprintf(p->out, "%s", z);
1166     for(i=1; i<nResult; i++){
1167       fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
1168     }
1169     if( z==0 ) z = "";
1170     while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
1171     if( z[0] ){
1172       fprintf(p->out, "\n;\n");
1173     }else{
1174       fprintf(p->out, ";\n");
1175     }
1176     rc = sqlite3_step(pSelect);
1177   }
1178   rc = sqlite3_finalize(pSelect);
1179   if( rc!=SQLITE_OK ){
1180     fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1181     if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1182   }
1183   return rc;
1184 }
1185 
1186 /*
1187 ** Allocate space and save off current error string.
1188 */
1189 static char *save_err_msg(
1190   sqlite3 *db            /* Database to query */
1191 ){
1192   int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1193   char *zErrMsg = sqlite3_malloc(nErrMsg);
1194   if( zErrMsg ){
1195     memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1196   }
1197   return zErrMsg;
1198 }
1199 
1200 /*
1201 ** Display memory stats.
1202 */
1203 static int display_stats(
1204   sqlite3 *db,                /* Database to query */
1205   ShellState *pArg,           /* Pointer to ShellState */
1206   int bReset                  /* True to reset the stats */
1207 ){
1208   int iCur;
1209   int iHiwtr;
1210 
1211   if( pArg && pArg->out ){
1212 
1213     iHiwtr = iCur = -1;
1214     sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1215     fprintf(pArg->out,
1216             "Memory Used:                         %d (max %d) bytes\n",
1217             iCur, iHiwtr);
1218     iHiwtr = iCur = -1;
1219     sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1220     fprintf(pArg->out, "Number of Outstanding Allocations:   %d (max %d)\n",
1221             iCur, iHiwtr);
1222     if( pArg->shellFlgs & SHFLG_Pagecache ){
1223       iHiwtr = iCur = -1;
1224       sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1225       fprintf(pArg->out,
1226               "Number of Pcache Pages Used:         %d (max %d) pages\n",
1227               iCur, iHiwtr);
1228     }
1229     iHiwtr = iCur = -1;
1230     sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1231     fprintf(pArg->out,
1232             "Number of Pcache Overflow Bytes:     %d (max %d) bytes\n",
1233             iCur, iHiwtr);
1234     if( pArg->shellFlgs & SHFLG_Scratch ){
1235       iHiwtr = iCur = -1;
1236       sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1237       fprintf(pArg->out, "Number of Scratch Allocations Used:  %d (max %d)\n",
1238               iCur, iHiwtr);
1239     }
1240     iHiwtr = iCur = -1;
1241     sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1242     fprintf(pArg->out,
1243             "Number of Scratch Overflow Bytes:    %d (max %d) bytes\n",
1244             iCur, iHiwtr);
1245     iHiwtr = iCur = -1;
1246     sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1247     fprintf(pArg->out, "Largest Allocation:                  %d bytes\n",
1248             iHiwtr);
1249     iHiwtr = iCur = -1;
1250     sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1251     fprintf(pArg->out, "Largest Pcache Allocation:           %d bytes\n",
1252             iHiwtr);
1253     iHiwtr = iCur = -1;
1254     sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1255     fprintf(pArg->out, "Largest Scratch Allocation:          %d bytes\n",
1256             iHiwtr);
1257 #ifdef YYTRACKMAXSTACKDEPTH
1258     iHiwtr = iCur = -1;
1259     sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1260     fprintf(pArg->out, "Deepest Parser Stack:                %d (max %d)\n",
1261             iCur, iHiwtr);
1262 #endif
1263   }
1264 
1265   if( pArg && pArg->out && db ){
1266     if( pArg->shellFlgs & SHFLG_Lookaside ){
1267       iHiwtr = iCur = -1;
1268       sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
1269                         &iCur, &iHiwtr, bReset);
1270       fprintf(pArg->out, "Lookaside Slots Used:                %d (max %d)\n",
1271               iCur, iHiwtr);
1272       sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
1273                         &iCur, &iHiwtr, bReset);
1274       fprintf(pArg->out, "Successful lookaside attempts:       %d\n", iHiwtr);
1275       sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
1276                         &iCur, &iHiwtr, bReset);
1277       fprintf(pArg->out, "Lookaside failures due to size:      %d\n", iHiwtr);
1278       sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
1279                         &iCur, &iHiwtr, bReset);
1280       fprintf(pArg->out, "Lookaside failures due to OOM:       %d\n", iHiwtr);
1281     }
1282     iHiwtr = iCur = -1;
1283     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1284     fprintf(pArg->out, "Pager Heap Usage:                    %d bytes\n",iCur);
1285     iHiwtr = iCur = -1;
1286     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1287     fprintf(pArg->out, "Page cache hits:                     %d\n", iCur);
1288     iHiwtr = iCur = -1;
1289     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1290     fprintf(pArg->out, "Page cache misses:                   %d\n", iCur);
1291     iHiwtr = iCur = -1;
1292     sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1293     fprintf(pArg->out, "Page cache writes:                   %d\n", iCur);
1294     iHiwtr = iCur = -1;
1295     sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1296     fprintf(pArg->out, "Schema Heap Usage:                   %d bytes\n",iCur);
1297     iHiwtr = iCur = -1;
1298     sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1299     fprintf(pArg->out, "Statement Heap/Lookaside Usage:      %d bytes\n",iCur);
1300   }
1301 
1302   if( pArg && pArg->out && db && pArg->pStmt ){
1303     iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
1304                                bReset);
1305     fprintf(pArg->out, "Fullscan Steps:                      %d\n", iCur);
1306     iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1307     fprintf(pArg->out, "Sort Operations:                     %d\n", iCur);
1308     iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
1309     fprintf(pArg->out, "Autoindex Inserts:                   %d\n", iCur);
1310     iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
1311     fprintf(pArg->out, "Virtual Machine Steps:               %d\n", iCur);
1312   }
1313 
1314   return 0;
1315 }
1316 
1317 /*
1318 ** Display scan stats.
1319 */
1320 static void display_scanstats(
1321   sqlite3 *db,                    /* Database to query */
1322   ShellState *pArg                /* Pointer to ShellState */
1323 ){
1324 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1325   int i, k, n, mx;
1326   fprintf(pArg->out, "-------- scanstats --------\n");
1327   mx = 0;
1328   for(k=0; k<=mx; k++){
1329     double rEstLoop = 1.0;
1330     for(i=n=0; 1; i++){
1331       sqlite3_stmt *p = pArg->pStmt;
1332       sqlite3_int64 nLoop, nVisit;
1333       double rEst;
1334       int iSid;
1335       const char *zExplain;
1336       if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
1337         break;
1338       }
1339       sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
1340       if( iSid>mx ) mx = iSid;
1341       if( iSid!=k ) continue;
1342       if( n==0 ){
1343         rEstLoop = (double)nLoop;
1344         if( k>0 ) fprintf(pArg->out, "-------- subquery %d -------\n", k);
1345       }
1346       n++;
1347       sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
1348       sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
1349       sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
1350       fprintf(pArg->out, "Loop %2d: %s\n", n, zExplain);
1351       rEstLoop *= rEst;
1352       fprintf(pArg->out,
1353           "         nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
1354           nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
1355       );
1356     }
1357   }
1358   fprintf(pArg->out, "---------------------------\n");
1359 #endif
1360 }
1361 
1362 /*
1363 ** Parameter azArray points to a zero-terminated array of strings. zStr
1364 ** points to a single nul-terminated string. Return non-zero if zStr
1365 ** is equal, according to strcmp(), to any of the strings in the array.
1366 ** Otherwise, return zero.
1367 */
1368 static int str_in_array(const char *zStr, const char **azArray){
1369   int i;
1370   for(i=0; azArray[i]; i++){
1371     if( 0==strcmp(zStr, azArray[i]) ) return 1;
1372   }
1373   return 0;
1374 }
1375 
1376 /*
1377 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1378 ** and populate the ShellState.aiIndent[] array with the number of
1379 ** spaces each opcode should be indented before it is output.
1380 **
1381 ** The indenting rules are:
1382 **
1383 **     * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1384 **       all opcodes that occur between the p2 jump destination and the opcode
1385 **       itself by 2 spaces.
1386 **
1387 **     * For each "Goto", if the jump destination is earlier in the program
1388 **       and ends on one of:
1389 **          Yield  SeekGt  SeekLt  RowSetRead  Rewind
1390 **       or if the P1 parameter is one instead of zero,
1391 **       then indent all opcodes between the earlier instruction
1392 **       and "Goto" by 2 spaces.
1393 */
1394 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
1395   const char *zSql;               /* The text of the SQL statement */
1396   const char *z;                  /* Used to check if this is an EXPLAIN */
1397   int *abYield = 0;               /* True if op is an OP_Yield */
1398   int nAlloc = 0;                 /* Allocated size of p->aiIndent[], abYield */
1399   int iOp;                        /* Index of operation in p->aiIndent[] */
1400 
1401   const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
1402                            "NextIfOpen", "PrevIfOpen", 0 };
1403   const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
1404                             "Rewind", 0 };
1405   const char *azGoto[] = { "Goto", 0 };
1406 
1407   /* Try to figure out if this is really an EXPLAIN statement. If this
1408   ** cannot be verified, return early.  */
1409   zSql = sqlite3_sql(pSql);
1410   if( zSql==0 ) return;
1411   for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
1412   if( sqlite3_strnicmp(z, "explain", 7) ) return;
1413 
1414   for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
1415     int i;
1416     int iAddr = sqlite3_column_int(pSql, 0);
1417     const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
1418 
1419     /* Set p2 to the P2 field of the current opcode. Then, assuming that
1420     ** p2 is an instruction address, set variable p2op to the index of that
1421     ** instruction in the aiIndent[] array. p2 and p2op may be different if
1422     ** the current instruction is part of a sub-program generated by an
1423     ** SQL trigger or foreign key.  */
1424     int p2 = sqlite3_column_int(pSql, 3);
1425     int p2op = (p2 + (iOp-iAddr));
1426 
1427     /* Grow the p->aiIndent array as required */
1428     if( iOp>=nAlloc ){
1429       nAlloc += 100;
1430       p->aiIndent = (int*)sqlite3_realloc(p->aiIndent, nAlloc*sizeof(int));
1431       abYield = (int*)sqlite3_realloc(abYield, nAlloc*sizeof(int));
1432     }
1433     abYield[iOp] = str_in_array(zOp, azYield);
1434     p->aiIndent[iOp] = 0;
1435     p->nIndent = iOp+1;
1436 
1437     if( str_in_array(zOp, azNext) ){
1438       for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
1439     }
1440     if( str_in_array(zOp, azGoto) && p2op<p->nIndent
1441      && (abYield[p2op] || sqlite3_column_int(pSql, 2))
1442     ){
1443       for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
1444     }
1445   }
1446 
1447   p->iIndent = 0;
1448   sqlite3_free(abYield);
1449   sqlite3_reset(pSql);
1450 }
1451 
1452 /*
1453 ** Free the array allocated by explain_data_prepare().
1454 */
1455 static void explain_data_delete(ShellState *p){
1456   sqlite3_free(p->aiIndent);
1457   p->aiIndent = 0;
1458   p->nIndent = 0;
1459   p->iIndent = 0;
1460 }
1461 
1462 /*
1463 ** Execute a statement or set of statements.  Print
1464 ** any result rows/columns depending on the current mode
1465 ** set via the supplied callback.
1466 **
1467 ** This is very similar to SQLite's built-in sqlite3_exec()
1468 ** function except it takes a slightly different callback
1469 ** and callback data argument.
1470 */
1471 static int shell_exec(
1472   sqlite3 *db,                              /* An open database */
1473   const char *zSql,                         /* SQL to be evaluated */
1474   int (*xCallback)(void*,int,char**,char**,int*),   /* Callback function */
1475                                             /* (not the same as sqlite3_exec) */
1476   ShellState *pArg,                         /* Pointer to ShellState */
1477   char **pzErrMsg                           /* Error msg written here */
1478 ){
1479   sqlite3_stmt *pStmt = NULL;     /* Statement to execute. */
1480   int rc = SQLITE_OK;             /* Return Code */
1481   int rc2;
1482   const char *zLeftover;          /* Tail of unprocessed SQL */
1483 
1484   if( pzErrMsg ){
1485     *pzErrMsg = NULL;
1486   }
1487 
1488   while( zSql[0] && (SQLITE_OK == rc) ){
1489     rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1490     if( SQLITE_OK != rc ){
1491       if( pzErrMsg ){
1492         *pzErrMsg = save_err_msg(db);
1493       }
1494     }else{
1495       if( !pStmt ){
1496         /* this happens for a comment or white-space */
1497         zSql = zLeftover;
1498         while( IsSpace(zSql[0]) ) zSql++;
1499         continue;
1500       }
1501 
1502       /* save off the prepared statment handle and reset row count */
1503       if( pArg ){
1504         pArg->pStmt = pStmt;
1505         pArg->cnt = 0;
1506       }
1507 
1508       /* echo the sql statement if echo on */
1509       if( pArg && pArg->echoOn ){
1510         const char *zStmtSql = sqlite3_sql(pStmt);
1511         fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1512       }
1513 
1514       /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1515       if( pArg && pArg->autoEQP ){
1516         sqlite3_stmt *pExplain;
1517         char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
1518                                      sqlite3_sql(pStmt));
1519         rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
1520         if( rc==SQLITE_OK ){
1521           while( sqlite3_step(pExplain)==SQLITE_ROW ){
1522             fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0));
1523             fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
1524             fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
1525             fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
1526           }
1527         }
1528         sqlite3_finalize(pExplain);
1529         sqlite3_free(zEQP);
1530       }
1531 
1532       /* If the shell is currently in ".explain" mode, gather the extra
1533       ** data required to add indents to the output.*/
1534       if( pArg && pArg->mode==MODE_Explain ){
1535         explain_data_prepare(pArg, pStmt);
1536       }
1537 
1538       /* perform the first step.  this will tell us if we
1539       ** have a result set or not and how wide it is.
1540       */
1541       rc = sqlite3_step(pStmt);
1542       /* if we have a result set... */
1543       if( SQLITE_ROW == rc ){
1544         /* if we have a callback... */
1545         if( xCallback ){
1546           /* allocate space for col name ptr, value ptr, and type */
1547           int nCol = sqlite3_column_count(pStmt);
1548           void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1549           if( !pData ){
1550             rc = SQLITE_NOMEM;
1551           }else{
1552             char **azCols = (char **)pData;      /* Names of result columns */
1553             char **azVals = &azCols[nCol];       /* Results */
1554             int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1555             int i, x;
1556             assert(sizeof(int) <= sizeof(char *));
1557             /* save off ptrs to column names */
1558             for(i=0; i<nCol; i++){
1559               azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1560             }
1561             do{
1562               /* extract the data and data types */
1563               for(i=0; i<nCol; i++){
1564                 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
1565                 if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
1566                   azVals[i] = "";
1567                 }else{
1568                   azVals[i] = (char*)sqlite3_column_text(pStmt, i);
1569                 }
1570                 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1571                   rc = SQLITE_NOMEM;
1572                   break; /* from for */
1573                 }
1574               } /* end for */
1575 
1576               /* if data and types extracted successfully... */
1577               if( SQLITE_ROW == rc ){
1578                 /* call the supplied callback with the result row data */
1579                 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1580                   rc = SQLITE_ABORT;
1581                 }else{
1582                   rc = sqlite3_step(pStmt);
1583                 }
1584               }
1585             } while( SQLITE_ROW == rc );
1586             sqlite3_free(pData);
1587           }
1588         }else{
1589           do{
1590             rc = sqlite3_step(pStmt);
1591           } while( rc == SQLITE_ROW );
1592         }
1593       }
1594 
1595       explain_data_delete(pArg);
1596 
1597       /* print usage stats if stats on */
1598       if( pArg && pArg->statsOn ){
1599         display_stats(db, pArg, 0);
1600       }
1601 
1602       /* print loop-counters if required */
1603       if( pArg && pArg->scanstatsOn ){
1604         display_scanstats(db, pArg);
1605       }
1606 
1607       /* Finalize the statement just executed. If this fails, save a
1608       ** copy of the error message. Otherwise, set zSql to point to the
1609       ** next statement to execute. */
1610       rc2 = sqlite3_finalize(pStmt);
1611       if( rc!=SQLITE_NOMEM ) rc = rc2;
1612       if( rc==SQLITE_OK ){
1613         zSql = zLeftover;
1614         while( IsSpace(zSql[0]) ) zSql++;
1615       }else if( pzErrMsg ){
1616         *pzErrMsg = save_err_msg(db);
1617       }
1618 
1619       /* clear saved stmt handle */
1620       if( pArg ){
1621         pArg->pStmt = NULL;
1622       }
1623     }
1624   } /* end while */
1625 
1626   return rc;
1627 }
1628 
1629 
1630 /*
1631 ** This is a different callback routine used for dumping the database.
1632 ** Each row received by this callback consists of a table name,
1633 ** the table type ("index" or "table") and SQL to create the table.
1634 ** This routine should print text sufficient to recreate the table.
1635 */
1636 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1637   int rc;
1638   const char *zTable;
1639   const char *zType;
1640   const char *zSql;
1641   const char *zPrepStmt = 0;
1642   ShellState *p = (ShellState *)pArg;
1643 
1644   UNUSED_PARAMETER(azCol);
1645   if( nArg!=3 ) return 1;
1646   zTable = azArg[0];
1647   zType = azArg[1];
1648   zSql = azArg[2];
1649 
1650   if( strcmp(zTable, "sqlite_sequence")==0 ){
1651     zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1652   }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
1653     fprintf(p->out, "ANALYZE sqlite_master;\n");
1654   }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1655     return 0;
1656   }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1657     char *zIns;
1658     if( !p->writableSchema ){
1659       fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1660       p->writableSchema = 1;
1661     }
1662     zIns = sqlite3_mprintf(
1663        "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1664        "VALUES('table','%q','%q',0,'%q');",
1665        zTable, zTable, zSql);
1666     fprintf(p->out, "%s\n", zIns);
1667     sqlite3_free(zIns);
1668     return 0;
1669   }else{
1670     fprintf(p->out, "%s;\n", zSql);
1671   }
1672 
1673   if( strcmp(zType, "table")==0 ){
1674     sqlite3_stmt *pTableInfo = 0;
1675     char *zSelect = 0;
1676     char *zTableInfo = 0;
1677     char *zTmp = 0;
1678     int nRow = 0;
1679 
1680     zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1681     zTableInfo = appendText(zTableInfo, zTable, '"');
1682     zTableInfo = appendText(zTableInfo, ");", 0);
1683 
1684     rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
1685     free(zTableInfo);
1686     if( rc!=SQLITE_OK || !pTableInfo ){
1687       return 1;
1688     }
1689 
1690     zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1691     /* Always quote the table name, even if it appears to be pure ascii,
1692     ** in case it is a keyword. Ex:  INSERT INTO "table" ... */
1693     zTmp = appendText(zTmp, zTable, '"');
1694     if( zTmp ){
1695       zSelect = appendText(zSelect, zTmp, '\'');
1696       free(zTmp);
1697     }
1698     zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1699     rc = sqlite3_step(pTableInfo);
1700     while( rc==SQLITE_ROW ){
1701       const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1702       zSelect = appendText(zSelect, "quote(", 0);
1703       zSelect = appendText(zSelect, zText, '"');
1704       rc = sqlite3_step(pTableInfo);
1705       if( rc==SQLITE_ROW ){
1706         zSelect = appendText(zSelect, "), ", 0);
1707       }else{
1708         zSelect = appendText(zSelect, ") ", 0);
1709       }
1710       nRow++;
1711     }
1712     rc = sqlite3_finalize(pTableInfo);
1713     if( rc!=SQLITE_OK || nRow==0 ){
1714       free(zSelect);
1715       return 1;
1716     }
1717     zSelect = appendText(zSelect, "|| ')' FROM  ", 0);
1718     zSelect = appendText(zSelect, zTable, '"');
1719 
1720     rc = run_table_dump_query(p, zSelect, zPrepStmt);
1721     if( rc==SQLITE_CORRUPT ){
1722       zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1723       run_table_dump_query(p, zSelect, 0);
1724     }
1725     free(zSelect);
1726   }
1727   return 0;
1728 }
1729 
1730 /*
1731 ** Run zQuery.  Use dump_callback() as the callback routine so that
1732 ** the contents of the query are output as SQL statements.
1733 **
1734 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1735 ** "ORDER BY rowid DESC" to the end.
1736 */
1737 static int run_schema_dump_query(
1738   ShellState *p,
1739   const char *zQuery
1740 ){
1741   int rc;
1742   char *zErr = 0;
1743   rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1744   if( rc==SQLITE_CORRUPT ){
1745     char *zQ2;
1746     int len = strlen30(zQuery);
1747     fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1748     if( zErr ){
1749       fprintf(p->out, "/****** %s ******/\n", zErr);
1750       sqlite3_free(zErr);
1751       zErr = 0;
1752     }
1753     zQ2 = malloc( len+100 );
1754     if( zQ2==0 ) return rc;
1755     sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1756     rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1757     if( rc ){
1758       fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1759     }else{
1760       rc = SQLITE_CORRUPT;
1761     }
1762     sqlite3_free(zErr);
1763     free(zQ2);
1764   }
1765   return rc;
1766 }
1767 
1768 /*
1769 ** Text of a help message
1770 */
1771 static char zHelp[] =
1772   ".backup ?DB? FILE      Backup DB (default \"main\") to FILE\n"
1773   ".bail on|off           Stop after hitting an error.  Default OFF\n"
1774   ".clone NEWDB           Clone data into NEWDB from the existing database\n"
1775   ".databases             List names and files of attached databases\n"
1776   ".dbinfo ?DB?           Show status information about the database\n"
1777   ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
1778   "                         If TABLE specified, only dump tables matching\n"
1779   "                         LIKE pattern TABLE.\n"
1780   ".echo on|off           Turn command echo on or off\n"
1781   ".eqp on|off            Enable or disable automatic EXPLAIN QUERY PLAN\n"
1782   ".exit                  Exit this program\n"
1783   ".explain ?on|off?      Turn output mode suitable for EXPLAIN on or off.\n"
1784   "                         With no args, it turns EXPLAIN on.\n"
1785   ".fullschema            Show schema and the content of sqlite_stat tables\n"
1786   ".headers on|off        Turn display of headers on or off\n"
1787   ".help                  Show this message\n"
1788   ".import FILE TABLE     Import data from FILE into TABLE\n"
1789   ".indexes ?TABLE?       Show names of all indexes\n"
1790   "                         If TABLE specified, only show indexes for tables\n"
1791   "                         matching LIKE pattern TABLE.\n"
1792 #ifdef SQLITE_ENABLE_IOTRACE
1793   ".iotrace FILE          Enable I/O diagnostic logging to FILE\n"
1794 #endif
1795 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1796   ".load FILE ?ENTRY?     Load an extension library\n"
1797 #endif
1798   ".log FILE|off          Turn logging on or off.  FILE can be stderr/stdout\n"
1799   ".mode MODE ?TABLE?     Set output mode where MODE is one of:\n"
1800   "                         ascii    Columns/rows delimited by 0x1F and 0x1E\n"
1801   "                         csv      Comma-separated values\n"
1802   "                         column   Left-aligned columns.  (See .width)\n"
1803   "                         html     HTML <table> code\n"
1804   "                         insert   SQL insert statements for TABLE\n"
1805   "                         line     One value per line\n"
1806   "                         list     Values delimited by .separator strings\n"
1807   "                         tabs     Tab-separated values\n"
1808   "                         tcl      TCL list elements\n"
1809   ".nullvalue STRING      Use STRING in place of NULL values\n"
1810   ".once FILENAME         Output for the next SQL command only to FILENAME\n"
1811   ".open ?FILENAME?       Close existing database and reopen FILENAME\n"
1812   ".output ?FILENAME?     Send output to FILENAME or stdout\n"
1813   ".print STRING...       Print literal STRING\n"
1814   ".prompt MAIN CONTINUE  Replace the standard prompts\n"
1815   ".quit                  Exit this program\n"
1816   ".read FILENAME         Execute SQL in FILENAME\n"
1817   ".restore ?DB? FILE     Restore content of DB (default \"main\") from FILE\n"
1818   ".save FILE             Write in-memory database into FILE\n"
1819   ".scanstats on|off      Turn sqlite3_stmt_scanstatus() metrics on or off\n"
1820   ".schema ?TABLE?        Show the CREATE statements\n"
1821   "                         If TABLE specified, only show tables matching\n"
1822   "                         LIKE pattern TABLE.\n"
1823   ".separator COL ?ROW?   Change the column separator and optionally the row\n"
1824   "                         separator for both the output mode and .import\n"
1825   ".shell CMD ARGS...     Run CMD ARGS... in a system shell\n"
1826   ".show                  Show the current values for various settings\n"
1827   ".stats on|off          Turn stats on or off\n"
1828   ".system CMD ARGS...    Run CMD ARGS... in a system shell\n"
1829   ".tables ?TABLE?        List names of tables\n"
1830   "                         If TABLE specified, only list tables matching\n"
1831   "                         LIKE pattern TABLE.\n"
1832   ".timeout MS            Try opening locked tables for MS milliseconds\n"
1833   ".timer on|off          Turn SQL timer on or off\n"
1834   ".trace FILE|off        Output each SQL statement as it is run\n"
1835   ".vfsname ?AUX?         Print the name of the VFS stack\n"
1836   ".width NUM1 NUM2 ...   Set column widths for \"column\" mode\n"
1837   "                         Negative values right-justify\n"
1838 ;
1839 
1840 /* Forward reference */
1841 static int process_input(ShellState *p, FILE *in);
1842 /*
1843 ** Implementation of the "readfile(X)" SQL function.  The entire content
1844 ** of the file named X is read and returned as a BLOB.  NULL is returned
1845 ** if the file does not exist or is unreadable.
1846 */
1847 static void readfileFunc(
1848   sqlite3_context *context,
1849   int argc,
1850   sqlite3_value **argv
1851 ){
1852   const char *zName;
1853   FILE *in;
1854   long nIn;
1855   void *pBuf;
1856 
1857   zName = (const char*)sqlite3_value_text(argv[0]);
1858   if( zName==0 ) return;
1859   in = fopen(zName, "rb");
1860   if( in==0 ) return;
1861   fseek(in, 0, SEEK_END);
1862   nIn = ftell(in);
1863   rewind(in);
1864   pBuf = sqlite3_malloc( nIn );
1865   if( pBuf && 1==fread(pBuf, nIn, 1, in) ){
1866     sqlite3_result_blob(context, pBuf, nIn, sqlite3_free);
1867   }else{
1868     sqlite3_free(pBuf);
1869   }
1870   fclose(in);
1871 }
1872 
1873 /*
1874 ** Implementation of the "writefile(X,Y)" SQL function.  The argument Y
1875 ** is written into file X.  The number of bytes written is returned.  Or
1876 ** NULL is returned if something goes wrong, such as being unable to open
1877 ** file X for writing.
1878 */
1879 static void writefileFunc(
1880   sqlite3_context *context,
1881   int argc,
1882   sqlite3_value **argv
1883 ){
1884   FILE *out;
1885   const char *z;
1886   sqlite3_int64 rc;
1887   const char *zFile;
1888 
1889   zFile = (const char*)sqlite3_value_text(argv[0]);
1890   if( zFile==0 ) return;
1891   out = fopen(zFile, "wb");
1892   if( out==0 ) return;
1893   z = (const char*)sqlite3_value_blob(argv[1]);
1894   if( z==0 ){
1895     rc = 0;
1896   }else{
1897     rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
1898   }
1899   fclose(out);
1900   sqlite3_result_int64(context, rc);
1901 }
1902 
1903 /*
1904 ** Make sure the database is open.  If it is not, then open it.  If
1905 ** the database fails to open, print an error message and exit.
1906 */
1907 static void open_db(ShellState *p, int keepAlive){
1908   if( p->db==0 ){
1909     sqlite3_initialize();
1910     sqlite3_open(p->zDbFilename, &p->db);
1911     db = p->db;
1912     if( db && sqlite3_errcode(db)==SQLITE_OK ){
1913       sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1914           shellstaticFunc, 0, 0);
1915     }
1916     if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1917       fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1918           p->zDbFilename, sqlite3_errmsg(db));
1919       if( keepAlive ) return;
1920       exit(1);
1921     }
1922 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1923     sqlite3_enable_load_extension(p->db, 1);
1924 #endif
1925     sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
1926                             readfileFunc, 0, 0);
1927     sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
1928                             writefileFunc, 0, 0);
1929   }
1930 }
1931 
1932 /*
1933 ** Do C-language style dequoting.
1934 **
1935 **    \t    -> tab
1936 **    \n    -> newline
1937 **    \r    -> carriage return
1938 **    \"    -> "
1939 **    \NNN  -> ascii character NNN in octal
1940 **    \\    -> backslash
1941 */
1942 static void resolve_backslashes(char *z){
1943   int i, j;
1944   char c;
1945   while( *z && *z!='\\' ) z++;
1946   for(i=j=0; (c = z[i])!=0; i++, j++){
1947     if( c=='\\' ){
1948       c = z[++i];
1949       if( c=='n' ){
1950         c = '\n';
1951       }else if( c=='t' ){
1952         c = '\t';
1953       }else if( c=='r' ){
1954         c = '\r';
1955       }else if( c=='\\' ){
1956         c = '\\';
1957       }else if( c>='0' && c<='7' ){
1958         c -= '0';
1959         if( z[i+1]>='0' && z[i+1]<='7' ){
1960           i++;
1961           c = (c<<3) + z[i] - '0';
1962           if( z[i+1]>='0' && z[i+1]<='7' ){
1963             i++;
1964             c = (c<<3) + z[i] - '0';
1965           }
1966         }
1967       }
1968     }
1969     z[j] = c;
1970   }
1971   if( j<i ) z[j] = 0;
1972 }
1973 
1974 /*
1975 ** Return the value of a hexadecimal digit.  Return -1 if the input
1976 ** is not a hex digit.
1977 */
1978 static int hexDigitValue(char c){
1979   if( c>='0' && c<='9' ) return c - '0';
1980   if( c>='a' && c<='f' ) return c - 'a' + 10;
1981   if( c>='A' && c<='F' ) return c - 'A' + 10;
1982   return -1;
1983 }
1984 
1985 /*
1986 ** Interpret zArg as an integer value, possibly with suffixes.
1987 */
1988 static sqlite3_int64 integerValue(const char *zArg){
1989   sqlite3_int64 v = 0;
1990   static const struct { char *zSuffix; int iMult; } aMult[] = {
1991     { "KiB", 1024 },
1992     { "MiB", 1024*1024 },
1993     { "GiB", 1024*1024*1024 },
1994     { "KB",  1000 },
1995     { "MB",  1000000 },
1996     { "GB",  1000000000 },
1997     { "K",   1000 },
1998     { "M",   1000000 },
1999     { "G",   1000000000 },
2000   };
2001   int i;
2002   int isNeg = 0;
2003   if( zArg[0]=='-' ){
2004     isNeg = 1;
2005     zArg++;
2006   }else if( zArg[0]=='+' ){
2007     zArg++;
2008   }
2009   if( zArg[0]=='0' && zArg[1]=='x' ){
2010     int x;
2011     zArg += 2;
2012     while( (x = hexDigitValue(zArg[0]))>=0 ){
2013       v = (v<<4) + x;
2014       zArg++;
2015     }
2016   }else{
2017     while( IsDigit(zArg[0]) ){
2018       v = v*10 + zArg[0] - '0';
2019       zArg++;
2020     }
2021   }
2022   for(i=0; i<ArraySize(aMult); i++){
2023     if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
2024       v *= aMult[i].iMult;
2025       break;
2026     }
2027   }
2028   return isNeg? -v : v;
2029 }
2030 
2031 /*
2032 ** Interpret zArg as either an integer or a boolean value.  Return 1 or 0
2033 ** for TRUE and FALSE.  Return the integer value if appropriate.
2034 */
2035 static int booleanValue(char *zArg){
2036   int i;
2037   if( zArg[0]=='0' && zArg[1]=='x' ){
2038     for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2039   }else{
2040     for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
2041   }
2042   if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
2043   if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
2044     return 1;
2045   }
2046   if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
2047     return 0;
2048   }
2049   fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2050           zArg);
2051   return 0;
2052 }
2053 
2054 /*
2055 ** Close an output file, assuming it is not stderr or stdout
2056 */
2057 static void output_file_close(FILE *f){
2058   if( f && f!=stdout && f!=stderr ) fclose(f);
2059 }
2060 
2061 /*
2062 ** Try to open an output file.   The names "stdout" and "stderr" are
2063 ** recognized and do the right thing.  NULL is returned if the output
2064 ** filename is "off".
2065 */
2066 static FILE *output_file_open(const char *zFile){
2067   FILE *f;
2068   if( strcmp(zFile,"stdout")==0 ){
2069     f = stdout;
2070   }else if( strcmp(zFile, "stderr")==0 ){
2071     f = stderr;
2072   }else if( strcmp(zFile, "off")==0 ){
2073     f = 0;
2074   }else{
2075     f = fopen(zFile, "wb");
2076     if( f==0 ){
2077       fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2078     }
2079   }
2080   return f;
2081 }
2082 
2083 /*
2084 ** A routine for handling output from sqlite3_trace().
2085 */
2086 static void sql_trace_callback(void *pArg, const char *z){
2087   FILE *f = (FILE*)pArg;
2088   if( f ){
2089     int i = (int)strlen(z);
2090     while( i>0 && z[i-1]==';' ){ i--; }
2091     fprintf(f, "%.*s;\n", i, z);
2092   }
2093 }
2094 
2095 /*
2096 ** A no-op routine that runs with the ".breakpoint" doc-command.  This is
2097 ** a useful spot to set a debugger breakpoint.
2098 */
2099 static void test_breakpoint(void){
2100   static int nCall = 0;
2101   nCall++;
2102 }
2103 
2104 /*
2105 ** An object used to read a CSV and other files for import.
2106 */
2107 typedef struct ImportCtx ImportCtx;
2108 struct ImportCtx {
2109   const char *zFile;  /* Name of the input file */
2110   FILE *in;           /* Read the CSV text from this input stream */
2111   char *z;            /* Accumulated text for a field */
2112   int n;              /* Number of bytes in z */
2113   int nAlloc;         /* Space allocated for z[] */
2114   int nLine;          /* Current line number */
2115   int cTerm;          /* Character that terminated the most recent field */
2116   int cColSep;        /* The column separator character.  (Usually ",") */
2117   int cRowSep;        /* The row separator character.  (Usually "\n") */
2118 };
2119 
2120 /* Append a single byte to z[] */
2121 static void import_append_char(ImportCtx *p, int c){
2122   if( p->n+1>=p->nAlloc ){
2123     p->nAlloc += p->nAlloc + 100;
2124     p->z = sqlite3_realloc(p->z, p->nAlloc);
2125     if( p->z==0 ){
2126       fprintf(stderr, "out of memory\n");
2127       exit(1);
2128     }
2129   }
2130   p->z[p->n++] = (char)c;
2131 }
2132 
2133 /* Read a single field of CSV text.  Compatible with rfc4180 and extended
2134 ** with the option of having a separator other than ",".
2135 **
2136 **   +  Input comes from p->in.
2137 **   +  Store results in p->z of length p->n.  Space to hold p->z comes
2138 **      from sqlite3_malloc().
2139 **   +  Use p->cSep as the column separator.  The default is ",".
2140 **   +  Use p->rSep as the row separator.  The default is "\n".
2141 **   +  Keep track of the line number in p->nLine.
2142 **   +  Store the character that terminates the field in p->cTerm.  Store
2143 **      EOF on end-of-file.
2144 **   +  Report syntax errors on stderr
2145 */
2146 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
2147   int c;
2148   int cSep = p->cColSep;
2149   int rSep = p->cRowSep;
2150   p->n = 0;
2151   c = fgetc(p->in);
2152   if( c==EOF || seenInterrupt ){
2153     p->cTerm = EOF;
2154     return 0;
2155   }
2156   if( c=='"' ){
2157     int pc, ppc;
2158     int startLine = p->nLine;
2159     int cQuote = c;
2160     pc = ppc = 0;
2161     while( 1 ){
2162       c = fgetc(p->in);
2163       if( c==rSep ) p->nLine++;
2164       if( c==cQuote ){
2165         if( pc==cQuote ){
2166           pc = 0;
2167           continue;
2168         }
2169       }
2170       if( (c==cSep && pc==cQuote)
2171        || (c==rSep && pc==cQuote)
2172        || (c==rSep && pc=='\r' && ppc==cQuote)
2173        || (c==EOF && pc==cQuote)
2174       ){
2175         do{ p->n--; }while( p->z[p->n]!=cQuote );
2176         p->cTerm = c;
2177         break;
2178       }
2179       if( pc==cQuote && c!='\r' ){
2180         fprintf(stderr, "%s:%d: unescaped %c character\n",
2181                 p->zFile, p->nLine, cQuote);
2182       }
2183       if( c==EOF ){
2184         fprintf(stderr, "%s:%d: unterminated %c-quoted field\n",
2185                 p->zFile, startLine, cQuote);
2186         p->cTerm = c;
2187         break;
2188       }
2189       import_append_char(p, c);
2190       ppc = pc;
2191       pc = c;
2192     }
2193   }else{
2194     while( c!=EOF && c!=cSep && c!=rSep ){
2195       import_append_char(p, c);
2196       c = fgetc(p->in);
2197     }
2198     if( c==rSep ){
2199       p->nLine++;
2200       if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
2201     }
2202     p->cTerm = c;
2203   }
2204   if( p->z ) p->z[p->n] = 0;
2205   return p->z;
2206 }
2207 
2208 /* Read a single field of ASCII delimited text.
2209 **
2210 **   +  Input comes from p->in.
2211 **   +  Store results in p->z of length p->n.  Space to hold p->z comes
2212 **      from sqlite3_malloc().
2213 **   +  Use p->cSep as the column separator.  The default is "\x1F".
2214 **   +  Use p->rSep as the row separator.  The default is "\x1E".
2215 **   +  Keep track of the row number in p->nLine.
2216 **   +  Store the character that terminates the field in p->cTerm.  Store
2217 **      EOF on end-of-file.
2218 **   +  Report syntax errors on stderr
2219 */
2220 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
2221   int c;
2222   int cSep = p->cColSep;
2223   int rSep = p->cRowSep;
2224   p->n = 0;
2225   c = fgetc(p->in);
2226   if( c==EOF || seenInterrupt ){
2227     p->cTerm = EOF;
2228     return 0;
2229   }
2230   while( c!=EOF && c!=cSep && c!=rSep ){
2231     import_append_char(p, c);
2232     c = fgetc(p->in);
2233   }
2234   if( c==rSep ){
2235     p->nLine++;
2236   }
2237   p->cTerm = c;
2238   if( p->z ) p->z[p->n] = 0;
2239   return p->z;
2240 }
2241 
2242 /*
2243 ** Try to transfer data for table zTable.  If an error is seen while
2244 ** moving forward, try to go backwards.  The backwards movement won't
2245 ** work for WITHOUT ROWID tables.
2246 */
2247 static void tryToCloneData(
2248   ShellState *p,
2249   sqlite3 *newDb,
2250   const char *zTable
2251 ){
2252   sqlite3_stmt *pQuery = 0;
2253   sqlite3_stmt *pInsert = 0;
2254   char *zQuery = 0;
2255   char *zInsert = 0;
2256   int rc;
2257   int i, j, n;
2258   int nTable = (int)strlen(zTable);
2259   int k = 0;
2260   int cnt = 0;
2261   const int spinRate = 10000;
2262 
2263   zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
2264   rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2265   if( rc ){
2266     fprintf(stderr, "Error %d: %s on [%s]\n",
2267             sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2268             zQuery);
2269     goto end_data_xfer;
2270   }
2271   n = sqlite3_column_count(pQuery);
2272   zInsert = sqlite3_malloc(200 + nTable + n*3);
2273   if( zInsert==0 ){
2274     fprintf(stderr, "out of memory\n");
2275     goto end_data_xfer;
2276   }
2277   sqlite3_snprintf(200+nTable,zInsert,
2278                    "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
2279   i = (int)strlen(zInsert);
2280   for(j=1; j<n; j++){
2281     memcpy(zInsert+i, ",?", 2);
2282     i += 2;
2283   }
2284   memcpy(zInsert+i, ");", 3);
2285   rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
2286   if( rc ){
2287     fprintf(stderr, "Error %d: %s on [%s]\n",
2288             sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
2289             zQuery);
2290     goto end_data_xfer;
2291   }
2292   for(k=0; k<2; k++){
2293     while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2294       for(i=0; i<n; i++){
2295         switch( sqlite3_column_type(pQuery, i) ){
2296           case SQLITE_NULL: {
2297             sqlite3_bind_null(pInsert, i+1);
2298             break;
2299           }
2300           case SQLITE_INTEGER: {
2301             sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
2302             break;
2303           }
2304           case SQLITE_FLOAT: {
2305             sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
2306             break;
2307           }
2308           case SQLITE_TEXT: {
2309             sqlite3_bind_text(pInsert, i+1,
2310                              (const char*)sqlite3_column_text(pQuery,i),
2311                              -1, SQLITE_STATIC);
2312             break;
2313           }
2314           case SQLITE_BLOB: {
2315             sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
2316                                             sqlite3_column_bytes(pQuery,i),
2317                                             SQLITE_STATIC);
2318             break;
2319           }
2320         }
2321       } /* End for */
2322       rc = sqlite3_step(pInsert);
2323       if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
2324         fprintf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
2325                         sqlite3_errmsg(newDb));
2326       }
2327       sqlite3_reset(pInsert);
2328       cnt++;
2329       if( (cnt%spinRate)==0 ){
2330         printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
2331         fflush(stdout);
2332       }
2333     } /* End while */
2334     if( rc==SQLITE_DONE ) break;
2335     sqlite3_finalize(pQuery);
2336     sqlite3_free(zQuery);
2337     zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
2338                              zTable);
2339     rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2340     if( rc ){
2341       fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
2342       break;
2343     }
2344   } /* End for(k=0...) */
2345 
2346 end_data_xfer:
2347   sqlite3_finalize(pQuery);
2348   sqlite3_finalize(pInsert);
2349   sqlite3_free(zQuery);
2350   sqlite3_free(zInsert);
2351 }
2352 
2353 
2354 /*
2355 ** Try to transfer all rows of the schema that match zWhere.  For
2356 ** each row, invoke xForEach() on the object defined by that row.
2357 ** If an error is encountered while moving forward through the
2358 ** sqlite_master table, try again moving backwards.
2359 */
2360 static void tryToCloneSchema(
2361   ShellState *p,
2362   sqlite3 *newDb,
2363   const char *zWhere,
2364   void (*xForEach)(ShellState*,sqlite3*,const char*)
2365 ){
2366   sqlite3_stmt *pQuery = 0;
2367   char *zQuery = 0;
2368   int rc;
2369   const unsigned char *zName;
2370   const unsigned char *zSql;
2371   char *zErrMsg = 0;
2372 
2373   zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2374                            " WHERE %s", zWhere);
2375   rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2376   if( rc ){
2377     fprintf(stderr, "Error: (%d) %s on [%s]\n",
2378                     sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2379                     zQuery);
2380     goto end_schema_xfer;
2381   }
2382   while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2383     zName = sqlite3_column_text(pQuery, 0);
2384     zSql = sqlite3_column_text(pQuery, 1);
2385     printf("%s... ", zName); fflush(stdout);
2386     sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2387     if( zErrMsg ){
2388       fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2389       sqlite3_free(zErrMsg);
2390       zErrMsg = 0;
2391     }
2392     if( xForEach ){
2393       xForEach(p, newDb, (const char*)zName);
2394     }
2395     printf("done\n");
2396   }
2397   if( rc!=SQLITE_DONE ){
2398     sqlite3_finalize(pQuery);
2399     sqlite3_free(zQuery);
2400     zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2401                              " WHERE %s ORDER BY rowid DESC", zWhere);
2402     rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2403     if( rc ){
2404       fprintf(stderr, "Error: (%d) %s on [%s]\n",
2405                       sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2406                       zQuery);
2407       goto end_schema_xfer;
2408     }
2409     while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2410       zName = sqlite3_column_text(pQuery, 0);
2411       zSql = sqlite3_column_text(pQuery, 1);
2412       printf("%s... ", zName); fflush(stdout);
2413       sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2414       if( zErrMsg ){
2415         fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2416         sqlite3_free(zErrMsg);
2417         zErrMsg = 0;
2418       }
2419       if( xForEach ){
2420         xForEach(p, newDb, (const char*)zName);
2421       }
2422       printf("done\n");
2423     }
2424   }
2425 end_schema_xfer:
2426   sqlite3_finalize(pQuery);
2427   sqlite3_free(zQuery);
2428 }
2429 
2430 /*
2431 ** Open a new database file named "zNewDb".  Try to recover as much information
2432 ** as possible out of the main database (which might be corrupt) and write it
2433 ** into zNewDb.
2434 */
2435 static void tryToClone(ShellState *p, const char *zNewDb){
2436   int rc;
2437   sqlite3 *newDb = 0;
2438   if( access(zNewDb,0)==0 ){
2439     fprintf(stderr, "File \"%s\" already exists.\n", zNewDb);
2440     return;
2441   }
2442   rc = sqlite3_open(zNewDb, &newDb);
2443   if( rc ){
2444     fprintf(stderr, "Cannot create output database: %s\n",
2445             sqlite3_errmsg(newDb));
2446   }else{
2447     sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
2448     sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
2449     tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
2450     tryToCloneSchema(p, newDb, "type!='table'", 0);
2451     sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
2452     sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2453   }
2454   sqlite3_close(newDb);
2455 }
2456 
2457 /*
2458 ** Change the output file back to stdout
2459 */
2460 static void output_reset(ShellState *p){
2461   if( p->outfile[0]=='|' ){
2462 #ifndef SQLITE_OMIT_POPEN
2463     pclose(p->out);
2464 #endif
2465   }else{
2466     output_file_close(p->out);
2467   }
2468   p->outfile[0] = 0;
2469   p->out = stdout;
2470 }
2471 
2472 /*
2473 ** Run an SQL command and return the single integer result.
2474 */
2475 static int db_int(ShellState *p, const char *zSql){
2476   sqlite3_stmt *pStmt;
2477   int res = 0;
2478   sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2479   if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
2480     res = sqlite3_column_int(pStmt,0);
2481   }
2482   sqlite3_finalize(pStmt);
2483   return res;
2484 }
2485 
2486 /*
2487 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
2488 */
2489 unsigned int get2byteInt(unsigned char *a){
2490   return (a[0]<<8) + a[1];
2491 }
2492 unsigned int get4byteInt(unsigned char *a){
2493   return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
2494 }
2495 
2496 /*
2497 ** Implementation of the ".info" command.
2498 **
2499 ** Return 1 on error, 2 to exit, and 0 otherwise.
2500 */
2501 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
2502   static const struct { const char *zName; int ofst; } aField[] = {
2503      { "file change counter:",  24  },
2504      { "database page count:",  28  },
2505      { "freelist page count:",  36  },
2506      { "schema cookie:",        40  },
2507      { "schema format:",        44  },
2508      { "default cache size:",   48  },
2509      { "autovacuum top root:",  52  },
2510      { "incremental vacuum:",   64  },
2511      { "text encoding:",        56  },
2512      { "user version:",         60  },
2513      { "application id:",       68  },
2514      { "software version:",     96  },
2515   };
2516   static const struct { const char *zName; const char *zSql; } aQuery[] = {
2517      { "number of tables:",
2518        "SELECT count(*) FROM %s WHERE type='table'" },
2519      { "number of indexes:",
2520        "SELECT count(*) FROM %s WHERE type='index'" },
2521      { "number of triggers:",
2522        "SELECT count(*) FROM %s WHERE type='trigger'" },
2523      { "number of views:",
2524        "SELECT count(*) FROM %s WHERE type='view'" },
2525      { "schema size:",
2526        "SELECT total(length(sql)) FROM %s" },
2527   };
2528   sqlite3_file *pFile;
2529   int i;
2530   char *zSchemaTab;
2531   char *zDb = nArg>=2 ? azArg[1] : "main";
2532   unsigned char aHdr[100];
2533   open_db(p, 0);
2534   if( p->db==0 ) return 1;
2535   sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile);
2536   if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){
2537     return 1;
2538   }
2539   i = pFile->pMethods->xRead(pFile, aHdr, 100, 0);
2540   if( i!=SQLITE_OK ){
2541     fprintf(stderr, "unable to read database header\n");
2542     return 1;
2543   }
2544   i = get2byteInt(aHdr+16);
2545   if( i==1 ) i = 65536;
2546   fprintf(p->out, "%-20s %d\n", "database page size:", i);
2547   fprintf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
2548   fprintf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
2549   fprintf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
2550   for(i=0; i<sizeof(aField)/sizeof(aField[0]); i++){
2551     int ofst = aField[i].ofst;
2552     unsigned int val = get4byteInt(aHdr + ofst);
2553     fprintf(p->out, "%-20s %u", aField[i].zName, val);
2554     switch( ofst ){
2555       case 56: {
2556         if( val==1 ) fprintf(p->out, " (utf8)");
2557         if( val==2 ) fprintf(p->out, " (utf16le)");
2558         if( val==3 ) fprintf(p->out, " (utf16be)");
2559       }
2560     }
2561     fprintf(p->out, "\n");
2562   }
2563   if( zDb==0 ){
2564     zSchemaTab = sqlite3_mprintf("main.sqlite_master");
2565   }else if( strcmp(zDb,"temp")==0 ){
2566     zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
2567   }else{
2568     zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
2569   }
2570   for(i=0; i<sizeof(aQuery)/sizeof(aQuery[0]); i++){
2571     char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
2572     int val = db_int(p, zSql);
2573     sqlite3_free(zSql);
2574     fprintf(p->out, "%-20s %d\n", aQuery[i].zName, val);
2575   }
2576   sqlite3_free(zSchemaTab);
2577   return 0;
2578 }
2579 
2580 
2581 /*
2582 ** If an input line begins with "." then invoke this routine to
2583 ** process that line.
2584 **
2585 ** Return 1 on error, 2 to exit, and 0 otherwise.
2586 */
2587 static int do_meta_command(char *zLine, ShellState *p){
2588   int i = 1;
2589   int nArg = 0;
2590   int n, c;
2591   int rc = 0;
2592   char *azArg[50];
2593 
2594   /* Parse the input line into tokens.
2595   */
2596   while( zLine[i] && nArg<ArraySize(azArg) ){
2597     while( IsSpace(zLine[i]) ){ i++; }
2598     if( zLine[i]==0 ) break;
2599     if( zLine[i]=='\'' || zLine[i]=='"' ){
2600       int delim = zLine[i++];
2601       azArg[nArg++] = &zLine[i];
2602       while( zLine[i] && zLine[i]!=delim ){
2603         if( zLine[i]=='\\' && delim=='"' && zLine[i+1]!=0 ) i++;
2604         i++;
2605       }
2606       if( zLine[i]==delim ){
2607         zLine[i++] = 0;
2608       }
2609       if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
2610     }else{
2611       azArg[nArg++] = &zLine[i];
2612       while( zLine[i] && !IsSpace(zLine[i]) ){ i++; }
2613       if( zLine[i] ) zLine[i++] = 0;
2614       resolve_backslashes(azArg[nArg-1]);
2615     }
2616   }
2617 
2618   /* Process the input line.
2619   */
2620   if( nArg==0 ) return 0; /* no tokens, no error */
2621   n = strlen30(azArg[0]);
2622   c = azArg[0][0];
2623   if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
2624    || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
2625   ){
2626     const char *zDestFile = 0;
2627     const char *zDb = 0;
2628     sqlite3 *pDest;
2629     sqlite3_backup *pBackup;
2630     int j;
2631     for(j=1; j<nArg; j++){
2632       const char *z = azArg[j];
2633       if( z[0]=='-' ){
2634         while( z[0]=='-' ) z++;
2635         /* No options to process at this time */
2636         {
2637           fprintf(stderr, "unknown option: %s\n", azArg[j]);
2638           return 1;
2639         }
2640       }else if( zDestFile==0 ){
2641         zDestFile = azArg[j];
2642       }else if( zDb==0 ){
2643         zDb = zDestFile;
2644         zDestFile = azArg[j];
2645       }else{
2646         fprintf(stderr, "too many arguments to .backup\n");
2647         return 1;
2648       }
2649     }
2650     if( zDestFile==0 ){
2651       fprintf(stderr, "missing FILENAME argument on .backup\n");
2652       return 1;
2653     }
2654     if( zDb==0 ) zDb = "main";
2655     rc = sqlite3_open(zDestFile, &pDest);
2656     if( rc!=SQLITE_OK ){
2657       fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
2658       sqlite3_close(pDest);
2659       return 1;
2660     }
2661     open_db(p, 0);
2662     pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
2663     if( pBackup==0 ){
2664       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2665       sqlite3_close(pDest);
2666       return 1;
2667     }
2668     while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
2669     sqlite3_backup_finish(pBackup);
2670     if( rc==SQLITE_DONE ){
2671       rc = 0;
2672     }else{
2673       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2674       rc = 1;
2675     }
2676     sqlite3_close(pDest);
2677   }else
2678 
2679   if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
2680     if( nArg==2 ){
2681       bail_on_error = booleanValue(azArg[1]);
2682     }else{
2683       fprintf(stderr, "Usage: .bail on|off\n");
2684       rc = 1;
2685     }
2686   }else
2687 
2688   /* The undocumented ".breakpoint" command causes a call to the no-op
2689   ** routine named test_breakpoint().
2690   */
2691   if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
2692     test_breakpoint();
2693   }else
2694 
2695   if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
2696     if( nArg==2 ){
2697       tryToClone(p, azArg[1]);
2698     }else{
2699       fprintf(stderr, "Usage: .clone FILENAME\n");
2700       rc = 1;
2701     }
2702   }else
2703 
2704   if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
2705     ShellState data;
2706     char *zErrMsg = 0;
2707     open_db(p, 0);
2708     memcpy(&data, p, sizeof(data));
2709     data.showHeader = 1;
2710     data.mode = MODE_Column;
2711     data.colWidth[0] = 3;
2712     data.colWidth[1] = 15;
2713     data.colWidth[2] = 58;
2714     data.cnt = 0;
2715     sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
2716     if( zErrMsg ){
2717       fprintf(stderr,"Error: %s\n", zErrMsg);
2718       sqlite3_free(zErrMsg);
2719       rc = 1;
2720     }
2721   }else
2722 
2723   if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
2724     rc = shell_dbinfo_command(p, nArg, azArg);
2725   }else
2726 
2727   if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
2728     open_db(p, 0);
2729     /* When playing back a "dump", the content might appear in an order
2730     ** which causes immediate foreign key constraints to be violated.
2731     ** So disable foreign-key constraint enforcement to prevent problems. */
2732     if( nArg!=1 && nArg!=2 ){
2733       fprintf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
2734       rc = 1;
2735       goto meta_command_exit;
2736     }
2737     fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
2738     fprintf(p->out, "BEGIN TRANSACTION;\n");
2739     p->writableSchema = 0;
2740     sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2741     p->nErr = 0;
2742     if( nArg==1 ){
2743       run_schema_dump_query(p,
2744         "SELECT name, type, sql FROM sqlite_master "
2745         "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2746       );
2747       run_schema_dump_query(p,
2748         "SELECT name, type, sql FROM sqlite_master "
2749         "WHERE name=='sqlite_sequence'"
2750       );
2751       run_table_dump_query(p,
2752         "SELECT sql FROM sqlite_master "
2753         "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2754       );
2755     }else{
2756       int i;
2757       for(i=1; i<nArg; i++){
2758         zShellStatic = azArg[i];
2759         run_schema_dump_query(p,
2760           "SELECT name, type, sql FROM sqlite_master "
2761           "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2762           "  AND sql NOT NULL");
2763         run_table_dump_query(p,
2764           "SELECT sql FROM sqlite_master "
2765           "WHERE sql NOT NULL"
2766           "  AND type IN ('index','trigger','view')"
2767           "  AND tbl_name LIKE shellstatic()", 0
2768         );
2769         zShellStatic = 0;
2770       }
2771     }
2772     if( p->writableSchema ){
2773       fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
2774       p->writableSchema = 0;
2775     }
2776     sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2777     sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
2778     fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
2779   }else
2780 
2781   if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
2782     if( nArg==2 ){
2783       p->echoOn = booleanValue(azArg[1]);
2784     }else{
2785       fprintf(stderr, "Usage: .echo on|off\n");
2786       rc = 1;
2787     }
2788   }else
2789 
2790   if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
2791     if( nArg==2 ){
2792       p->autoEQP = booleanValue(azArg[1]);
2793     }else{
2794       fprintf(stderr, "Usage: .eqp on|off\n");
2795       rc = 1;
2796     }
2797   }else
2798 
2799   if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
2800     if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
2801     rc = 2;
2802   }else
2803 
2804   if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
2805     int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
2806     if(val == 1) {
2807       if(!p->normalMode.valid) {
2808         p->normalMode.valid = 1;
2809         p->normalMode.mode = p->mode;
2810         p->normalMode.showHeader = p->showHeader;
2811         memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth));
2812       }
2813       /* We could put this code under the !p->explainValid
2814       ** condition so that it does not execute if we are already in
2815       ** explain mode. However, always executing it allows us an easy
2816       ** was to reset to explain mode in case the user previously
2817       ** did an .explain followed by a .width, .mode or .header
2818       ** command.
2819       */
2820       p->mode = MODE_Explain;
2821       p->showHeader = 1;
2822       memset(p->colWidth,0,sizeof(p->colWidth));
2823       p->colWidth[0] = 4;                  /* addr */
2824       p->colWidth[1] = 13;                 /* opcode */
2825       p->colWidth[2] = 4;                  /* P1 */
2826       p->colWidth[3] = 4;                  /* P2 */
2827       p->colWidth[4] = 4;                  /* P3 */
2828       p->colWidth[5] = 13;                 /* P4 */
2829       p->colWidth[6] = 2;                  /* P5 */
2830       p->colWidth[7] = 13;                  /* Comment */
2831     }else if (p->normalMode.valid) {
2832       p->normalMode.valid = 0;
2833       p->mode = p->normalMode.mode;
2834       p->showHeader = p->normalMode.showHeader;
2835       memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth));
2836     }
2837   }else
2838 
2839   if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
2840     ShellState data;
2841     char *zErrMsg = 0;
2842     int doStats = 0;
2843     if( nArg!=1 ){
2844       fprintf(stderr, "Usage: .fullschema\n");
2845       rc = 1;
2846       goto meta_command_exit;
2847     }
2848     open_db(p, 0);
2849     memcpy(&data, p, sizeof(data));
2850     data.showHeader = 0;
2851     data.mode = MODE_Semi;
2852     rc = sqlite3_exec(p->db,
2853        "SELECT sql FROM"
2854        "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2855        "     FROM sqlite_master UNION ALL"
2856        "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2857        "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
2858        "ORDER BY rowid",
2859        callback, &data, &zErrMsg
2860     );
2861     if( rc==SQLITE_OK ){
2862       sqlite3_stmt *pStmt;
2863       rc = sqlite3_prepare_v2(p->db,
2864                "SELECT rowid FROM sqlite_master"
2865                " WHERE name GLOB 'sqlite_stat[134]'",
2866                -1, &pStmt, 0);
2867       doStats = sqlite3_step(pStmt)==SQLITE_ROW;
2868       sqlite3_finalize(pStmt);
2869     }
2870     if( doStats==0 ){
2871       fprintf(p->out, "/* No STAT tables available */\n");
2872     }else{
2873       fprintf(p->out, "ANALYZE sqlite_master;\n");
2874       sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
2875                    callback, &data, &zErrMsg);
2876       data.mode = MODE_Insert;
2877       data.zDestTable = "sqlite_stat1";
2878       shell_exec(p->db, "SELECT * FROM sqlite_stat1",
2879                  shell_callback, &data,&zErrMsg);
2880       data.zDestTable = "sqlite_stat3";
2881       shell_exec(p->db, "SELECT * FROM sqlite_stat3",
2882                  shell_callback, &data,&zErrMsg);
2883       data.zDestTable = "sqlite_stat4";
2884       shell_exec(p->db, "SELECT * FROM sqlite_stat4",
2885                  shell_callback, &data, &zErrMsg);
2886       fprintf(p->out, "ANALYZE sqlite_master;\n");
2887     }
2888   }else
2889 
2890   if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
2891     if( nArg==2 ){
2892       p->showHeader = booleanValue(azArg[1]);
2893     }else{
2894       fprintf(stderr, "Usage: .headers on|off\n");
2895       rc = 1;
2896     }
2897   }else
2898 
2899   if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
2900     fprintf(p->out, "%s", zHelp);
2901   }else
2902 
2903   if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
2904     char *zTable;               /* Insert data into this table */
2905     char *zFile;                /* Name of file to extra content from */
2906     sqlite3_stmt *pStmt = NULL; /* A statement */
2907     int nCol;                   /* Number of columns in the table */
2908     int nByte;                  /* Number of bytes in an SQL string */
2909     int i, j;                   /* Loop counters */
2910     int needCommit;             /* True to COMMIT or ROLLBACK at end */
2911     int nSep;                   /* Number of bytes in p->colSeparator[] */
2912     char *zSql;                 /* An SQL statement */
2913     ImportCtx sCtx;             /* Reader context */
2914     char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
2915     int (SQLITE_CDECL *xCloser)(FILE*);      /* Func to close file */
2916 
2917     if( nArg!=3 ){
2918       fprintf(stderr, "Usage: .import FILE TABLE\n");
2919       goto meta_command_exit;
2920     }
2921     zFile = azArg[1];
2922     zTable = azArg[2];
2923     seenInterrupt = 0;
2924     memset(&sCtx, 0, sizeof(sCtx));
2925     open_db(p, 0);
2926     nSep = strlen30(p->colSeparator);
2927     if( nSep==0 ){
2928       fprintf(stderr, "Error: non-null column separator required for import\n");
2929       return 1;
2930     }
2931     if( nSep>1 ){
2932       fprintf(stderr, "Error: multi-character column separators not allowed"
2933                       " for import\n");
2934       return 1;
2935     }
2936     nSep = strlen30(p->rowSeparator);
2937     if( nSep==0 ){
2938       fprintf(stderr, "Error: non-null row separator required for import\n");
2939       return 1;
2940     }
2941     if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
2942       /* When importing CSV (only), if the row separator is set to the
2943       ** default output row separator, change it to the default input
2944       ** row separator.  This avoids having to maintain different input
2945       ** and output row separators. */
2946       sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
2947       nSep = strlen30(p->rowSeparator);
2948     }
2949     if( nSep>1 ){
2950       fprintf(stderr, "Error: multi-character row separators not allowed"
2951                       " for import\n");
2952       return 1;
2953     }
2954     sCtx.zFile = zFile;
2955     sCtx.nLine = 1;
2956     if( sCtx.zFile[0]=='|' ){
2957 #ifdef SQLITE_OMIT_POPEN
2958       fprintf(stderr, "Error: pipes are not supported in this OS\n");
2959       return 1;
2960 #else
2961       sCtx.in = popen(sCtx.zFile+1, "r");
2962       sCtx.zFile = "<pipe>";
2963       xCloser = pclose;
2964 #endif
2965     }else{
2966       sCtx.in = fopen(sCtx.zFile, "rb");
2967       xCloser = fclose;
2968     }
2969     if( p->mode==MODE_Ascii ){
2970       xRead = ascii_read_one_field;
2971     }else{
2972       xRead = csv_read_one_field;
2973     }
2974     if( sCtx.in==0 ){
2975       fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2976       return 1;
2977     }
2978     sCtx.cColSep = p->colSeparator[0];
2979     sCtx.cRowSep = p->rowSeparator[0];
2980     zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
2981     if( zSql==0 ){
2982       fprintf(stderr, "Error: out of memory\n");
2983       xCloser(sCtx.in);
2984       return 1;
2985     }
2986     nByte = strlen30(zSql);
2987     rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2988     import_append_char(&sCtx, 0);    /* To ensure sCtx.z is allocated */
2989     if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
2990       char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
2991       char cSep = '(';
2992       while( xRead(&sCtx) ){
2993         zCreate = sqlite3_mprintf("%z%c\n  \"%s\" TEXT", zCreate, cSep, sCtx.z);
2994         cSep = ',';
2995         if( sCtx.cTerm!=sCtx.cColSep ) break;
2996       }
2997       if( cSep=='(' ){
2998         sqlite3_free(zCreate);
2999         sqlite3_free(sCtx.z);
3000         xCloser(sCtx.in);
3001         fprintf(stderr,"%s: empty file\n", sCtx.zFile);
3002         return 1;
3003       }
3004       zCreate = sqlite3_mprintf("%z\n)", zCreate);
3005       rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
3006       sqlite3_free(zCreate);
3007       if( rc ){
3008         fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
3009                 sqlite3_errmsg(db));
3010         sqlite3_free(sCtx.z);
3011         xCloser(sCtx.in);
3012         return 1;
3013       }
3014       rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3015     }
3016     sqlite3_free(zSql);
3017     if( rc ){
3018       if (pStmt) sqlite3_finalize(pStmt);
3019       fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
3020       xCloser(sCtx.in);
3021       return 1;
3022     }
3023     nCol = sqlite3_column_count(pStmt);
3024     sqlite3_finalize(pStmt);
3025     pStmt = 0;
3026     if( nCol==0 ) return 0; /* no columns, no error */
3027     zSql = sqlite3_malloc( nByte*2 + 20 + nCol*2 );
3028     if( zSql==0 ){
3029       fprintf(stderr, "Error: out of memory\n");
3030       xCloser(sCtx.in);
3031       return 1;
3032     }
3033     sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
3034     j = strlen30(zSql);
3035     for(i=1; i<nCol; i++){
3036       zSql[j++] = ',';
3037       zSql[j++] = '?';
3038     }
3039     zSql[j++] = ')';
3040     zSql[j] = 0;
3041     rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3042     sqlite3_free(zSql);
3043     if( rc ){
3044       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
3045       if (pStmt) sqlite3_finalize(pStmt);
3046       xCloser(sCtx.in);
3047       return 1;
3048     }
3049     needCommit = sqlite3_get_autocommit(db);
3050     if( needCommit ) sqlite3_exec(db, "BEGIN", 0, 0, 0);
3051     do{
3052       int startLine = sCtx.nLine;
3053       for(i=0; i<nCol; i++){
3054         char *z = xRead(&sCtx);
3055         /*
3056         ** Did we reach end-of-file before finding any columns?
3057         ** If so, stop instead of NULL filling the remaining columns.
3058         */
3059         if( z==0 && i==0 ) break;
3060         /*
3061         ** Did we reach end-of-file OR end-of-line before finding any
3062         ** columns in ASCII mode?  If so, stop instead of NULL filling
3063         ** the remaining columns.
3064         */
3065         if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
3066         sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
3067         if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
3068           fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3069                           "filling the rest with NULL\n",
3070                           sCtx.zFile, startLine, nCol, i+1);
3071           i += 2;
3072           while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
3073         }
3074       }
3075       if( sCtx.cTerm==sCtx.cColSep ){
3076         do{
3077           xRead(&sCtx);
3078           i++;
3079         }while( sCtx.cTerm==sCtx.cColSep );
3080         fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3081                         "extras ignored\n",
3082                         sCtx.zFile, startLine, nCol, i);
3083       }
3084       if( i>=nCol ){
3085         sqlite3_step(pStmt);
3086         rc = sqlite3_reset(pStmt);
3087         if( rc!=SQLITE_OK ){
3088           fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, startLine,
3089                   sqlite3_errmsg(db));
3090         }
3091       }
3092     }while( sCtx.cTerm!=EOF );
3093 
3094     xCloser(sCtx.in);
3095     sqlite3_free(sCtx.z);
3096     sqlite3_finalize(pStmt);
3097     if( needCommit ) sqlite3_exec(db, "COMMIT", 0, 0, 0);
3098   }else
3099 
3100   if( c=='i' && (strncmp(azArg[0], "indices", n)==0
3101                  || strncmp(azArg[0], "indexes", n)==0) ){
3102     ShellState data;
3103     char *zErrMsg = 0;
3104     open_db(p, 0);
3105     memcpy(&data, p, sizeof(data));
3106     data.showHeader = 0;
3107     data.mode = MODE_List;
3108     if( nArg==1 ){
3109       rc = sqlite3_exec(p->db,
3110         "SELECT name FROM sqlite_master "
3111         "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
3112         "UNION ALL "
3113         "SELECT name FROM sqlite_temp_master "
3114         "WHERE type='index' "
3115         "ORDER BY 1",
3116         callback, &data, &zErrMsg
3117       );
3118     }else if( nArg==2 ){
3119       zShellStatic = azArg[1];
3120       rc = sqlite3_exec(p->db,
3121         "SELECT name FROM sqlite_master "
3122         "WHERE type='index' AND tbl_name LIKE shellstatic() "
3123         "UNION ALL "
3124         "SELECT name FROM sqlite_temp_master "
3125         "WHERE type='index' AND tbl_name LIKE shellstatic() "
3126         "ORDER BY 1",
3127         callback, &data, &zErrMsg
3128       );
3129       zShellStatic = 0;
3130     }else{
3131       fprintf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
3132       rc = 1;
3133       goto meta_command_exit;
3134     }
3135     if( zErrMsg ){
3136       fprintf(stderr,"Error: %s\n", zErrMsg);
3137       sqlite3_free(zErrMsg);
3138       rc = 1;
3139     }else if( rc != SQLITE_OK ){
3140       fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
3141       rc = 1;
3142     }
3143   }else
3144 
3145 #ifdef SQLITE_ENABLE_IOTRACE
3146   if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
3147     SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
3148     if( iotrace && iotrace!=stdout ) fclose(iotrace);
3149     iotrace = 0;
3150     if( nArg<2 ){
3151       sqlite3IoTrace = 0;
3152     }else if( strcmp(azArg[1], "-")==0 ){
3153       sqlite3IoTrace = iotracePrintf;
3154       iotrace = stdout;
3155     }else{
3156       iotrace = fopen(azArg[1], "w");
3157       if( iotrace==0 ){
3158         fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
3159         sqlite3IoTrace = 0;
3160         rc = 1;
3161       }else{
3162         sqlite3IoTrace = iotracePrintf;
3163       }
3164     }
3165   }else
3166 #endif
3167 
3168 #ifndef SQLITE_OMIT_LOAD_EXTENSION
3169   if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
3170     const char *zFile, *zProc;
3171     char *zErrMsg = 0;
3172     if( nArg<2 ){
3173       fprintf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
3174       rc = 1;
3175       goto meta_command_exit;
3176     }
3177     zFile = azArg[1];
3178     zProc = nArg>=3 ? azArg[2] : 0;
3179     open_db(p, 0);
3180     rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
3181     if( rc!=SQLITE_OK ){
3182       fprintf(stderr, "Error: %s\n", zErrMsg);
3183       sqlite3_free(zErrMsg);
3184       rc = 1;
3185     }
3186   }else
3187 #endif
3188 
3189   if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
3190     if( nArg!=2 ){
3191       fprintf(stderr, "Usage: .log FILENAME\n");
3192       rc = 1;
3193     }else{
3194       const char *zFile = azArg[1];
3195       output_file_close(p->pLog);
3196       p->pLog = output_file_open(zFile);
3197     }
3198   }else
3199 
3200   if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
3201     const char *zMode = nArg>=2 ? azArg[1] : "";
3202     int n2 = (int)strlen(zMode);
3203     int c2 = zMode[0];
3204     if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
3205       p->mode = MODE_Line;
3206     }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
3207       p->mode = MODE_Column;
3208     }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
3209       p->mode = MODE_List;
3210     }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
3211       p->mode = MODE_Html;
3212     }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
3213       p->mode = MODE_Tcl;
3214       sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
3215     }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
3216       p->mode = MODE_Csv;
3217       sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
3218       sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
3219     }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
3220       p->mode = MODE_List;
3221       sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
3222     }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
3223       p->mode = MODE_Insert;
3224       set_table_name(p, nArg>=3 ? azArg[2] : "table");
3225     }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
3226       p->mode = MODE_Ascii;
3227       sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
3228       sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
3229     }else {
3230       fprintf(stderr,"Error: mode should be one of: "
3231          "ascii column csv html insert line list tabs tcl\n");
3232       rc = 1;
3233     }
3234   }else
3235 
3236   if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
3237     if( nArg==2 ){
3238       sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
3239                        "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
3240     }else{
3241       fprintf(stderr, "Usage: .nullvalue STRING\n");
3242       rc = 1;
3243     }
3244   }else
3245 
3246   if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
3247     sqlite3 *savedDb = p->db;
3248     const char *zSavedFilename = p->zDbFilename;
3249     char *zNewFilename = 0;
3250     p->db = 0;
3251     if( nArg>=2 ){
3252       p->zDbFilename = zNewFilename = sqlite3_mprintf("%s", azArg[1]);
3253     }
3254     open_db(p, 1);
3255     if( p->db!=0 ){
3256       sqlite3_close(savedDb);
3257       sqlite3_free(p->zFreeOnClose);
3258       p->zFreeOnClose = zNewFilename;
3259     }else{
3260       sqlite3_free(zNewFilename);
3261       p->db = savedDb;
3262       p->zDbFilename = zSavedFilename;
3263     }
3264   }else
3265 
3266   if( c=='o'
3267    && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
3268   ){
3269     const char *zFile = nArg>=2 ? azArg[1] : "stdout";
3270     if( nArg>2 ){
3271       fprintf(stderr, "Usage: .%s FILE\n", azArg[0]);
3272       rc = 1;
3273       goto meta_command_exit;
3274     }
3275     if( n>1 && strncmp(azArg[0], "once", n)==0 ){
3276       if( nArg<2 ){
3277         fprintf(stderr, "Usage: .once FILE\n");
3278         rc = 1;
3279         goto meta_command_exit;
3280       }
3281       p->outCount = 2;
3282     }else{
3283       p->outCount = 0;
3284     }
3285     output_reset(p);
3286     if( zFile[0]=='|' ){
3287 #ifdef SQLITE_OMIT_POPEN
3288       fprintf(stderr,"Error: pipes are not supported in this OS\n");
3289       rc = 1;
3290       p->out = stdout;
3291 #else
3292       p->out = popen(zFile + 1, "w");
3293       if( p->out==0 ){
3294         fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
3295         p->out = stdout;
3296         rc = 1;
3297       }else{
3298         sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
3299       }
3300 #endif
3301     }else{
3302       p->out = output_file_open(zFile);
3303       if( p->out==0 ){
3304         if( strcmp(zFile,"off")!=0 ){
3305           fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile);
3306         }
3307         p->out = stdout;
3308         rc = 1;
3309       } else {
3310         sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
3311       }
3312     }
3313   }else
3314 
3315   if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
3316     int i;
3317     for(i=1; i<nArg; i++){
3318       if( i>1 ) fprintf(p->out, " ");
3319       fprintf(p->out, "%s", azArg[i]);
3320     }
3321     fprintf(p->out, "\n");
3322   }else
3323 
3324   if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
3325     if( nArg >= 2) {
3326       strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
3327     }
3328     if( nArg >= 3) {
3329       strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
3330     }
3331   }else
3332 
3333   if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
3334     rc = 2;
3335   }else
3336 
3337   if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
3338     FILE *alt;
3339     if( nArg!=2 ){
3340       fprintf(stderr, "Usage: .read FILE\n");
3341       rc = 1;
3342       goto meta_command_exit;
3343     }
3344     alt = fopen(azArg[1], "rb");
3345     if( alt==0 ){
3346       fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
3347       rc = 1;
3348     }else{
3349       rc = process_input(p, alt);
3350       fclose(alt);
3351     }
3352   }else
3353 
3354   if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
3355     const char *zSrcFile;
3356     const char *zDb;
3357     sqlite3 *pSrc;
3358     sqlite3_backup *pBackup;
3359     int nTimeout = 0;
3360 
3361     if( nArg==2 ){
3362       zSrcFile = azArg[1];
3363       zDb = "main";
3364     }else if( nArg==3 ){
3365       zSrcFile = azArg[2];
3366       zDb = azArg[1];
3367     }else{
3368       fprintf(stderr, "Usage: .restore ?DB? FILE\n");
3369       rc = 1;
3370       goto meta_command_exit;
3371     }
3372     rc = sqlite3_open(zSrcFile, &pSrc);
3373     if( rc!=SQLITE_OK ){
3374       fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
3375       sqlite3_close(pSrc);
3376       return 1;
3377     }
3378     open_db(p, 0);
3379     pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
3380     if( pBackup==0 ){
3381       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3382       sqlite3_close(pSrc);
3383       return 1;
3384     }
3385     while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
3386           || rc==SQLITE_BUSY  ){
3387       if( rc==SQLITE_BUSY ){
3388         if( nTimeout++ >= 3 ) break;
3389         sqlite3_sleep(100);
3390       }
3391     }
3392     sqlite3_backup_finish(pBackup);
3393     if( rc==SQLITE_DONE ){
3394       rc = 0;
3395     }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
3396       fprintf(stderr, "Error: source database is busy\n");
3397       rc = 1;
3398     }else{
3399       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3400       rc = 1;
3401     }
3402     sqlite3_close(pSrc);
3403   }else
3404 
3405 
3406   if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
3407     if( nArg==2 ){
3408       p->scanstatsOn = booleanValue(azArg[1]);
3409 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
3410       fprintf(stderr, "Warning: .scanstats not available in this build.\n");
3411 #endif
3412     }else{
3413       fprintf(stderr, "Usage: .scanstats on|off\n");
3414       rc = 1;
3415     }
3416   }else
3417 
3418   if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
3419     ShellState data;
3420     char *zErrMsg = 0;
3421     open_db(p, 0);
3422     memcpy(&data, p, sizeof(data));
3423     data.showHeader = 0;
3424     data.mode = MODE_Semi;
3425     if( nArg==2 ){
3426       int i;
3427       for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
3428       if( strcmp(azArg[1],"sqlite_master")==0 ){
3429         char *new_argv[2], *new_colv[2];
3430         new_argv[0] = "CREATE TABLE sqlite_master (\n"
3431                       "  type text,\n"
3432                       "  name text,\n"
3433                       "  tbl_name text,\n"
3434                       "  rootpage integer,\n"
3435                       "  sql text\n"
3436                       ")";
3437         new_argv[1] = 0;
3438         new_colv[0] = "sql";
3439         new_colv[1] = 0;
3440         callback(&data, 1, new_argv, new_colv);
3441         rc = SQLITE_OK;
3442       }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
3443         char *new_argv[2], *new_colv[2];
3444         new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
3445                       "  type text,\n"
3446                       "  name text,\n"
3447                       "  tbl_name text,\n"
3448                       "  rootpage integer,\n"
3449                       "  sql text\n"
3450                       ")";
3451         new_argv[1] = 0;
3452         new_colv[0] = "sql";
3453         new_colv[1] = 0;
3454         callback(&data, 1, new_argv, new_colv);
3455         rc = SQLITE_OK;
3456       }else{
3457         zShellStatic = azArg[1];
3458         rc = sqlite3_exec(p->db,
3459           "SELECT sql FROM "
3460           "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3461           "     FROM sqlite_master UNION ALL"
3462           "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3463           "WHERE lower(tbl_name) LIKE shellstatic()"
3464           "  AND type!='meta' AND sql NOTNULL "
3465           "ORDER BY rowid",
3466           callback, &data, &zErrMsg);
3467         zShellStatic = 0;
3468       }
3469     }else if( nArg==1 ){
3470       rc = sqlite3_exec(p->db,
3471          "SELECT sql FROM "
3472          "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3473          "     FROM sqlite_master UNION ALL"
3474          "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3475          "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
3476          "ORDER BY rowid",
3477          callback, &data, &zErrMsg
3478       );
3479     }else{
3480       fprintf(stderr, "Usage: .schema ?LIKE-PATTERN?\n");
3481       rc = 1;
3482       goto meta_command_exit;
3483     }
3484     if( zErrMsg ){
3485       fprintf(stderr,"Error: %s\n", zErrMsg);
3486       sqlite3_free(zErrMsg);
3487       rc = 1;
3488     }else if( rc != SQLITE_OK ){
3489       fprintf(stderr,"Error: querying schema information\n");
3490       rc = 1;
3491     }else{
3492       rc = 0;
3493     }
3494   }else
3495 
3496 
3497 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3498   if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
3499     extern int sqlite3SelectTrace;
3500     sqlite3SelectTrace = integerValue(azArg[1]);
3501   }else
3502 #endif
3503 
3504 
3505 #ifdef SQLITE_DEBUG
3506   /* Undocumented commands for internal testing.  Subject to change
3507   ** without notice. */
3508   if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
3509     if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
3510       int i, v;
3511       for(i=1; i<nArg; i++){
3512         v = booleanValue(azArg[i]);
3513         fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
3514       }
3515     }
3516     if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
3517       int i; sqlite3_int64 v;
3518       for(i=1; i<nArg; i++){
3519         char zBuf[200];
3520         v = integerValue(azArg[i]);
3521         sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
3522         fprintf(p->out, "%s", zBuf);
3523       }
3524     }
3525   }else
3526 #endif
3527 
3528   if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
3529     if( nArg<2 || nArg>3 ){
3530       fprintf(stderr, "Usage: .separator COL ?ROW?\n");
3531       rc = 1;
3532     }
3533     if( nArg>=2 ){
3534       sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
3535                        "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
3536     }
3537     if( nArg>=3 ){
3538       sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
3539                        "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
3540     }
3541   }else
3542 
3543   if( c=='s'
3544    && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
3545   ){
3546     char *zCmd;
3547     int i, x;
3548     if( nArg<2 ){
3549       fprintf(stderr, "Usage: .system COMMAND\n");
3550       rc = 1;
3551       goto meta_command_exit;
3552     }
3553     zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
3554     for(i=2; i<nArg; i++){
3555       zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
3556                              zCmd, azArg[i]);
3557     }
3558     x = system(zCmd);
3559     sqlite3_free(zCmd);
3560     if( x ) fprintf(stderr, "System command returns %d\n", x);
3561   }else
3562 
3563   if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
3564     int i;
3565     if( nArg!=1 ){
3566       fprintf(stderr, "Usage: .show\n");
3567       rc = 1;
3568       goto meta_command_exit;
3569     }
3570     fprintf(p->out,"%12.12s: %s\n","echo", p->echoOn ? "on" : "off");
3571     fprintf(p->out,"%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off");
3572     fprintf(p->out,"%9.9s: %s\n","explain", p->normalMode.valid ? "on" :"off");
3573     fprintf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off");
3574     fprintf(p->out,"%12.12s: %s\n","mode", modeDescr[p->mode]);
3575     fprintf(p->out,"%12.12s: ", "nullvalue");
3576       output_c_string(p->out, p->nullValue);
3577       fprintf(p->out, "\n");
3578     fprintf(p->out,"%12.12s: %s\n","output",
3579             strlen30(p->outfile) ? p->outfile : "stdout");
3580     fprintf(p->out,"%12.12s: ", "colseparator");
3581       output_c_string(p->out, p->colSeparator);
3582       fprintf(p->out, "\n");
3583     fprintf(p->out,"%12.12s: ", "rowseparator");
3584       output_c_string(p->out, p->rowSeparator);
3585       fprintf(p->out, "\n");
3586     fprintf(p->out,"%12.12s: %s\n","stats", p->statsOn ? "on" : "off");
3587     fprintf(p->out,"%12.12s: ","width");
3588     for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
3589       fprintf(p->out,"%d ",p->colWidth[i]);
3590     }
3591     fprintf(p->out,"\n");
3592   }else
3593 
3594   if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
3595     if( nArg==2 ){
3596       p->statsOn = booleanValue(azArg[1]);
3597     }else{
3598       fprintf(stderr, "Usage: .stats on|off\n");
3599       rc = 1;
3600     }
3601   }else
3602 
3603   if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
3604     sqlite3_stmt *pStmt;
3605     char **azResult;
3606     int nRow, nAlloc;
3607     char *zSql = 0;
3608     int ii;
3609     open_db(p, 0);
3610     rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
3611     if( rc ) return rc;
3612     zSql = sqlite3_mprintf(
3613         "SELECT name FROM sqlite_master"
3614         " WHERE type IN ('table','view')"
3615         "   AND name NOT LIKE 'sqlite_%%'"
3616         "   AND name LIKE ?1");
3617     while( sqlite3_step(pStmt)==SQLITE_ROW ){
3618       const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
3619       if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
3620       if( strcmp(zDbName,"temp")==0 ){
3621         zSql = sqlite3_mprintf(
3622                  "%z UNION ALL "
3623                  "SELECT 'temp.' || name FROM sqlite_temp_master"
3624                  " WHERE type IN ('table','view')"
3625                  "   AND name NOT LIKE 'sqlite_%%'"
3626                  "   AND name LIKE ?1", zSql);
3627       }else{
3628         zSql = sqlite3_mprintf(
3629                  "%z UNION ALL "
3630                  "SELECT '%q.' || name FROM \"%w\".sqlite_master"
3631                  " WHERE type IN ('table','view')"
3632                  "   AND name NOT LIKE 'sqlite_%%'"
3633                  "   AND name LIKE ?1", zSql, zDbName, zDbName);
3634       }
3635     }
3636     sqlite3_finalize(pStmt);
3637     zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
3638     rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3639     sqlite3_free(zSql);
3640     if( rc ) return rc;
3641     nRow = nAlloc = 0;
3642     azResult = 0;
3643     if( nArg>1 ){
3644       sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
3645     }else{
3646       sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
3647     }
3648     while( sqlite3_step(pStmt)==SQLITE_ROW ){
3649       if( nRow>=nAlloc ){
3650         char **azNew;
3651         int n = nAlloc*2 + 10;
3652         azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n);
3653         if( azNew==0 ){
3654           fprintf(stderr, "Error: out of memory\n");
3655           break;
3656         }
3657         nAlloc = n;
3658         azResult = azNew;
3659       }
3660       azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
3661       if( azResult[nRow] ) nRow++;
3662     }
3663     sqlite3_finalize(pStmt);
3664     if( nRow>0 ){
3665       int len, maxlen = 0;
3666       int i, j;
3667       int nPrintCol, nPrintRow;
3668       for(i=0; i<nRow; i++){
3669         len = strlen30(azResult[i]);
3670         if( len>maxlen ) maxlen = len;
3671       }
3672       nPrintCol = 80/(maxlen+2);
3673       if( nPrintCol<1 ) nPrintCol = 1;
3674       nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
3675       for(i=0; i<nPrintRow; i++){
3676         for(j=i; j<nRow; j+=nPrintRow){
3677           char *zSp = j<nPrintRow ? "" : "  ";
3678           fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");
3679         }
3680         fprintf(p->out, "\n");
3681       }
3682     }
3683     for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
3684     sqlite3_free(azResult);
3685   }else
3686 
3687   if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
3688     static const struct {
3689        const char *zCtrlName;   /* Name of a test-control option */
3690        int ctrlCode;            /* Integer code for that option */
3691     } aCtrl[] = {
3692       { "prng_save",             SQLITE_TESTCTRL_PRNG_SAVE              },
3693       { "prng_restore",          SQLITE_TESTCTRL_PRNG_RESTORE           },
3694       { "prng_reset",            SQLITE_TESTCTRL_PRNG_RESET             },
3695       { "bitvec_test",           SQLITE_TESTCTRL_BITVEC_TEST            },
3696       { "fault_install",         SQLITE_TESTCTRL_FAULT_INSTALL          },
3697       { "benign_malloc_hooks",   SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS    },
3698       { "pending_byte",          SQLITE_TESTCTRL_PENDING_BYTE           },
3699       { "assert",                SQLITE_TESTCTRL_ASSERT                 },
3700       { "always",                SQLITE_TESTCTRL_ALWAYS                 },
3701       { "reserve",               SQLITE_TESTCTRL_RESERVE                },
3702       { "optimizations",         SQLITE_TESTCTRL_OPTIMIZATIONS          },
3703       { "iskeyword",             SQLITE_TESTCTRL_ISKEYWORD              },
3704       { "scratchmalloc",         SQLITE_TESTCTRL_SCRATCHMALLOC          },
3705       { "byteorder",             SQLITE_TESTCTRL_BYTEORDER              },
3706       { "never_corrupt",         SQLITE_TESTCTRL_NEVER_CORRUPT          },
3707       { "imposter",              SQLITE_TESTCTRL_IMPOSTER               },
3708     };
3709     int testctrl = -1;
3710     int rc = 0;
3711     int i, n;
3712     open_db(p, 0);
3713 
3714     /* convert testctrl text option to value. allow any unique prefix
3715     ** of the option name, or a numerical value. */
3716     n = strlen30(azArg[1]);
3717     for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){
3718       if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){
3719         if( testctrl<0 ){
3720           testctrl = aCtrl[i].ctrlCode;
3721         }else{
3722           fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
3723           testctrl = -1;
3724           break;
3725         }
3726       }
3727     }
3728     if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
3729     if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
3730       fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
3731     }else{
3732       switch(testctrl){
3733 
3734         /* sqlite3_test_control(int, db, int) */
3735         case SQLITE_TESTCTRL_OPTIMIZATIONS:
3736         case SQLITE_TESTCTRL_RESERVE:
3737           if( nArg==3 ){
3738             int opt = (int)strtol(azArg[2], 0, 0);
3739             rc = sqlite3_test_control(testctrl, p->db, opt);
3740             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3741           } else {
3742             fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3743                     azArg[1]);
3744           }
3745           break;
3746 
3747         /* sqlite3_test_control(int) */
3748         case SQLITE_TESTCTRL_PRNG_SAVE:
3749         case SQLITE_TESTCTRL_PRNG_RESTORE:
3750         case SQLITE_TESTCTRL_PRNG_RESET:
3751         case SQLITE_TESTCTRL_BYTEORDER:
3752           if( nArg==2 ){
3753             rc = sqlite3_test_control(testctrl);
3754             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3755           } else {
3756             fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
3757           }
3758           break;
3759 
3760         /* sqlite3_test_control(int, uint) */
3761         case SQLITE_TESTCTRL_PENDING_BYTE:
3762           if( nArg==3 ){
3763             unsigned int opt = (unsigned int)integerValue(azArg[2]);
3764             rc = sqlite3_test_control(testctrl, opt);
3765             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3766           } else {
3767             fprintf(stderr,"Error: testctrl %s takes a single unsigned"
3768                            " int option\n", azArg[1]);
3769           }
3770           break;
3771 
3772         /* sqlite3_test_control(int, int) */
3773         case SQLITE_TESTCTRL_ASSERT:
3774         case SQLITE_TESTCTRL_ALWAYS:
3775         case SQLITE_TESTCTRL_NEVER_CORRUPT:
3776           if( nArg==3 ){
3777             int opt = booleanValue(azArg[2]);
3778             rc = sqlite3_test_control(testctrl, opt);
3779             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3780           } else {
3781             fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3782                             azArg[1]);
3783           }
3784           break;
3785 
3786         /* sqlite3_test_control(int, char *) */
3787 #ifdef SQLITE_N_KEYWORD
3788         case SQLITE_TESTCTRL_ISKEYWORD:
3789           if( nArg==3 ){
3790             const char *opt = azArg[2];
3791             rc = sqlite3_test_control(testctrl, opt);
3792             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3793           } else {
3794             fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
3795                             azArg[1]);
3796           }
3797           break;
3798 #endif
3799 
3800         case SQLITE_TESTCTRL_IMPOSTER:
3801           if( nArg==5 ){
3802             rc = sqlite3_test_control(testctrl, p->db,
3803                           azArg[2],
3804                           integerValue(azArg[3]),
3805                           integerValue(azArg[4]));
3806             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
3807           }else{
3808             fprintf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
3809           }
3810           break;
3811 
3812         case SQLITE_TESTCTRL_BITVEC_TEST:
3813         case SQLITE_TESTCTRL_FAULT_INSTALL:
3814         case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
3815         case SQLITE_TESTCTRL_SCRATCHMALLOC:
3816         default:
3817           fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
3818                   azArg[1]);
3819           break;
3820       }
3821     }
3822   }else
3823 
3824   if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
3825     open_db(p, 0);
3826     sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
3827   }else
3828 
3829   if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
3830     if( nArg==2 ){
3831       enableTimer = booleanValue(azArg[1]);
3832       if( enableTimer && !HAS_TIMER ){
3833         fprintf(stderr, "Error: timer not available on this system.\n");
3834         enableTimer = 0;
3835       }
3836     }else{
3837       fprintf(stderr, "Usage: .timer on|off\n");
3838       rc = 1;
3839     }
3840   }else
3841 
3842   if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
3843     open_db(p, 0);
3844     if( nArg!=2 ){
3845       fprintf(stderr, "Usage: .trace FILE|off\n");
3846       rc = 1;
3847       goto meta_command_exit;
3848     }
3849     output_file_close(p->traceOut);
3850     p->traceOut = output_file_open(azArg[1]);
3851 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
3852     if( p->traceOut==0 ){
3853       sqlite3_trace(p->db, 0, 0);
3854     }else{
3855       sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
3856     }
3857 #endif
3858   }else
3859 
3860 #if SQLITE_USER_AUTHENTICATION
3861   if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
3862     if( nArg<2 ){
3863       fprintf(stderr, "Usage: .user SUBCOMMAND ...\n");
3864       rc = 1;
3865       goto meta_command_exit;
3866     }
3867     open_db(p, 0);
3868     if( strcmp(azArg[1],"login")==0 ){
3869       if( nArg!=4 ){
3870         fprintf(stderr, "Usage: .user login USER PASSWORD\n");
3871         rc = 1;
3872         goto meta_command_exit;
3873       }
3874       rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
3875                                     (int)strlen(azArg[3]));
3876       if( rc ){
3877         fprintf(stderr, "Authentication failed for user %s\n", azArg[2]);
3878         rc = 1;
3879       }
3880     }else if( strcmp(azArg[1],"add")==0 ){
3881       if( nArg!=5 ){
3882         fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
3883         rc = 1;
3884         goto meta_command_exit;
3885       }
3886       rc = sqlite3_user_add(p->db, azArg[2],
3887                             azArg[3], (int)strlen(azArg[3]),
3888                             booleanValue(azArg[4]));
3889       if( rc ){
3890         fprintf(stderr, "User-Add failed: %d\n", rc);
3891         rc = 1;
3892       }
3893     }else if( strcmp(azArg[1],"edit")==0 ){
3894       if( nArg!=5 ){
3895         fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
3896         rc = 1;
3897         goto meta_command_exit;
3898       }
3899       rc = sqlite3_user_change(p->db, azArg[2],
3900                               azArg[3], (int)strlen(azArg[3]),
3901                               booleanValue(azArg[4]));
3902       if( rc ){
3903         fprintf(stderr, "User-Edit failed: %d\n", rc);
3904         rc = 1;
3905       }
3906     }else if( strcmp(azArg[1],"delete")==0 ){
3907       if( nArg!=3 ){
3908         fprintf(stderr, "Usage: .user delete USER\n");
3909         rc = 1;
3910         goto meta_command_exit;
3911       }
3912       rc = sqlite3_user_delete(p->db, azArg[2]);
3913       if( rc ){
3914         fprintf(stderr, "User-Delete failed: %d\n", rc);
3915         rc = 1;
3916       }
3917     }else{
3918       fprintf(stderr, "Usage: .user login|add|edit|delete ...\n");
3919       rc = 1;
3920       goto meta_command_exit;
3921     }
3922   }else
3923 #endif /* SQLITE_USER_AUTHENTICATION */
3924 
3925   if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
3926     fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
3927         sqlite3_libversion(), sqlite3_sourceid());
3928   }else
3929 
3930   if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
3931     const char *zDbName = nArg==2 ? azArg[1] : "main";
3932     char *zVfsName = 0;
3933     if( p->db ){
3934       sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
3935       if( zVfsName ){
3936         fprintf(p->out, "%s\n", zVfsName);
3937         sqlite3_free(zVfsName);
3938       }
3939     }
3940   }else
3941 
3942 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
3943   if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
3944     extern int sqlite3WhereTrace;
3945     sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
3946   }else
3947 #endif
3948 
3949   if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
3950     int j;
3951     assert( nArg<=ArraySize(azArg) );
3952     for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
3953       p->colWidth[j-1] = (int)integerValue(azArg[j]);
3954     }
3955   }else
3956 
3957   {
3958     fprintf(stderr, "Error: unknown command or invalid arguments: "
3959       " \"%s\". Enter \".help\" for help\n", azArg[0]);
3960     rc = 1;
3961   }
3962 
3963 meta_command_exit:
3964   if( p->outCount ){
3965     p->outCount--;
3966     if( p->outCount==0 ) output_reset(p);
3967   }
3968   return rc;
3969 }
3970 
3971 /*
3972 ** Return TRUE if a semicolon occurs anywhere in the first N characters
3973 ** of string z[].
3974 */
3975 static int line_contains_semicolon(const char *z, int N){
3976   int i;
3977   for(i=0; i<N; i++){  if( z[i]==';' ) return 1; }
3978   return 0;
3979 }
3980 
3981 /*
3982 ** Test to see if a line consists entirely of whitespace.
3983 */
3984 static int _all_whitespace(const char *z){
3985   for(; *z; z++){
3986     if( IsSpace(z[0]) ) continue;
3987     if( *z=='/' && z[1]=='*' ){
3988       z += 2;
3989       while( *z && (*z!='*' || z[1]!='/') ){ z++; }
3990       if( *z==0 ) return 0;
3991       z++;
3992       continue;
3993     }
3994     if( *z=='-' && z[1]=='-' ){
3995       z += 2;
3996       while( *z && *z!='\n' ){ z++; }
3997       if( *z==0 ) return 1;
3998       continue;
3999     }
4000     return 0;
4001   }
4002   return 1;
4003 }
4004 
4005 /*
4006 ** Return TRUE if the line typed in is an SQL command terminator other
4007 ** than a semi-colon.  The SQL Server style "go" command is understood
4008 ** as is the Oracle "/".
4009 */
4010 static int line_is_command_terminator(const char *zLine){
4011   while( IsSpace(zLine[0]) ){ zLine++; };
4012   if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
4013     return 1;  /* Oracle */
4014   }
4015   if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
4016          && _all_whitespace(&zLine[2]) ){
4017     return 1;  /* SQL Server */
4018   }
4019   return 0;
4020 }
4021 
4022 /*
4023 ** Return true if zSql is a complete SQL statement.  Return false if it
4024 ** ends in the middle of a string literal or C-style comment.
4025 */
4026 static int line_is_complete(char *zSql, int nSql){
4027   int rc;
4028   if( zSql==0 ) return 1;
4029   zSql[nSql] = ';';
4030   zSql[nSql+1] = 0;
4031   rc = sqlite3_complete(zSql);
4032   zSql[nSql] = 0;
4033   return rc;
4034 }
4035 
4036 /*
4037 ** Read input from *in and process it.  If *in==0 then input
4038 ** is interactive - the user is typing it it.  Otherwise, input
4039 ** is coming from a file or device.  A prompt is issued and history
4040 ** is saved only if input is interactive.  An interrupt signal will
4041 ** cause this routine to exit immediately, unless input is interactive.
4042 **
4043 ** Return the number of errors.
4044 */
4045 static int process_input(ShellState *p, FILE *in){
4046   char *zLine = 0;          /* A single input line */
4047   char *zSql = 0;           /* Accumulated SQL text */
4048   int nLine;                /* Length of current line */
4049   int nSql = 0;             /* Bytes of zSql[] used */
4050   int nAlloc = 0;           /* Allocated zSql[] space */
4051   int nSqlPrior = 0;        /* Bytes of zSql[] used by prior line */
4052   char *zErrMsg;            /* Error message returned */
4053   int rc;                   /* Error code */
4054   int errCnt = 0;           /* Number of errors seen */
4055   int lineno = 0;           /* Current line number */
4056   int startline = 0;        /* Line number for start of current input */
4057 
4058   while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
4059     fflush(p->out);
4060     zLine = one_input_line(in, zLine, nSql>0);
4061     if( zLine==0 ){
4062       /* End of input */
4063       if( stdin_is_interactive ) printf("\n");
4064       break;
4065     }
4066     if( seenInterrupt ){
4067       if( in!=0 ) break;
4068       seenInterrupt = 0;
4069     }
4070     lineno++;
4071     if( nSql==0 && _all_whitespace(zLine) ){
4072       if( p->echoOn ) printf("%s\n", zLine);
4073       continue;
4074     }
4075     if( zLine && zLine[0]=='.' && nSql==0 ){
4076       if( p->echoOn ) printf("%s\n", zLine);
4077       rc = do_meta_command(zLine, p);
4078       if( rc==2 ){ /* exit requested */
4079         break;
4080       }else if( rc ){
4081         errCnt++;
4082       }
4083       continue;
4084     }
4085     if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
4086       memcpy(zLine,";",2);
4087     }
4088     nLine = strlen30(zLine);
4089     if( nSql+nLine+2>=nAlloc ){
4090       nAlloc = nSql+nLine+100;
4091       zSql = realloc(zSql, nAlloc);
4092       if( zSql==0 ){
4093         fprintf(stderr, "Error: out of memory\n");
4094         exit(1);
4095       }
4096     }
4097     nSqlPrior = nSql;
4098     if( nSql==0 ){
4099       int i;
4100       for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
4101       assert( nAlloc>0 && zSql!=0 );
4102       memcpy(zSql, zLine+i, nLine+1-i);
4103       startline = lineno;
4104       nSql = nLine-i;
4105     }else{
4106       zSql[nSql++] = '\n';
4107       memcpy(zSql+nSql, zLine, nLine+1);
4108       nSql += nLine;
4109     }
4110     if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
4111                 && sqlite3_complete(zSql) ){
4112       p->cnt = 0;
4113       open_db(p, 0);
4114       BEGIN_TIMER;
4115       rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
4116       END_TIMER;
4117       if( rc || zErrMsg ){
4118         char zPrefix[100];
4119         if( in!=0 || !stdin_is_interactive ){
4120           sqlite3_snprintf(sizeof(zPrefix), zPrefix,
4121                            "Error: near line %d:", startline);
4122         }else{
4123           sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
4124         }
4125         if( zErrMsg!=0 ){
4126           fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
4127           sqlite3_free(zErrMsg);
4128           zErrMsg = 0;
4129         }else{
4130           fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
4131         }
4132         errCnt++;
4133       }
4134       nSql = 0;
4135       if( p->outCount ){
4136         output_reset(p);
4137         p->outCount = 0;
4138       }
4139     }else if( nSql && _all_whitespace(zSql) ){
4140       if( p->echoOn ) printf("%s\n", zSql);
4141       nSql = 0;
4142     }
4143   }
4144   if( nSql ){
4145     if( !_all_whitespace(zSql) ){
4146       fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
4147       errCnt++;
4148     }
4149     free(zSql);
4150   }
4151   free(zLine);
4152   return errCnt>0;
4153 }
4154 
4155 /*
4156 ** Return a pathname which is the user's home directory.  A
4157 ** 0 return indicates an error of some kind.
4158 */
4159 static char *find_home_dir(void){
4160   static char *home_dir = NULL;
4161   if( home_dir ) return home_dir;
4162 
4163 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
4164      && !defined(__RTP__) && !defined(_WRS_KERNEL)
4165   {
4166     struct passwd *pwent;
4167     uid_t uid = getuid();
4168     if( (pwent=getpwuid(uid)) != NULL) {
4169       home_dir = pwent->pw_dir;
4170     }
4171   }
4172 #endif
4173 
4174 #if defined(_WIN32_WCE)
4175   /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
4176    */
4177   home_dir = "/";
4178 #else
4179 
4180 #if defined(_WIN32) || defined(WIN32)
4181   if (!home_dir) {
4182     home_dir = getenv("USERPROFILE");
4183   }
4184 #endif
4185 
4186   if (!home_dir) {
4187     home_dir = getenv("HOME");
4188   }
4189 
4190 #if defined(_WIN32) || defined(WIN32)
4191   if (!home_dir) {
4192     char *zDrive, *zPath;
4193     int n;
4194     zDrive = getenv("HOMEDRIVE");
4195     zPath = getenv("HOMEPATH");
4196     if( zDrive && zPath ){
4197       n = strlen30(zDrive) + strlen30(zPath) + 1;
4198       home_dir = malloc( n );
4199       if( home_dir==0 ) return 0;
4200       sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
4201       return home_dir;
4202     }
4203     home_dir = "c:\\";
4204   }
4205 #endif
4206 
4207 #endif /* !_WIN32_WCE */
4208 
4209   if( home_dir ){
4210     int n = strlen30(home_dir) + 1;
4211     char *z = malloc( n );
4212     if( z ) memcpy(z, home_dir, n);
4213     home_dir = z;
4214   }
4215 
4216   return home_dir;
4217 }
4218 
4219 /*
4220 ** Read input from the file given by sqliterc_override.  Or if that
4221 ** parameter is NULL, take input from ~/.sqliterc
4222 **
4223 ** Returns the number of errors.
4224 */
4225 static void process_sqliterc(
4226   ShellState *p,                  /* Configuration data */
4227   const char *sqliterc_override   /* Name of config file. NULL to use default */
4228 ){
4229   char *home_dir = NULL;
4230   const char *sqliterc = sqliterc_override;
4231   char *zBuf = 0;
4232   FILE *in = NULL;
4233 
4234   if (sqliterc == NULL) {
4235     home_dir = find_home_dir();
4236     if( home_dir==0 ){
4237       fprintf(stderr, "-- warning: cannot find home directory;"
4238                       " cannot read ~/.sqliterc\n");
4239       return;
4240     }
4241     sqlite3_initialize();
4242     zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
4243     sqliterc = zBuf;
4244   }
4245   in = fopen(sqliterc,"rb");
4246   if( in ){
4247     if( stdin_is_interactive ){
4248       fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
4249     }
4250     process_input(p,in);
4251     fclose(in);
4252   }
4253   sqlite3_free(zBuf);
4254 }
4255 
4256 /*
4257 ** Show available command line options
4258 */
4259 static const char zOptions[] =
4260   "   -ascii               set output mode to 'ascii'\n"
4261   "   -bail                stop after hitting an error\n"
4262   "   -batch               force batch I/O\n"
4263   "   -column              set output mode to 'column'\n"
4264   "   -cmd COMMAND         run \"COMMAND\" before reading stdin\n"
4265   "   -csv                 set output mode to 'csv'\n"
4266   "   -echo                print commands before execution\n"
4267   "   -init FILENAME       read/process named file\n"
4268   "   -[no]header          turn headers on or off\n"
4269 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4270   "   -heap SIZE           Size of heap for memsys3 or memsys5\n"
4271 #endif
4272   "   -help                show this message\n"
4273   "   -html                set output mode to HTML\n"
4274   "   -interactive         force interactive I/O\n"
4275   "   -line                set output mode to 'line'\n"
4276   "   -list                set output mode to 'list'\n"
4277   "   -lookaside SIZE N    use N entries of SZ bytes for lookaside memory\n"
4278   "   -mmap N              default mmap size set to N\n"
4279 #ifdef SQLITE_ENABLE_MULTIPLEX
4280   "   -multiplex           enable the multiplexor VFS\n"
4281 #endif
4282   "   -newline SEP         set output row separator. Default: '\\n'\n"
4283   "   -nullvalue TEXT      set text string for NULL values. Default ''\n"
4284   "   -pagecache SIZE N    use N slots of SZ bytes each for page cache memory\n"
4285   "   -scratch SIZE N      use N slots of SZ bytes each for scratch memory\n"
4286   "   -separator SEP       set output column separator. Default: '|'\n"
4287   "   -stats               print memory stats before each finalize\n"
4288   "   -version             show SQLite version\n"
4289   "   -vfs NAME            use NAME as the default VFS\n"
4290 #ifdef SQLITE_ENABLE_VFSTRACE
4291   "   -vfstrace            enable tracing of all VFS calls\n"
4292 #endif
4293 ;
4294 static void usage(int showDetail){
4295   fprintf(stderr,
4296       "Usage: %s [OPTIONS] FILENAME [SQL]\n"
4297       "FILENAME is the name of an SQLite database. A new database is created\n"
4298       "if the file does not previously exist.\n", Argv0);
4299   if( showDetail ){
4300     fprintf(stderr, "OPTIONS include:\n%s", zOptions);
4301   }else{
4302     fprintf(stderr, "Use the -help option for additional information\n");
4303   }
4304   exit(1);
4305 }
4306 
4307 /*
4308 ** Initialize the state information in data
4309 */
4310 static void main_init(ShellState *data) {
4311   memset(data, 0, sizeof(*data));
4312   data->mode = MODE_List;
4313   memcpy(data->colSeparator,SEP_Column, 2);
4314   memcpy(data->rowSeparator,SEP_Row, 2);
4315   data->showHeader = 0;
4316   data->shellFlgs = SHFLG_Lookaside;
4317   sqlite3_config(SQLITE_CONFIG_URI, 1);
4318   sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
4319   sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
4320   sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
4321   sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");
4322 }
4323 
4324 /*
4325 ** Output text to the console in a font that attracts extra attention.
4326 */
4327 #ifdef _WIN32
4328 static void printBold(const char *zText){
4329   HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
4330   CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
4331   GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
4332   SetConsoleTextAttribute(out,
4333          FOREGROUND_RED|FOREGROUND_INTENSITY
4334   );
4335   printf("%s", zText);
4336   SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
4337 }
4338 #else
4339 static void printBold(const char *zText){
4340   printf("\033[1m%s\033[0m", zText);
4341 }
4342 #endif
4343 
4344 /*
4345 ** Get the argument to an --option.  Throw an error and die if no argument
4346 ** is available.
4347 */
4348 static char *cmdline_option_value(int argc, char **argv, int i){
4349   if( i==argc ){
4350     fprintf(stderr, "%s: Error: missing argument to %s\n",
4351             argv[0], argv[argc-1]);
4352     exit(1);
4353   }
4354   return argv[i];
4355 }
4356 
4357 int SQLITE_CDECL main(int argc, char **argv){
4358   char *zErrMsg = 0;
4359   ShellState data;
4360   const char *zInitFile = 0;
4361   int i;
4362   int rc = 0;
4363   int warnInmemoryDb = 0;
4364   int readStdin = 1;
4365   int nCmd = 0;
4366   char **azCmd = 0;
4367 
4368 #if USE_SYSTEM_SQLITE+0!=1
4369   if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
4370     fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
4371             sqlite3_sourceid(), SQLITE_SOURCE_ID);
4372     exit(1);
4373   }
4374 #endif
4375   setBinaryMode(stdin);
4376   setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
4377   Argv0 = argv[0];
4378   main_init(&data);
4379   stdin_is_interactive = isatty(0);
4380 
4381   /* Make sure we have a valid signal handler early, before anything
4382   ** else is done.
4383   */
4384 #ifdef SIGINT
4385   signal(SIGINT, interrupt_handler);
4386 #endif
4387 
4388 #ifdef SQLITE_SHELL_DBNAME_PROC
4389   {
4390     /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
4391     ** of a C-function that will provide the name of the database file.  Use
4392     ** this compile-time option to embed this shell program in larger
4393     ** applications. */
4394     extern void SQLITE_SHELL_DBNAME_PROC(const char**);
4395     SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
4396     warnInmemoryDb = 0;
4397   }
4398 #endif
4399 
4400   /* Do an initial pass through the command-line argument to locate
4401   ** the name of the database file, the name of the initialization file,
4402   ** the size of the alternative malloc heap,
4403   ** and the first command to execute.
4404   */
4405   for(i=1; i<argc; i++){
4406     char *z;
4407     z = argv[i];
4408     if( z[0]!='-' ){
4409       if( data.zDbFilename==0 ){
4410         data.zDbFilename = z;
4411       }else{
4412         /* Excesss arguments are interpreted as SQL (or dot-commands) and
4413         ** mean that nothing is read from stdin */
4414         readStdin = 0;
4415         nCmd++;
4416         azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
4417         if( azCmd==0 ){
4418           fprintf(stderr, "out of memory\n");
4419           exit(1);
4420         }
4421         azCmd[nCmd-1] = z;
4422       }
4423     }
4424     if( z[1]=='-' ) z++;
4425     if( strcmp(z,"-separator")==0
4426      || strcmp(z,"-nullvalue")==0
4427      || strcmp(z,"-newline")==0
4428      || strcmp(z,"-cmd")==0
4429     ){
4430       (void)cmdline_option_value(argc, argv, ++i);
4431     }else if( strcmp(z,"-init")==0 ){
4432       zInitFile = cmdline_option_value(argc, argv, ++i);
4433     }else if( strcmp(z,"-batch")==0 ){
4434       /* Need to check for batch mode here to so we can avoid printing
4435       ** informational messages (like from process_sqliterc) before
4436       ** we do the actual processing of arguments later in a second pass.
4437       */
4438       stdin_is_interactive = 0;
4439     }else if( strcmp(z,"-heap")==0 ){
4440 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4441       const char *zSize;
4442       sqlite3_int64 szHeap;
4443 
4444       zSize = cmdline_option_value(argc, argv, ++i);
4445       szHeap = integerValue(zSize);
4446       if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
4447       sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
4448 #endif
4449     }else if( strcmp(z,"-scratch")==0 ){
4450       int n, sz;
4451       sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4452       if( sz>400000 ) sz = 400000;
4453       if( sz<2500 ) sz = 2500;
4454       n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4455       if( n>10 ) n = 10;
4456       if( n<1 ) n = 1;
4457       sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n);
4458       data.shellFlgs |= SHFLG_Scratch;
4459     }else if( strcmp(z,"-pagecache")==0 ){
4460       int n, sz;
4461       sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4462       if( sz>70000 ) sz = 70000;
4463       if( sz<800 ) sz = 800;
4464       n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4465       if( n<10 ) n = 10;
4466       sqlite3_config(SQLITE_CONFIG_PAGECACHE, malloc(n*sz+1), sz, n);
4467       data.shellFlgs |= SHFLG_Pagecache;
4468     }else if( strcmp(z,"-lookaside")==0 ){
4469       int n, sz;
4470       sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4471       if( sz<0 ) sz = 0;
4472       n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4473       if( n<0 ) n = 0;
4474       sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
4475       if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
4476 #ifdef SQLITE_ENABLE_VFSTRACE
4477     }else if( strcmp(z,"-vfstrace")==0 ){
4478       extern int vfstrace_register(
4479          const char *zTraceName,
4480          const char *zOldVfsName,
4481          int (*xOut)(const char*,void*),
4482          void *pOutArg,
4483          int makeDefault
4484       );
4485       vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
4486 #endif
4487 #ifdef SQLITE_ENABLE_MULTIPLEX
4488     }else if( strcmp(z,"-multiplex")==0 ){
4489       extern int sqlite3_multiple_initialize(const char*,int);
4490       sqlite3_multiplex_initialize(0, 1);
4491 #endif
4492     }else if( strcmp(z,"-mmap")==0 ){
4493       sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
4494       sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
4495     }else if( strcmp(z,"-vfs")==0 ){
4496       sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
4497       if( pVfs ){
4498         sqlite3_vfs_register(pVfs, 1);
4499       }else{
4500         fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
4501         exit(1);
4502       }
4503     }
4504   }
4505   if( data.zDbFilename==0 ){
4506 #ifndef SQLITE_OMIT_MEMORYDB
4507     data.zDbFilename = ":memory:";
4508     warnInmemoryDb = argc==1;
4509 #else
4510     fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
4511     return 1;
4512 #endif
4513   }
4514   data.out = stdout;
4515 
4516   /* Go ahead and open the database file if it already exists.  If the
4517   ** file does not exist, delay opening it.  This prevents empty database
4518   ** files from being created if a user mistypes the database name argument
4519   ** to the sqlite command-line tool.
4520   */
4521   if( access(data.zDbFilename, 0)==0 ){
4522     open_db(&data, 0);
4523   }
4524 
4525   /* Process the initialization file if there is one.  If no -init option
4526   ** is given on the command line, look for a file named ~/.sqliterc and
4527   ** try to process it.
4528   */
4529   process_sqliterc(&data,zInitFile);
4530 
4531   /* Make a second pass through the command-line argument and set
4532   ** options.  This second pass is delayed until after the initialization
4533   ** file is processed so that the command-line arguments will override
4534   ** settings in the initialization file.
4535   */
4536   for(i=1; i<argc; i++){
4537     char *z = argv[i];
4538     if( z[0]!='-' ) continue;
4539     if( z[1]=='-' ){ z++; }
4540     if( strcmp(z,"-init")==0 ){
4541       i++;
4542     }else if( strcmp(z,"-html")==0 ){
4543       data.mode = MODE_Html;
4544     }else if( strcmp(z,"-list")==0 ){
4545       data.mode = MODE_List;
4546     }else if( strcmp(z,"-line")==0 ){
4547       data.mode = MODE_Line;
4548     }else if( strcmp(z,"-column")==0 ){
4549       data.mode = MODE_Column;
4550     }else if( strcmp(z,"-csv")==0 ){
4551       data.mode = MODE_Csv;
4552       memcpy(data.colSeparator,",",2);
4553     }else if( strcmp(z,"-ascii")==0 ){
4554       data.mode = MODE_Ascii;
4555       sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
4556                        SEP_Unit);
4557       sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
4558                        SEP_Record);
4559     }else if( strcmp(z,"-separator")==0 ){
4560       sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
4561                        "%s",cmdline_option_value(argc,argv,++i));
4562     }else if( strcmp(z,"-newline")==0 ){
4563       sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
4564                        "%s",cmdline_option_value(argc,argv,++i));
4565     }else if( strcmp(z,"-nullvalue")==0 ){
4566       sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
4567                        "%s",cmdline_option_value(argc,argv,++i));
4568     }else if( strcmp(z,"-header")==0 ){
4569       data.showHeader = 1;
4570     }else if( strcmp(z,"-noheader")==0 ){
4571       data.showHeader = 0;
4572     }else if( strcmp(z,"-echo")==0 ){
4573       data.echoOn = 1;
4574     }else if( strcmp(z,"-eqp")==0 ){
4575       data.autoEQP = 1;
4576     }else if( strcmp(z,"-stats")==0 ){
4577       data.statsOn = 1;
4578     }else if( strcmp(z,"-scanstats")==0 ){
4579       data.scanstatsOn = 1;
4580     }else if( strcmp(z,"-bail")==0 ){
4581       bail_on_error = 1;
4582     }else if( strcmp(z,"-version")==0 ){
4583       printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
4584       return 0;
4585     }else if( strcmp(z,"-interactive")==0 ){
4586       stdin_is_interactive = 1;
4587     }else if( strcmp(z,"-batch")==0 ){
4588       stdin_is_interactive = 0;
4589     }else if( strcmp(z,"-heap")==0 ){
4590       i++;
4591     }else if( strcmp(z,"-scratch")==0 ){
4592       i+=2;
4593     }else if( strcmp(z,"-pagecache")==0 ){
4594       i+=2;
4595     }else if( strcmp(z,"-lookaside")==0 ){
4596       i+=2;
4597     }else if( strcmp(z,"-mmap")==0 ){
4598       i++;
4599     }else if( strcmp(z,"-vfs")==0 ){
4600       i++;
4601 #ifdef SQLITE_ENABLE_VFSTRACE
4602     }else if( strcmp(z,"-vfstrace")==0 ){
4603       i++;
4604 #endif
4605 #ifdef SQLITE_ENABLE_MULTIPLEX
4606     }else if( strcmp(z,"-multiplex")==0 ){
4607       i++;
4608 #endif
4609     }else if( strcmp(z,"-help")==0 ){
4610       usage(1);
4611     }else if( strcmp(z,"-cmd")==0 ){
4612       /* Run commands that follow -cmd first and separately from commands
4613       ** that simply appear on the command-line.  This seems goofy.  It would
4614       ** be better if all commands ran in the order that they appear.  But
4615       ** we retain the goofy behavior for historical compatibility. */
4616       if( i==argc-1 ) break;
4617       z = cmdline_option_value(argc,argv,++i);
4618       if( z[0]=='.' ){
4619         rc = do_meta_command(z, &data);
4620         if( rc && bail_on_error ) return rc==2 ? 0 : rc;
4621       }else{
4622         open_db(&data, 0);
4623         rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
4624         if( zErrMsg!=0 ){
4625           fprintf(stderr,"Error: %s\n", zErrMsg);
4626           if( bail_on_error ) return rc!=0 ? rc : 1;
4627         }else if( rc!=0 ){
4628           fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
4629           if( bail_on_error ) return rc;
4630         }
4631       }
4632     }else{
4633       fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
4634       fprintf(stderr,"Use -help for a list of options.\n");
4635       return 1;
4636     }
4637   }
4638 
4639   if( !readStdin ){
4640     /* Run all arguments that do not begin with '-' as if they were separate
4641     ** command-line inputs, except for the argToSkip argument which contains
4642     ** the database filename.
4643     */
4644     for(i=0; i<nCmd; i++){
4645       if( azCmd[i][0]=='.' ){
4646         rc = do_meta_command(azCmd[i], &data);
4647         if( rc ) return rc==2 ? 0 : rc;
4648       }else{
4649         open_db(&data, 0);
4650         rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
4651         if( zErrMsg!=0 ){
4652           fprintf(stderr,"Error: %s\n", zErrMsg);
4653           return rc!=0 ? rc : 1;
4654         }else if( rc!=0 ){
4655           fprintf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
4656           return rc;
4657         }
4658       }
4659     }
4660     free(azCmd);
4661   }else{
4662     /* Run commands received from standard input
4663     */
4664     if( stdin_is_interactive ){
4665       char *zHome;
4666       char *zHistory = 0;
4667       int nHistory;
4668       printf(
4669         "SQLite version %s %.19s\n" /*extra-version-info*/
4670         "Enter \".help\" for usage hints.\n",
4671         sqlite3_libversion(), sqlite3_sourceid()
4672       );
4673       if( warnInmemoryDb ){
4674         printf("Connected to a ");
4675         printBold("transient in-memory database");
4676         printf(".\nUse \".open FILENAME\" to reopen on a "
4677                "persistent database.\n");
4678       }
4679       zHome = find_home_dir();
4680       if( zHome ){
4681         nHistory = strlen30(zHome) + 20;
4682         if( (zHistory = malloc(nHistory))!=0 ){
4683           sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
4684         }
4685       }
4686       if( zHistory ) shell_read_history(zHistory);
4687       rc = process_input(&data, 0);
4688       if( zHistory ){
4689         shell_stifle_history(100);
4690         shell_write_history(zHistory);
4691         free(zHistory);
4692       }
4693     }else{
4694       rc = process_input(&data, stdin);
4695     }
4696   }
4697   set_table_name(&data, 0);
4698   if( data.db ){
4699     sqlite3_close(data.db);
4700   }
4701   sqlite3_free(data.zFreeOnClose);
4702   return rc;
4703 }
4704