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