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