src/third_party/sqlite/src/src/shell.c

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