sl@0: /*
sl@0: ** 2001 September 15
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This file contains code to implement the "sqlite" command line
sl@0: ** utility for accessing SQLite databases.
sl@0: **
sl@0: ** $Id: shell.c,v 1.185 2008/08/11 19:12:35 drh Exp $
sl@0: */
sl@0: #include <stdlib.h>
sl@0: #include <string.h>
sl@0: #include <stdio.h>
sl@0: #include <assert.h>
sl@0: #include "sqlite3.h"
sl@0: #include <ctype.h>
sl@0: #include <stdarg.h>
sl@0: 
sl@0: #if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)
sl@0: # include <signal.h>
sl@0: # include <pwd.h>
sl@0: # include <unistd.h>
sl@0: # include <sys/types.h>
sl@0: #endif
sl@0: 
sl@0: #ifdef __OS2__
sl@0: # include <unistd.h>
sl@0: #endif
sl@0: 
sl@0: #if defined(HAVE_READLINE) && HAVE_READLINE==1
sl@0: # include <readline/readline.h>
sl@0: # include <readline/history.h>
sl@0: #else
sl@0: # define readline(p) local_getline(p,stdin)
sl@0: # define add_history(X)
sl@0: # define read_history(X)
sl@0: # define write_history(X)
sl@0: # define stifle_history(X)
sl@0: #endif
sl@0: 
sl@0: #if defined(_WIN32) || defined(WIN32)
sl@0: # include <io.h>
sl@0: #else
sl@0: /* Make sure isatty() has a prototype.
sl@0: */
sl@0: extern int isatty();
sl@0: #endif
sl@0: 
sl@0: #if defined(_WIN32_WCE)
sl@0: /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
sl@0:  * thus we always assume that we have a console. That can be
sl@0:  * overridden with the -batch command line option.
sl@0:  */
sl@0: #define isatty(x) 1
sl@0: #endif
sl@0: 
sl@0: #if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)
sl@0: #include <sys/time.h>
sl@0: #include <sys/resource.h>
sl@0: 
sl@0: /* Saved resource information for the beginning of an operation */
sl@0: static struct rusage sBegin;
sl@0: 
sl@0: /* True if the timer is enabled */
sl@0: static int enableTimer = 0;
sl@0: 
sl@0: /*
sl@0: ** Begin timing an operation
sl@0: */
sl@0: static void beginTimer(void){
sl@0:   if( enableTimer ){
sl@0:     getrusage(RUSAGE_SELF, &sBegin);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /* Return the difference of two time_structs in seconds */
sl@0: static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
sl@0:   return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + 
sl@0:          (double)(pEnd->tv_sec - pStart->tv_sec);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Print the timing results.
sl@0: */
sl@0: static void endTimer(void){
sl@0:   if( enableTimer ){
sl@0:     struct rusage sEnd;
sl@0:     getrusage(RUSAGE_SELF, &sEnd);
sl@0:     printf("CPU Time: user %f sys %f\n",
sl@0:        timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
sl@0:        timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
sl@0:   }
sl@0: }
sl@0: #define BEGIN_TIMER beginTimer()
sl@0: #define END_TIMER endTimer()
sl@0: #define HAS_TIMER 1
sl@0: #else
sl@0: #define BEGIN_TIMER 
sl@0: #define END_TIMER
sl@0: #define HAS_TIMER 0
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** If the following flag is set, then command execution stops
sl@0: ** at an error if we are not interactive.
sl@0: */
sl@0: static int bail_on_error = 0;
sl@0: 
sl@0: /*
sl@0: ** Threat stdin as an interactive input if the following variable
sl@0: ** is true.  Otherwise, assume stdin is connected to a file or pipe.
sl@0: */
sl@0: static int stdin_is_interactive = 1;
sl@0: 
sl@0: /*
sl@0: ** The following is the open SQLite database.  We make a pointer
sl@0: ** to this database a static variable so that it can be accessed
sl@0: ** by the SIGINT handler to interrupt database processing.
sl@0: */
sl@0: static sqlite3 *db = 0;
sl@0: 
sl@0: /*
sl@0: ** True if an interrupt (Control-C) has been received.
sl@0: */
sl@0: static volatile int seenInterrupt = 0;
sl@0: 
sl@0: /*
sl@0: ** This is the name of our program. It is set in main(), used
sl@0: ** in a number of other places, mostly for error messages.
sl@0: */
sl@0: static char *Argv0;
sl@0: 
sl@0: /*
sl@0: ** Prompt strings. Initialized in main. Settable with
sl@0: **   .prompt main continue
sl@0: */
sl@0: static char mainPrompt[20];     /* First line prompt. default: "sqlite> "*/
sl@0: static char continuePrompt[20]; /* Continuation prompt. default: "   ...> " */
sl@0: 
sl@0: /*
sl@0: ** Write I/O traces to the following stream.
sl@0: */
sl@0: #ifdef SQLITE_ENABLE_IOTRACE
sl@0: static FILE *iotrace = 0;
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** This routine works like printf in that its first argument is a
sl@0: ** format string and subsequent arguments are values to be substituted
sl@0: ** in place of % fields.  The result of formatting this string
sl@0: ** is written to iotrace.
sl@0: */
sl@0: #ifdef SQLITE_ENABLE_IOTRACE
sl@0: static void iotracePrintf(const char *zFormat, ...){
sl@0:   va_list ap;
sl@0:   char *z;
sl@0:   if( iotrace==0 ) return;
sl@0:   va_start(ap, zFormat);
sl@0:   z = sqlite3_vmprintf(zFormat, ap);
sl@0:   va_end(ap);
sl@0:   fprintf(iotrace, "%s", z);
sl@0:   sqlite3_free(z);
sl@0: }
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Determines if a string is a number of not.
sl@0: */
sl@0: static int isNumber(const char *z, int *realnum){
sl@0:   if( *z=='-' || *z=='+' ) z++;
sl@0:   if( !isdigit(*z) ){
sl@0:     return 0;
sl@0:   }
sl@0:   z++;
sl@0:   if( realnum ) *realnum = 0;
sl@0:   while( isdigit(*z) ){ z++; }
sl@0:   if( *z=='.' ){
sl@0:     z++;
sl@0:     if( !isdigit(*z) ) return 0;
sl@0:     while( isdigit(*z) ){ z++; }
sl@0:     if( realnum ) *realnum = 1;
sl@0:   }
sl@0:   if( *z=='e' || *z=='E' ){
sl@0:     z++;
sl@0:     if( *z=='+' || *z=='-' ) z++;
sl@0:     if( !isdigit(*z) ) return 0;
sl@0:     while( isdigit(*z) ){ z++; }
sl@0:     if( realnum ) *realnum = 1;
sl@0:   }
sl@0:   return *z==0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** A global char* and an SQL function to access its current value 
sl@0: ** from within an SQL statement. This program used to use the 
sl@0: ** sqlite_exec_printf() API to substitue a string into an SQL statement.
sl@0: ** The correct way to do this with sqlite3 is to use the bind API, but
sl@0: ** since the shell is built around the callback paradigm it would be a lot
sl@0: ** of work. Instead just use this hack, which is quite harmless.
sl@0: */
sl@0: static const char *zShellStatic = 0;
sl@0: static void shellstaticFunc(
sl@0:   sqlite3_context *context,
sl@0:   int argc,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   assert( 0==argc );
sl@0:   assert( zShellStatic );
sl@0:   sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** This routine reads a line of text from FILE in, stores
sl@0: ** the text in memory obtained from malloc() and returns a pointer
sl@0: ** to the text.  NULL is returned at end of file, or if malloc()
sl@0: ** fails.
sl@0: **
sl@0: ** The interface is like "readline" but no command-line editing
sl@0: ** is done.
sl@0: */
sl@0: static char *local_getline(char *zPrompt, FILE *in){
sl@0:   char *zLine;
sl@0:   int nLine;
sl@0:   int n;
sl@0:   int eol;
sl@0: 
sl@0:   if( zPrompt && *zPrompt ){
sl@0:     printf("%s",zPrompt);
sl@0:     fflush(stdout);
sl@0:   }
sl@0:   nLine = 100;
sl@0:   zLine = malloc( nLine );
sl@0:   if( zLine==0 ) return 0;
sl@0:   n = 0;
sl@0:   eol = 0;
sl@0:   while( !eol ){
sl@0:     if( n+100>nLine ){
sl@0:       nLine = nLine*2 + 100;
sl@0:       zLine = realloc(zLine, nLine);
sl@0:       if( zLine==0 ) return 0;
sl@0:     }
sl@0:     if( fgets(&zLine[n], nLine - n, in)==0 ){
sl@0:       if( n==0 ){
sl@0:         free(zLine);
sl@0:         return 0;
sl@0:       }
sl@0:       zLine[n] = 0;
sl@0:       eol = 1;
sl@0:       break;
sl@0:     }
sl@0:     while( zLine[n] ){ n++; }
sl@0:     if( n>0 && zLine[n-1]=='\n' ){
sl@0:       n--;
sl@0:       zLine[n] = 0;
sl@0:       eol = 1;
sl@0:     }
sl@0:   }
sl@0:   zLine = realloc( zLine, n+1 );
sl@0:   return zLine;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Retrieve a single line of input text.
sl@0: **
sl@0: ** zPrior is a string of prior text retrieved.  If not the empty
sl@0: ** string, then issue a continuation prompt.
sl@0: */
sl@0: static char *one_input_line(const char *zPrior, FILE *in){
sl@0:   char *zPrompt;
sl@0:   char *zResult;
sl@0:   if( in!=0 ){
sl@0:     return local_getline(0, in);
sl@0:   }
sl@0:   if( zPrior && zPrior[0] ){
sl@0:     zPrompt = continuePrompt;
sl@0:   }else{
sl@0:     zPrompt = mainPrompt;
sl@0:   }
sl@0:   zResult = readline(zPrompt);
sl@0: #if defined(HAVE_READLINE) && HAVE_READLINE==1
sl@0:   if( zResult && *zResult ) add_history(zResult);
sl@0: #endif
sl@0:   return zResult;
sl@0: }
sl@0: 
sl@0: struct previous_mode_data {
sl@0:   int valid;        /* Is there legit data in here? */
sl@0:   int mode;
sl@0:   int showHeader;
sl@0:   int colWidth[100];
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** An pointer to an instance of this structure is passed from
sl@0: ** the main program to the callback.  This is used to communicate
sl@0: ** state and mode information.
sl@0: */
sl@0: struct callback_data {
sl@0:   sqlite3 *db;            /* The database */
sl@0:   int echoOn;            /* True to echo input commands */
sl@0:   int cnt;               /* Number of records displayed so far */
sl@0:   FILE *out;             /* Write results here */
sl@0:   int mode;              /* An output mode setting */
sl@0:   int writableSchema;    /* True if PRAGMA writable_schema=ON */
sl@0:   int showHeader;        /* True to show column names in List or Column mode */
sl@0:   char *zDestTable;      /* Name of destination table when MODE_Insert */
sl@0:   char separator[20];    /* Separator character for MODE_List */
sl@0:   int colWidth[100];     /* Requested width of each column when in column mode*/
sl@0:   int actualWidth[100];  /* Actual width of each column */
sl@0:   char nullvalue[20];    /* The text to print when a NULL comes back from
sl@0:                          ** the database */
sl@0:   struct previous_mode_data explainPrev;
sl@0:                          /* Holds the mode information just before
sl@0:                          ** .explain ON */
sl@0:   char outfile[FILENAME_MAX]; /* Filename for *out */
sl@0:   const char *zDbFilename;    /* name of the database file */
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** These are the allowed modes.
sl@0: */
sl@0: #define MODE_Line     0  /* One column per line.  Blank line between records */
sl@0: #define MODE_Column   1  /* One record per line in neat columns */
sl@0: #define MODE_List     2  /* One record per line with a separator */
sl@0: #define MODE_Semi     3  /* Same as MODE_List but append ";" to each line */
sl@0: #define MODE_Html     4  /* Generate an XHTML table */
sl@0: #define MODE_Insert   5  /* Generate SQL "insert" statements */
sl@0: #define MODE_Tcl      6  /* Generate ANSI-C or TCL quoted elements */
sl@0: #define MODE_Csv      7  /* Quote strings, numbers are plain */
sl@0: #define MODE_Explain  8  /* Like MODE_Column, but do not truncate data */
sl@0: 
sl@0: static const char *modeDescr[] = {
sl@0:   "line",
sl@0:   "column",
sl@0:   "list",
sl@0:   "semi",
sl@0:   "html",
sl@0:   "insert",
sl@0:   "tcl",
sl@0:   "csv",
sl@0:   "explain",
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** Number of elements in an array
sl@0: */
sl@0: #define ArraySize(X)  (sizeof(X)/sizeof(X[0]))
sl@0: 
sl@0: /*
sl@0: ** Output the given string as a quoted string using SQL quoting conventions.
sl@0: */
sl@0: static void output_quoted_string(FILE *out, const char *z){
sl@0:   int i;
sl@0:   int nSingle = 0;
sl@0:   for(i=0; z[i]; i++){
sl@0:     if( z[i]=='\'' ) nSingle++;
sl@0:   }
sl@0:   if( nSingle==0 ){
sl@0:     fprintf(out,"'%s'",z);
sl@0:   }else{
sl@0:     fprintf(out,"'");
sl@0:     while( *z ){
sl@0:       for(i=0; z[i] && z[i]!='\''; i++){}
sl@0:       if( i==0 ){
sl@0:         fprintf(out,"''");
sl@0:         z++;
sl@0:       }else if( z[i]=='\'' ){
sl@0:         fprintf(out,"%.*s''",i,z);
sl@0:         z += i+1;
sl@0:       }else{
sl@0:         fprintf(out,"%s",z);
sl@0:         break;
sl@0:       }
sl@0:     }
sl@0:     fprintf(out,"'");
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Output the given string as a quoted according to C or TCL quoting rules.
sl@0: */
sl@0: static void output_c_string(FILE *out, const char *z){
sl@0:   unsigned int c;
sl@0:   fputc('"', out);
sl@0:   while( (c = *(z++))!=0 ){
sl@0:     if( c=='\\' ){
sl@0:       fputc(c, out);
sl@0:       fputc(c, out);
sl@0:     }else if( c=='\t' ){
sl@0:       fputc('\\', out);
sl@0:       fputc('t', out);
sl@0:     }else if( c=='\n' ){
sl@0:       fputc('\\', out);
sl@0:       fputc('n', out);
sl@0:     }else if( c=='\r' ){
sl@0:       fputc('\\', out);
sl@0:       fputc('r', out);
sl@0:     }else if( !isprint(c) ){
sl@0:       fprintf(out, "\\%03o", c&0xff);
sl@0:     }else{
sl@0:       fputc(c, out);
sl@0:     }
sl@0:   }
sl@0:   fputc('"', out);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Output the given string with characters that are special to
sl@0: ** HTML escaped.
sl@0: */
sl@0: static void output_html_string(FILE *out, const char *z){
sl@0:   int i;
sl@0:   while( *z ){
sl@0:     for(i=0; z[i] && z[i]!='<' && z[i]!='&'; i++){}
sl@0:     if( i>0 ){
sl@0:       fprintf(out,"%.*s",i,z);
sl@0:     }
sl@0:     if( z[i]=='<' ){
sl@0:       fprintf(out,"&lt;");
sl@0:     }else if( z[i]=='&' ){
sl@0:       fprintf(out,"&amp;");
sl@0:     }else{
sl@0:       break;
sl@0:     }
sl@0:     z += i + 1;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** If a field contains any character identified by a 1 in the following
sl@0: ** array, then the string must be quoted for CSV.
sl@0: */
sl@0: static const char needCsvQuote[] = {
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 0, 1, 0, 0, 0, 0, 1,   0, 0, 0, 0, 0, 0, 0, 0, 
sl@0:   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
sl@0:   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
sl@0:   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
sl@0:   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
sl@0:   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 1, 
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0:   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** Output a single term of CSV.  Actually, p->separator is used for
sl@0: ** the separator, which may or may not be a comma.  p->nullvalue is
sl@0: ** the null value.  Strings are quoted using ANSI-C rules.  Numbers
sl@0: ** appear outside of quotes.
sl@0: */
sl@0: static void output_csv(struct callback_data *p, const char *z, int bSep){
sl@0:   FILE *out = p->out;
sl@0:   if( z==0 ){
sl@0:     fprintf(out,"%s",p->nullvalue);
sl@0:   }else{
sl@0:     int i;
sl@0:     int nSep = strlen(p->separator);
sl@0:     for(i=0; z[i]; i++){
sl@0:       if( needCsvQuote[((unsigned char*)z)[i]] 
sl@0:          || (z[i]==p->separator[0] && 
sl@0:              (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
sl@0:         i = 0;
sl@0:         break;
sl@0:       }
sl@0:     }
sl@0:     if( i==0 ){
sl@0:       putc('"', out);
sl@0:       for(i=0; z[i]; i++){
sl@0:         if( z[i]=='"' ) putc('"', out);
sl@0:         putc(z[i], out);
sl@0:       }
sl@0:       putc('"', out);
sl@0:     }else{
sl@0:       fprintf(out, "%s", z);
sl@0:     }
sl@0:   }
sl@0:   if( bSep ){
sl@0:     fprintf(p->out, "%s", p->separator);
sl@0:   }
sl@0: }
sl@0: 
sl@0: #ifdef SIGINT
sl@0: /*
sl@0: ** This routine runs when the user presses Ctrl-C
sl@0: */
sl@0: static void interrupt_handler(int NotUsed){
sl@0:   seenInterrupt = 1;
sl@0:   if( db ) sqlite3_interrupt(db);
sl@0: }
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** This is the callback routine that the SQLite library
sl@0: ** invokes for each row of a query result.
sl@0: */
sl@0: static int callback(void *pArg, int nArg, char **azArg, char **azCol){
sl@0:   int i;
sl@0:   struct callback_data *p = (struct callback_data*)pArg;
sl@0:   switch( p->mode ){
sl@0:     case MODE_Line: {
sl@0:       int w = 5;
sl@0:       if( azArg==0 ) break;
sl@0:       for(i=0; i<nArg; i++){
sl@0:         int len = strlen(azCol[i] ? azCol[i] : "");
sl@0:         if( len>w ) w = len;
sl@0:       }
sl@0:       if( p->cnt++>0 ) fprintf(p->out,"\n");
sl@0:       for(i=0; i<nArg; i++){
sl@0:         fprintf(p->out,"%*s = %s\n", w, azCol[i],
sl@0:                 azArg[i] ? azArg[i] : p->nullvalue);
sl@0:       }
sl@0:       break;
sl@0:     }
sl@0:     case MODE_Explain:
sl@0:     case MODE_Column: {
sl@0:       if( p->cnt++==0 ){
sl@0:         for(i=0; i<nArg; i++){
sl@0:           int w, n;
sl@0:           if( i<ArraySize(p->colWidth) ){
sl@0:             w = p->colWidth[i];
sl@0:           }else{
sl@0:             w = 0;
sl@0:           }
sl@0:           if( w<=0 ){
sl@0:             w = strlen(azCol[i] ? azCol[i] : "");
sl@0:             if( w<10 ) w = 10;
sl@0:             n = strlen(azArg && azArg[i] ? azArg[i] : p->nullvalue);
sl@0:             if( w<n ) w = n;
sl@0:           }
sl@0:           if( i<ArraySize(p->actualWidth) ){
sl@0:             p->actualWidth[i] = w;
sl@0:           }
sl@0:           if( p->showHeader ){
sl@0:             fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": "  ");
sl@0:           }
sl@0:         }
sl@0:         if( p->showHeader ){
sl@0:           for(i=0; i<nArg; i++){
sl@0:             int w;
sl@0:             if( i<ArraySize(p->actualWidth) ){
sl@0:                w = p->actualWidth[i];
sl@0:             }else{
sl@0:                w = 10;
sl@0:             }
sl@0:             fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
sl@0:                    "----------------------------------------------------------",
sl@0:                     i==nArg-1 ? "\n": "  ");
sl@0:           }
sl@0:         }
sl@0:       }
sl@0:       if( azArg==0 ) break;
sl@0:       for(i=0; i<nArg; i++){
sl@0:         int w;
sl@0:         if( i<ArraySize(p->actualWidth) ){
sl@0:            w = p->actualWidth[i];
sl@0:         }else{
sl@0:            w = 10;
sl@0:         }
sl@0:         if( p->mode==MODE_Explain && azArg[i] && strlen(azArg[i])>w ){
sl@0:           w = strlen(azArg[i]);
sl@0:         }
sl@0:         fprintf(p->out,"%-*.*s%s",w,w,
sl@0:             azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": "  ");
sl@0:       }
sl@0:       break;
sl@0:     }
sl@0:     case MODE_Semi:
sl@0:     case MODE_List: {
sl@0:       if( p->cnt++==0 && p->showHeader ){
sl@0:         for(i=0; i<nArg; i++){
sl@0:           fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
sl@0:         }
sl@0:       }
sl@0:       if( azArg==0 ) break;
sl@0:       for(i=0; i<nArg; i++){
sl@0:         char *z = azArg[i];
sl@0:         if( z==0 ) z = p->nullvalue;
sl@0:         fprintf(p->out, "%s", z);
sl@0:         if( i<nArg-1 ){
sl@0:           fprintf(p->out, "%s", p->separator);
sl@0:         }else if( p->mode==MODE_Semi ){
sl@0:           fprintf(p->out, ";\n");
sl@0:         }else{
sl@0:           fprintf(p->out, "\n");
sl@0:         }
sl@0:       }
sl@0:       break;
sl@0:     }
sl@0:     case MODE_Html: {
sl@0:       if( p->cnt++==0 && p->showHeader ){
sl@0:         fprintf(p->out,"<TR>");
sl@0:         for(i=0; i<nArg; i++){
sl@0:           fprintf(p->out,"<TH>%s</TH>",azCol[i]);
sl@0:         }
sl@0:         fprintf(p->out,"</TR>\n");
sl@0:       }
sl@0:       if( azArg==0 ) break;
sl@0:       fprintf(p->out,"<TR>");
sl@0:       for(i=0; i<nArg; i++){
sl@0:         fprintf(p->out,"<TD>");
sl@0:         output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
sl@0:         fprintf(p->out,"</TD>\n");
sl@0:       }
sl@0:       fprintf(p->out,"</TR>\n");
sl@0:       break;
sl@0:     }
sl@0:     case MODE_Tcl: {
sl@0:       if( p->cnt++==0 && p->showHeader ){
sl@0:         for(i=0; i<nArg; i++){
sl@0:           output_c_string(p->out,azCol[i] ? azCol[i] : "");
sl@0:           fprintf(p->out, "%s", p->separator);
sl@0:         }
sl@0:         fprintf(p->out,"\n");
sl@0:       }
sl@0:       if( azArg==0 ) break;
sl@0:       for(i=0; i<nArg; i++){
sl@0:         output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
sl@0:         fprintf(p->out, "%s", p->separator);
sl@0:       }
sl@0:       fprintf(p->out,"\n");
sl@0:       break;
sl@0:     }
sl@0:     case MODE_Csv: {
sl@0:       if( p->cnt++==0 && p->showHeader ){
sl@0:         for(i=0; i<nArg; i++){
sl@0:           output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
sl@0:         }
sl@0:         fprintf(p->out,"\n");
sl@0:       }
sl@0:       if( azArg==0 ) break;
sl@0:       for(i=0; i<nArg; i++){
sl@0:         output_csv(p, azArg[i], i<nArg-1);
sl@0:       }
sl@0:       fprintf(p->out,"\n");
sl@0:       break;
sl@0:     }
sl@0:     case MODE_Insert: {
sl@0:       if( azArg==0 ) break;
sl@0:       fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
sl@0:       for(i=0; i<nArg; i++){
sl@0:         char *zSep = i>0 ? ",": "";
sl@0:         if( azArg[i]==0 ){
sl@0:           fprintf(p->out,"%sNULL",zSep);
sl@0:         }else if( isNumber(azArg[i], 0) ){
sl@0:           fprintf(p->out,"%s%s",zSep, azArg[i]);
sl@0:         }else{
sl@0:           if( zSep[0] ) fprintf(p->out,"%s",zSep);
sl@0:           output_quoted_string(p->out, azArg[i]);
sl@0:         }
sl@0:       }
sl@0:       fprintf(p->out,");\n");
sl@0:       break;
sl@0:     }
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Set the destination table field of the callback_data structure to
sl@0: ** the name of the table given.  Escape any quote characters in the
sl@0: ** table name.
sl@0: */
sl@0: static void set_table_name(struct callback_data *p, const char *zName){
sl@0:   int i, n;
sl@0:   int needQuote;
sl@0:   char *z;
sl@0: 
sl@0:   if( p->zDestTable ){
sl@0:     free(p->zDestTable);
sl@0:     p->zDestTable = 0;
sl@0:   }
sl@0:   if( zName==0 ) return;
sl@0:   needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
sl@0:   for(i=n=0; zName[i]; i++, n++){
sl@0:     if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
sl@0:       needQuote = 1;
sl@0:       if( zName[i]=='\'' ) n++;
sl@0:     }
sl@0:   }
sl@0:   if( needQuote ) n += 2;
sl@0:   z = p->zDestTable = malloc( n+1 );
sl@0:   if( z==0 ){
sl@0:     fprintf(stderr,"Out of memory!\n");
sl@0:     exit(1);
sl@0:   }
sl@0:   n = 0;
sl@0:   if( needQuote ) z[n++] = '\'';
sl@0:   for(i=0; zName[i]; i++){
sl@0:     z[n++] = zName[i];
sl@0:     if( zName[i]=='\'' ) z[n++] = '\'';
sl@0:   }
sl@0:   if( needQuote ) z[n++] = '\'';
sl@0:   z[n] = 0;
sl@0: }
sl@0: 
sl@0: /* zIn is either a pointer to a NULL-terminated string in memory obtained
sl@0: ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
sl@0: ** added to zIn, and the result returned in memory obtained from malloc().
sl@0: ** zIn, if it was not NULL, is freed.
sl@0: **
sl@0: ** If the third argument, quote, is not '\0', then it is used as a 
sl@0: ** quote character for zAppend.
sl@0: */
sl@0: static char *appendText(char *zIn, char const *zAppend, char quote){
sl@0:   int len;
sl@0:   int i;
sl@0:   int nAppend = strlen(zAppend);
sl@0:   int nIn = (zIn?strlen(zIn):0);
sl@0: 
sl@0:   len = nAppend+nIn+1;
sl@0:   if( quote ){
sl@0:     len += 2;
sl@0:     for(i=0; i<nAppend; i++){
sl@0:       if( zAppend[i]==quote ) len++;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   zIn = (char *)realloc(zIn, len);
sl@0:   if( !zIn ){
sl@0:     return 0;
sl@0:   }
sl@0: 
sl@0:   if( quote ){
sl@0:     char *zCsr = &zIn[nIn];
sl@0:     *zCsr++ = quote;
sl@0:     for(i=0; i<nAppend; i++){
sl@0:       *zCsr++ = zAppend[i];
sl@0:       if( zAppend[i]==quote ) *zCsr++ = quote;
sl@0:     }
sl@0:     *zCsr++ = quote;
sl@0:     *zCsr++ = '\0';
sl@0:     assert( (zCsr-zIn)==len );
sl@0:   }else{
sl@0:     memcpy(&zIn[nIn], zAppend, nAppend);
sl@0:     zIn[len-1] = '\0';
sl@0:   }
sl@0: 
sl@0:   return zIn;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Execute a query statement that has a single result column.  Print
sl@0: ** that result column on a line by itself with a semicolon terminator.
sl@0: **
sl@0: ** This is used, for example, to show the schema of the database by
sl@0: ** querying the SQLITE_MASTER table.
sl@0: */
sl@0: static int run_table_dump_query(FILE *out, sqlite3 *db, const char *zSelect){
sl@0:   sqlite3_stmt *pSelect;
sl@0:   int rc;
sl@0:   rc = sqlite3_prepare(db, zSelect, -1, &pSelect, 0);
sl@0:   if( rc!=SQLITE_OK || !pSelect ){
sl@0:     return rc;
sl@0:   }
sl@0:   rc = sqlite3_step(pSelect);
sl@0:   while( rc==SQLITE_ROW ){
sl@0:     fprintf(out, "%s;\n", sqlite3_column_text(pSelect, 0));
sl@0:     rc = sqlite3_step(pSelect);
sl@0:   }
sl@0:   return sqlite3_finalize(pSelect);
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** This is a different callback routine used for dumping the database.
sl@0: ** Each row received by this callback consists of a table name,
sl@0: ** the table type ("index" or "table") and SQL to create the table.
sl@0: ** This routine should print text sufficient to recreate the table.
sl@0: */
sl@0: static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
sl@0:   int rc;
sl@0:   const char *zTable;
sl@0:   const char *zType;
sl@0:   const char *zSql;
sl@0:   struct callback_data *p = (struct callback_data *)pArg;
sl@0: 
sl@0:   if( nArg!=3 ) return 1;
sl@0:   zTable = azArg[0];
sl@0:   zType = azArg[1];
sl@0:   zSql = azArg[2];
sl@0:   
sl@0:   if( strcmp(zTable, "sqlite_sequence")==0 ){
sl@0:     fprintf(p->out, "DELETE FROM sqlite_sequence;\n");
sl@0:   }else if( strcmp(zTable, "sqlite_stat1")==0 ){
sl@0:     fprintf(p->out, "ANALYZE sqlite_master;\n");
sl@0:   }else if( strncmp(zTable, "sqlite_", 7)==0 ){
sl@0:     return 0;
sl@0:   }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
sl@0:     char *zIns;
sl@0:     if( !p->writableSchema ){
sl@0:       fprintf(p->out, "PRAGMA writable_schema=ON;\n");
sl@0:       p->writableSchema = 1;
sl@0:     }
sl@0:     zIns = sqlite3_mprintf(
sl@0:        "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
sl@0:        "VALUES('table','%q','%q',0,'%q');",
sl@0:        zTable, zTable, zSql);
sl@0:     fprintf(p->out, "%s\n", zIns);
sl@0:     sqlite3_free(zIns);
sl@0:     return 0;
sl@0:   }else{
sl@0:     fprintf(p->out, "%s;\n", zSql);
sl@0:   }
sl@0: 
sl@0:   if( strcmp(zType, "table")==0 ){
sl@0:     sqlite3_stmt *pTableInfo = 0;
sl@0:     char *zSelect = 0;
sl@0:     char *zTableInfo = 0;
sl@0:     char *zTmp = 0;
sl@0:    
sl@0:     zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
sl@0:     zTableInfo = appendText(zTableInfo, zTable, '"');
sl@0:     zTableInfo = appendText(zTableInfo, ");", 0);
sl@0: 
sl@0:     rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
sl@0:     if( zTableInfo ) free(zTableInfo);
sl@0:     if( rc!=SQLITE_OK || !pTableInfo ){
sl@0:       return 1;
sl@0:     }
sl@0: 
sl@0:     zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
sl@0:     zTmp = appendText(zTmp, zTable, '"');
sl@0:     if( zTmp ){
sl@0:       zSelect = appendText(zSelect, zTmp, '\'');
sl@0:     }
sl@0:     zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
sl@0:     rc = sqlite3_step(pTableInfo);
sl@0:     while( rc==SQLITE_ROW ){
sl@0:       const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
sl@0:       zSelect = appendText(zSelect, "quote(", 0);
sl@0:       zSelect = appendText(zSelect, zText, '"');
sl@0:       rc = sqlite3_step(pTableInfo);
sl@0:       if( rc==SQLITE_ROW ){
sl@0:         zSelect = appendText(zSelect, ") || ',' || ", 0);
sl@0:       }else{
sl@0:         zSelect = appendText(zSelect, ") ", 0);
sl@0:       }
sl@0:     }
sl@0:     rc = sqlite3_finalize(pTableInfo);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       if( zSelect ) free(zSelect);
sl@0:       return 1;
sl@0:     }
sl@0:     zSelect = appendText(zSelect, "|| ')' FROM  ", 0);
sl@0:     zSelect = appendText(zSelect, zTable, '"');
sl@0: 
sl@0:     rc = run_table_dump_query(p->out, p->db, zSelect);
sl@0:     if( rc==SQLITE_CORRUPT ){
sl@0:       zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
sl@0:       rc = run_table_dump_query(p->out, p->db, zSelect);
sl@0:     }
sl@0:     if( zSelect ) free(zSelect);
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Run zQuery.  Use dump_callback() as the callback routine so that
sl@0: ** the contents of the query are output as SQL statements.
sl@0: **
sl@0: ** If we get a SQLITE_CORRUPT error, rerun the query after appending
sl@0: ** "ORDER BY rowid DESC" to the end.
sl@0: */
sl@0: static int run_schema_dump_query(
sl@0:   struct callback_data *p, 
sl@0:   const char *zQuery,
sl@0:   char **pzErrMsg
sl@0: ){
sl@0:   int rc;
sl@0:   rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg);
sl@0:   if( rc==SQLITE_CORRUPT ){
sl@0:     char *zQ2;
sl@0:     int len = strlen(zQuery);
sl@0:     if( pzErrMsg ) sqlite3_free(*pzErrMsg);
sl@0:     zQ2 = malloc( len+100 );
sl@0:     if( zQ2==0 ) return rc;
sl@0:     sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery);
sl@0:     rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg);
sl@0:     free(zQ2);
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Text of a help message
sl@0: */
sl@0: static char zHelp[] =
sl@0:   ".bail ON|OFF           Stop after hitting an error.  Default OFF\n"
sl@0:   ".databases             List names and files of attached databases\n"
sl@0:   ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
sl@0:   ".echo ON|OFF           Turn command echo on or off\n"
sl@0:   ".exit                  Exit this program\n"
sl@0:   ".explain ON|OFF        Turn output mode suitable for EXPLAIN on or off.\n"
sl@0:   ".header(s) ON|OFF      Turn display of headers on or off\n"
sl@0:   ".help                  Show this message\n"
sl@0:   ".import FILE TABLE     Import data from FILE into TABLE\n"
sl@0:   ".indices TABLE         Show names of all indices on TABLE\n"
sl@0: #ifdef SQLITE_ENABLE_IOTRACE
sl@0:   ".iotrace FILE          Enable I/O diagnostic logging to FILE\n"
sl@0: #endif
sl@0: #ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0:   ".load FILE ?ENTRY?     Load an extension library\n"
sl@0: #endif
sl@0:   ".mode MODE ?TABLE?     Set output mode where MODE is one of:\n"
sl@0:   "                         csv      Comma-separated values\n"
sl@0:   "                         column   Left-aligned columns.  (See .width)\n"
sl@0:   "                         html     HTML <table> code\n"
sl@0:   "                         insert   SQL insert statements for TABLE\n"
sl@0:   "                         line     One value per line\n"
sl@0:   "                         list     Values delimited by .separator string\n"
sl@0:   "                         tabs     Tab-separated values\n"
sl@0:   "                         tcl      TCL list elements\n"
sl@0:   ".nullvalue STRING      Print STRING in place of NULL values\n"
sl@0:   ".output FILENAME       Send output to FILENAME\n"
sl@0:   ".output stdout         Send output to the screen\n"
sl@0:   ".prompt MAIN CONTINUE  Replace the standard prompts\n"
sl@0:   ".quit                  Exit this program\n"
sl@0:   ".read FILENAME         Execute SQL in FILENAME\n"
sl@0:   ".schema ?TABLE?        Show the CREATE statements\n"
sl@0:   ".separator STRING      Change separator used by output mode and .import\n"
sl@0:   ".show                  Show the current values for various settings\n"
sl@0:   ".tables ?PATTERN?      List names of tables matching a LIKE pattern\n"
sl@0:   ".timeout MS            Try opening locked tables for MS milliseconds\n"
sl@0: #if HAS_TIMER
sl@0:   ".timer ON|OFF          Turn the CPU timer measurement on or off\n"
sl@0: #endif
sl@0:   ".width NUM NUM ...     Set column widths for \"column\" mode\n"
sl@0: ;
sl@0: 
sl@0: /* Forward reference */
sl@0: static int process_input(struct callback_data *p, FILE *in);
sl@0: 
sl@0: /*
sl@0: ** Make sure the database is open.  If it is not, then open it.  If
sl@0: ** the database fails to open, print an error message and exit.
sl@0: */
sl@0: static void open_db(struct callback_data *p){
sl@0:   if( p->db==0 ){
sl@0:     sqlite3_open(p->zDbFilename, &p->db);
sl@0:     db = p->db;
sl@0:     if( db && sqlite3_errcode(db)==SQLITE_OK ){
sl@0:       sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
sl@0:           shellstaticFunc, 0, 0);
sl@0:     }
sl@0:     if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
sl@0:       fprintf(stderr,"Unable to open database \"%s\": %s\n", 
sl@0:           p->zDbFilename, sqlite3_errmsg(db));
sl@0:       exit(1);
sl@0:     }
sl@0: #ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0:     sqlite3_enable_load_extension(p->db, 1);
sl@0: #endif
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Do C-language style dequoting.
sl@0: **
sl@0: **    \t    -> tab
sl@0: **    \n    -> newline
sl@0: **    \r    -> carriage return
sl@0: **    \NNN  -> ascii character NNN in octal
sl@0: **    \\    -> backslash
sl@0: */
sl@0: static void resolve_backslashes(char *z){
sl@0:   int i, j, c;
sl@0:   for(i=j=0; (c = z[i])!=0; i++, j++){
sl@0:     if( c=='\\' ){
sl@0:       c = z[++i];
sl@0:       if( c=='n' ){
sl@0:         c = '\n';
sl@0:       }else if( c=='t' ){
sl@0:         c = '\t';
sl@0:       }else if( c=='r' ){
sl@0:         c = '\r';
sl@0:       }else if( c>='0' && c<='7' ){
sl@0:         c -= '0';
sl@0:         if( z[i+1]>='0' && z[i+1]<='7' ){
sl@0:           i++;
sl@0:           c = (c<<3) + z[i] - '0';
sl@0:           if( z[i+1]>='0' && z[i+1]<='7' ){
sl@0:             i++;
sl@0:             c = (c<<3) + z[i] - '0';
sl@0:           }
sl@0:         }
sl@0:       }
sl@0:     }
sl@0:     z[j] = c;
sl@0:   }
sl@0:   z[j] = 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Interpret zArg as a boolean value.  Return either 0 or 1.
sl@0: */
sl@0: static int booleanValue(char *zArg){
sl@0:   int val = atoi(zArg);
sl@0:   int j;
sl@0:   for(j=0; zArg[j]; j++){
sl@0:     zArg[j] = tolower(zArg[j]);
sl@0:   }
sl@0:   if( strcmp(zArg,"on")==0 ){
sl@0:     val = 1;
sl@0:   }else if( strcmp(zArg,"yes")==0 ){
sl@0:     val = 1;
sl@0:   }
sl@0:   return val;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** If an input line begins with "." then invoke this routine to
sl@0: ** process that line.
sl@0: **
sl@0: ** Return 1 on error, 2 to exit, and 0 otherwise.
sl@0: */
sl@0: static int do_meta_command(char *zLine, struct callback_data *p){
sl@0:   int i = 1;
sl@0:   int nArg = 0;
sl@0:   int n, c;
sl@0:   int rc = 0;
sl@0:   char *azArg[50];
sl@0: 
sl@0:   /* Parse the input line into tokens.
sl@0:   */
sl@0:   while( zLine[i] && nArg<ArraySize(azArg) ){
sl@0:     while( isspace((unsigned char)zLine[i]) ){ i++; }
sl@0:     if( zLine[i]==0 ) break;
sl@0:     if( zLine[i]=='\'' || zLine[i]=='"' ){
sl@0:       int delim = zLine[i++];
sl@0:       azArg[nArg++] = &zLine[i];
sl@0:       while( zLine[i] && zLine[i]!=delim ){ i++; }
sl@0:       if( zLine[i]==delim ){
sl@0:         zLine[i++] = 0;
sl@0:       }
sl@0:       if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
sl@0:     }else{
sl@0:       azArg[nArg++] = &zLine[i];
sl@0:       while( zLine[i] && !isspace((unsigned char)zLine[i]) ){ i++; }
sl@0:       if( zLine[i] ) zLine[i++] = 0;
sl@0:       resolve_backslashes(azArg[nArg-1]);
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Process the input line.
sl@0:   */
sl@0:   if( nArg==0 ) return rc;
sl@0:   n = strlen(azArg[0]);
sl@0:   c = azArg[0][0];
sl@0:   if( c=='b' && n>1 && strncmp(azArg[0], "bail", n)==0 && nArg>1 ){
sl@0:     bail_on_error = booleanValue(azArg[1]);
sl@0:   }else
sl@0: 
sl@0:   if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
sl@0:     struct callback_data data;
sl@0:     char *zErrMsg = 0;
sl@0:     open_db(p);
sl@0:     memcpy(&data, p, sizeof(data));
sl@0:     data.showHeader = 1;
sl@0:     data.mode = MODE_Column;
sl@0:     data.colWidth[0] = 3;
sl@0:     data.colWidth[1] = 15;
sl@0:     data.colWidth[2] = 58;
sl@0:     data.cnt = 0;
sl@0:     sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
sl@0:     if( zErrMsg ){
sl@0:       fprintf(stderr,"Error: %s\n", zErrMsg);
sl@0:       sqlite3_free(zErrMsg);
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
sl@0:     char *zErrMsg = 0;
sl@0:     open_db(p);
sl@0:     fprintf(p->out, "BEGIN TRANSACTION;\n");
sl@0:     p->writableSchema = 0;
sl@0:     sqlite3_exec(p->db, "PRAGMA writable_schema=ON", 0, 0, 0);
sl@0:     if( nArg==1 ){
sl@0:       run_schema_dump_query(p, 
sl@0:         "SELECT name, type, sql FROM sqlite_master "
sl@0:         "WHERE sql NOT NULL AND type=='table'", 0
sl@0:       );
sl@0:       run_table_dump_query(p->out, p->db,
sl@0:         "SELECT sql FROM sqlite_master "
sl@0:         "WHERE sql NOT NULL AND type IN ('index','trigger','view')"
sl@0:       );
sl@0:     }else{
sl@0:       int i;
sl@0:       for(i=1; i<nArg; i++){
sl@0:         zShellStatic = azArg[i];
sl@0:         run_schema_dump_query(p,
sl@0:           "SELECT name, type, sql FROM sqlite_master "
sl@0:           "WHERE tbl_name LIKE shellstatic() AND type=='table'"
sl@0:           "  AND sql NOT NULL", 0);
sl@0:         run_table_dump_query(p->out, p->db,
sl@0:           "SELECT sql FROM sqlite_master "
sl@0:           "WHERE sql NOT NULL"
sl@0:           "  AND type IN ('index','trigger','view')"
sl@0:           "  AND tbl_name LIKE shellstatic()"
sl@0:         );
sl@0:         zShellStatic = 0;
sl@0:       }
sl@0:     }
sl@0:     if( p->writableSchema ){
sl@0:       fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
sl@0:       p->writableSchema = 0;
sl@0:     }
sl@0:     sqlite3_exec(p->db, "PRAGMA writable_schema=OFF", 0, 0, 0);
sl@0:     if( zErrMsg ){
sl@0:       fprintf(stderr,"Error: %s\n", zErrMsg);
sl@0:       sqlite3_free(zErrMsg);
sl@0:     }else{
sl@0:       fprintf(p->out, "COMMIT;\n");
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 ){
sl@0:     p->echoOn = booleanValue(azArg[1]);
sl@0:   }else
sl@0: 
sl@0:   if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
sl@0:     rc = 2;
sl@0:   }else
sl@0: 
sl@0:   if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
sl@0:     int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
sl@0:     if(val == 1) {
sl@0:       if(!p->explainPrev.valid) {
sl@0:         p->explainPrev.valid = 1;
sl@0:         p->explainPrev.mode = p->mode;
sl@0:         p->explainPrev.showHeader = p->showHeader;
sl@0:         memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
sl@0:       }
sl@0:       /* We could put this code under the !p->explainValid
sl@0:       ** condition so that it does not execute if we are already in
sl@0:       ** explain mode. However, always executing it allows us an easy
sl@0:       ** was to reset to explain mode in case the user previously
sl@0:       ** did an .explain followed by a .width, .mode or .header
sl@0:       ** command.
sl@0:       */
sl@0:       p->mode = MODE_Explain;
sl@0:       p->showHeader = 1;
sl@0:       memset(p->colWidth,0,ArraySize(p->colWidth));
sl@0:       p->colWidth[0] = 4;                  /* addr */
sl@0:       p->colWidth[1] = 13;                 /* opcode */
sl@0:       p->colWidth[2] = 4;                  /* P1 */
sl@0:       p->colWidth[3] = 4;                  /* P2 */
sl@0:       p->colWidth[4] = 4;                  /* P3 */
sl@0:       p->colWidth[5] = 13;                 /* P4 */
sl@0:       p->colWidth[6] = 2;                  /* P5 */
sl@0:       p->colWidth[7] = 13;                  /* Comment */
sl@0:     }else if (p->explainPrev.valid) {
sl@0:       p->explainPrev.valid = 0;
sl@0:       p->mode = p->explainPrev.mode;
sl@0:       p->showHeader = p->explainPrev.showHeader;
sl@0:       memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
sl@0:                  strncmp(azArg[0], "headers", n)==0 )&& nArg>1 ){
sl@0:     p->showHeader = booleanValue(azArg[1]);
sl@0:   }else
sl@0: 
sl@0:   if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
sl@0:     fprintf(stderr,zHelp);
sl@0:   }else
sl@0: 
sl@0:   if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg>=3 ){
sl@0:     char *zTable = azArg[2];    /* Insert data into this table */
sl@0:     char *zFile = azArg[1];     /* The file from which to extract data */
sl@0:     sqlite3_stmt *pStmt;        /* A statement */
sl@0:     int rc;                     /* Result code */
sl@0:     int nCol;                   /* Number of columns in the table */
sl@0:     int nByte;                  /* Number of bytes in an SQL string */
sl@0:     int i, j;                   /* Loop counters */
sl@0:     int nSep;                   /* Number of bytes in p->separator[] */
sl@0:     char *zSql;                 /* An SQL statement */
sl@0:     char *zLine;                /* A single line of input from the file */
sl@0:     char **azCol;               /* zLine[] broken up into columns */
sl@0:     char *zCommit;              /* How to commit changes */   
sl@0:     FILE *in;                   /* The input file */
sl@0:     int lineno = 0;             /* Line number of input file */
sl@0: 
sl@0:     open_db(p);
sl@0:     nSep = strlen(p->separator);
sl@0:     if( nSep==0 ){
sl@0:       fprintf(stderr, "non-null separator required for import\n");
sl@0:       return 0;
sl@0:     }
sl@0:     zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
sl@0:     if( zSql==0 ) return 0;
sl@0:     nByte = strlen(zSql);
sl@0:     rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
sl@0:     sqlite3_free(zSql);
sl@0:     if( rc ){
sl@0:       fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
sl@0:       nCol = 0;
sl@0:       rc = 1;
sl@0:     }else{
sl@0:       nCol = sqlite3_column_count(pStmt);
sl@0:     }
sl@0:     sqlite3_finalize(pStmt);
sl@0:     if( nCol==0 ) return 0;
sl@0:     zSql = malloc( nByte + 20 + nCol*2 );
sl@0:     if( zSql==0 ) return 0;
sl@0:     sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable);
sl@0:     j = strlen(zSql);
sl@0:     for(i=1; i<nCol; i++){
sl@0:       zSql[j++] = ',';
sl@0:       zSql[j++] = '?';
sl@0:     }
sl@0:     zSql[j++] = ')';
sl@0:     zSql[j] = 0;
sl@0:     rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
sl@0:     free(zSql);
sl@0:     if( rc ){
sl@0:       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
sl@0:       sqlite3_finalize(pStmt);
sl@0:       return 1;
sl@0:     }
sl@0:     in = fopen(zFile, "rb");
sl@0:     if( in==0 ){
sl@0:       fprintf(stderr, "cannot open file: %s\n", zFile);
sl@0:       sqlite3_finalize(pStmt);
sl@0:       return 0;
sl@0:     }
sl@0:     azCol = malloc( sizeof(azCol[0])*(nCol+1) );
sl@0:     if( azCol==0 ){
sl@0:       fclose(in);
sl@0:       return 0;
sl@0:     }
sl@0:     sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
sl@0:     zCommit = "COMMIT";
sl@0:     while( (zLine = local_getline(0, in))!=0 ){
sl@0:       char *z;
sl@0:       i = 0;
sl@0:       lineno++;
sl@0:       azCol[0] = zLine;
sl@0:       for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){
sl@0:         if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){
sl@0:           *z = 0;
sl@0:           i++;
sl@0:           if( i<nCol ){
sl@0:             azCol[i] = &z[nSep];
sl@0:             z += nSep-1;
sl@0:           }
sl@0:         }
sl@0:       }
sl@0:       *z = 0;
sl@0:       if( i+1!=nCol ){
sl@0:         fprintf(stderr,"%s line %d: expected %d columns of data but found %d\n",
sl@0:            zFile, lineno, nCol, i+1);
sl@0:         zCommit = "ROLLBACK";
sl@0:         break;
sl@0:       }
sl@0:       for(i=0; i<nCol; i++){
sl@0:         sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
sl@0:       }
sl@0:       sqlite3_step(pStmt);
sl@0:       rc = sqlite3_reset(pStmt);
sl@0:       free(zLine);
sl@0:       if( rc!=SQLITE_OK ){
sl@0:         fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
sl@0:         zCommit = "ROLLBACK";
sl@0:         rc = 1;
sl@0:         break;
sl@0:       }
sl@0:     }
sl@0:     free(azCol);
sl@0:     fclose(in);
sl@0:     sqlite3_finalize(pStmt);
sl@0:     sqlite3_exec(p->db, zCommit, 0, 0, 0);
sl@0:   }else
sl@0: 
sl@0:   if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg>1 ){
sl@0:     struct callback_data data;
sl@0:     char *zErrMsg = 0;
sl@0:     open_db(p);
sl@0:     memcpy(&data, p, sizeof(data));
sl@0:     data.showHeader = 0;
sl@0:     data.mode = MODE_List;
sl@0:     zShellStatic = azArg[1];
sl@0:     sqlite3_exec(p->db,
sl@0:       "SELECT name FROM sqlite_master "
sl@0:       "WHERE type='index' AND tbl_name LIKE shellstatic() "
sl@0:       "UNION ALL "
sl@0:       "SELECT name FROM sqlite_temp_master "
sl@0:       "WHERE type='index' AND tbl_name LIKE shellstatic() "
sl@0:       "ORDER BY 1",
sl@0:       callback, &data, &zErrMsg
sl@0:     );
sl@0:     zShellStatic = 0;
sl@0:     if( zErrMsg ){
sl@0:       fprintf(stderr,"Error: %s\n", zErrMsg);
sl@0:       sqlite3_free(zErrMsg);
sl@0:     }
sl@0:   }else
sl@0: 
sl@0: #ifdef SQLITE_ENABLE_IOTRACE
sl@0:   if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
sl@0:     extern void (*sqlite3IoTrace)(const char*, ...);
sl@0:     if( iotrace && iotrace!=stdout ) fclose(iotrace);
sl@0:     iotrace = 0;
sl@0:     if( nArg<2 ){
sl@0:       sqlite3IoTrace = 0;
sl@0:     }else if( strcmp(azArg[1], "-")==0 ){
sl@0:       sqlite3IoTrace = iotracePrintf;
sl@0:       iotrace = stdout;
sl@0:     }else{
sl@0:       iotrace = fopen(azArg[1], "w");
sl@0:       if( iotrace==0 ){
sl@0:         fprintf(stderr, "cannot open \"%s\"\n", azArg[1]);
sl@0:         sqlite3IoTrace = 0;
sl@0:       }else{
sl@0:         sqlite3IoTrace = iotracePrintf;
sl@0:       }
sl@0:     }
sl@0:   }else
sl@0: #endif
sl@0: 
sl@0: #ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0:   if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
sl@0:     const char *zFile, *zProc;
sl@0:     char *zErrMsg = 0;
sl@0:     int rc;
sl@0:     zFile = azArg[1];
sl@0:     zProc = nArg>=3 ? azArg[2] : 0;
sl@0:     open_db(p);
sl@0:     rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       fprintf(stderr, "%s\n", zErrMsg);
sl@0:       sqlite3_free(zErrMsg);
sl@0:       rc = 1;
sl@0:     }
sl@0:   }else
sl@0: #endif
sl@0: 
sl@0:   if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg>=2 ){
sl@0:     int n2 = strlen(azArg[1]);
sl@0:     if( strncmp(azArg[1],"line",n2)==0
sl@0:         ||
sl@0:         strncmp(azArg[1],"lines",n2)==0 ){
sl@0:       p->mode = MODE_Line;
sl@0:     }else if( strncmp(azArg[1],"column",n2)==0
sl@0:               ||
sl@0:               strncmp(azArg[1],"columns",n2)==0 ){
sl@0:       p->mode = MODE_Column;
sl@0:     }else if( strncmp(azArg[1],"list",n2)==0 ){
sl@0:       p->mode = MODE_List;
sl@0:     }else if( strncmp(azArg[1],"html",n2)==0 ){
sl@0:       p->mode = MODE_Html;
sl@0:     }else if( strncmp(azArg[1],"tcl",n2)==0 ){
sl@0:       p->mode = MODE_Tcl;
sl@0:     }else if( strncmp(azArg[1],"csv",n2)==0 ){
sl@0:       p->mode = MODE_Csv;
sl@0:       sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
sl@0:     }else if( strncmp(azArg[1],"tabs",n2)==0 ){
sl@0:       p->mode = MODE_List;
sl@0:       sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
sl@0:     }else if( strncmp(azArg[1],"insert",n2)==0 ){
sl@0:       p->mode = MODE_Insert;
sl@0:       if( nArg>=3 ){
sl@0:         set_table_name(p, azArg[2]);
sl@0:       }else{
sl@0:         set_table_name(p, "table");
sl@0:       }
sl@0:     }else {
sl@0:       fprintf(stderr,"mode should be one of: "
sl@0:          "column csv html insert line list tabs tcl\n");
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
sl@0:     sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
sl@0:                      "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
sl@0:   }else
sl@0: 
sl@0:   if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
sl@0:     if( p->out!=stdout ){
sl@0:       fclose(p->out);
sl@0:     }
sl@0:     if( strcmp(azArg[1],"stdout")==0 ){
sl@0:       p->out = stdout;
sl@0:       sqlite3_snprintf(sizeof(p->outfile), p->outfile, "stdout");
sl@0:     }else{
sl@0:       p->out = fopen(azArg[1], "wb");
sl@0:       if( p->out==0 ){
sl@0:         fprintf(stderr,"can't write to \"%s\"\n", azArg[1]);
sl@0:         p->out = stdout;
sl@0:       } else {
sl@0:          sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
sl@0:       }
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
sl@0:     if( nArg >= 2) {
sl@0:       strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
sl@0:     }
sl@0:     if( nArg >= 3) {
sl@0:       strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
sl@0:     rc = 2;
sl@0:   }else
sl@0: 
sl@0:   if( c=='r' && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
sl@0:     FILE *alt = fopen(azArg[1], "rb");
sl@0:     if( alt==0 ){
sl@0:       fprintf(stderr,"can't open \"%s\"\n", azArg[1]);
sl@0:     }else{
sl@0:       process_input(p, alt);
sl@0:       fclose(alt);
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
sl@0:     struct callback_data data;
sl@0:     char *zErrMsg = 0;
sl@0:     open_db(p);
sl@0:     memcpy(&data, p, sizeof(data));
sl@0:     data.showHeader = 0;
sl@0:     data.mode = MODE_Semi;
sl@0:     if( nArg>1 ){
sl@0:       int i;
sl@0:       for(i=0; azArg[1][i]; i++) azArg[1][i] = tolower(azArg[1][i]);
sl@0:       if( strcmp(azArg[1],"sqlite_master")==0 ){
sl@0:         char *new_argv[2], *new_colv[2];
sl@0:         new_argv[0] = "CREATE TABLE sqlite_master (\n"
sl@0:                       "  type text,\n"
sl@0:                       "  name text,\n"
sl@0:                       "  tbl_name text,\n"
sl@0:                       "  rootpage integer,\n"
sl@0:                       "  sql text\n"
sl@0:                       ")";
sl@0:         new_argv[1] = 0;
sl@0:         new_colv[0] = "sql";
sl@0:         new_colv[1] = 0;
sl@0:         callback(&data, 1, new_argv, new_colv);
sl@0:       }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
sl@0:         char *new_argv[2], *new_colv[2];
sl@0:         new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
sl@0:                       "  type text,\n"
sl@0:                       "  name text,\n"
sl@0:                       "  tbl_name text,\n"
sl@0:                       "  rootpage integer,\n"
sl@0:                       "  sql text\n"
sl@0:                       ")";
sl@0:         new_argv[1] = 0;
sl@0:         new_colv[0] = "sql";
sl@0:         new_colv[1] = 0;
sl@0:         callback(&data, 1, new_argv, new_colv);
sl@0:       }else{
sl@0:         zShellStatic = azArg[1];
sl@0:         sqlite3_exec(p->db,
sl@0:           "SELECT sql FROM "
sl@0:           "  (SELECT * FROM sqlite_master UNION ALL"
sl@0:           "   SELECT * FROM sqlite_temp_master) "
sl@0:           "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL "
sl@0:           "ORDER BY substr(type,2,1), name",
sl@0:           callback, &data, &zErrMsg);
sl@0:         zShellStatic = 0;
sl@0:       }
sl@0:     }else{
sl@0:       sqlite3_exec(p->db,
sl@0:          "SELECT sql FROM "
sl@0:          "  (SELECT * FROM sqlite_master UNION ALL"
sl@0:          "   SELECT * FROM sqlite_temp_master) "
sl@0:          "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
sl@0:          "ORDER BY substr(type,2,1), name",
sl@0:          callback, &data, &zErrMsg
sl@0:       );
sl@0:     }
sl@0:     if( zErrMsg ){
sl@0:       fprintf(stderr,"Error: %s\n", zErrMsg);
sl@0:       sqlite3_free(zErrMsg);
sl@0:     }
sl@0:   }else
sl@0: 
sl@0:   if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
sl@0:     sqlite3_snprintf(sizeof(p->separator), p->separator,
sl@0:                      "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
sl@0:   }else
sl@0: 
sl@0:   if( c=='s' && strncmp(azArg[0], "show", n)==0){
sl@0:     int i;
sl@0:     fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
sl@0:     fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
sl@0:     fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
sl@0:     fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
sl@0:     fprintf(p->out,"%9.9s: ", "nullvalue");
sl@0:       output_c_string(p->out, p->nullvalue);
sl@0:       fprintf(p->out, "\n");
sl@0:     fprintf(p->out,"%9.9s: %s\n","output",
sl@0:                                  strlen(p->outfile) ? p->outfile : "stdout");
sl@0:     fprintf(p->out,"%9.9s: ", "separator");
sl@0:       output_c_string(p->out, p->separator);
sl@0:       fprintf(p->out, "\n");
sl@0:     fprintf(p->out,"%9.9s: ","width");
sl@0:     for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
sl@0:       fprintf(p->out,"%d ",p->colWidth[i]);
sl@0:     }
sl@0:     fprintf(p->out,"\n");
sl@0:   }else
sl@0: 
sl@0:   if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
sl@0:     char **azResult;
sl@0:     int nRow, rc;
sl@0:     char *zErrMsg;
sl@0:     open_db(p);
sl@0:     if( nArg==1 ){
sl@0:       rc = sqlite3_get_table(p->db,
sl@0:         "SELECT name FROM sqlite_master "
sl@0:         "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'"
sl@0:         "UNION ALL "
sl@0:         "SELECT name FROM sqlite_temp_master "
sl@0:         "WHERE type IN ('table','view') "
sl@0:         "ORDER BY 1",
sl@0:         &azResult, &nRow, 0, &zErrMsg
sl@0:       );
sl@0:     }else{
sl@0:       zShellStatic = azArg[1];
sl@0:       rc = sqlite3_get_table(p->db,
sl@0:         "SELECT name FROM sqlite_master "
sl@0:         "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' "
sl@0:         "UNION ALL "
sl@0:         "SELECT name FROM sqlite_temp_master "
sl@0:         "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' "
sl@0:         "ORDER BY 1",
sl@0:         &azResult, &nRow, 0, &zErrMsg
sl@0:       );
sl@0:       zShellStatic = 0;
sl@0:     }
sl@0:     if( zErrMsg ){
sl@0:       fprintf(stderr,"Error: %s\n", zErrMsg);
sl@0:       sqlite3_free(zErrMsg);
sl@0:     }
sl@0:     if( rc==SQLITE_OK ){
sl@0:       int len, maxlen = 0;
sl@0:       int i, j;
sl@0:       int nPrintCol, nPrintRow;
sl@0:       for(i=1; i<=nRow; i++){
sl@0:         if( azResult[i]==0 ) continue;
sl@0:         len = strlen(azResult[i]);
sl@0:         if( len>maxlen ) maxlen = len;
sl@0:       }
sl@0:       nPrintCol = 80/(maxlen+2);
sl@0:       if( nPrintCol<1 ) nPrintCol = 1;
sl@0:       nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
sl@0:       for(i=0; i<nPrintRow; i++){
sl@0:         for(j=i+1; j<=nRow; j+=nPrintRow){
sl@0:           char *zSp = j<=nPrintRow ? "" : "  ";
sl@0:           printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
sl@0:         }
sl@0:         printf("\n");
sl@0:       }
sl@0:     }else{
sl@0:       rc = 1;
sl@0:     }
sl@0:     sqlite3_free_table(azResult);
sl@0:   }else
sl@0: 
sl@0:   if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){
sl@0:     open_db(p);
sl@0:     sqlite3_busy_timeout(p->db, atoi(azArg[1]));
sl@0:   }else
sl@0:   
sl@0: #if HAS_TIMER  
sl@0:   if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg>1 ){
sl@0:     enableTimer = booleanValue(azArg[1]);
sl@0:   }else
sl@0: #endif
sl@0: 
sl@0:   if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
sl@0:     int j;
sl@0:     assert( nArg<=ArraySize(azArg) );
sl@0:     for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
sl@0:       p->colWidth[j-1] = atoi(azArg[j]);
sl@0:     }
sl@0:   }else
sl@0: 
sl@0: 
sl@0:   {
sl@0:     fprintf(stderr, "unknown command or invalid arguments: "
sl@0:       " \"%s\". Enter \".help\" for help\n", azArg[0]);
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return TRUE if a semicolon occurs anywhere in the first N characters
sl@0: ** of string z[].
sl@0: */
sl@0: static int _contains_semicolon(const char *z, int N){
sl@0:   int i;
sl@0:   for(i=0; i<N; i++){  if( z[i]==';' ) return 1; }
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Test to see if a line consists entirely of whitespace.
sl@0: */
sl@0: static int _all_whitespace(const char *z){
sl@0:   for(; *z; z++){
sl@0:     if( isspace(*(unsigned char*)z) ) continue;
sl@0:     if( *z=='/' && z[1]=='*' ){
sl@0:       z += 2;
sl@0:       while( *z && (*z!='*' || z[1]!='/') ){ z++; }
sl@0:       if( *z==0 ) return 0;
sl@0:       z++;
sl@0:       continue;
sl@0:     }
sl@0:     if( *z=='-' && z[1]=='-' ){
sl@0:       z += 2;
sl@0:       while( *z && *z!='\n' ){ z++; }
sl@0:       if( *z==0 ) return 1;
sl@0:       continue;
sl@0:     }
sl@0:     return 0;
sl@0:   }
sl@0:   return 1;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return TRUE if the line typed in is an SQL command terminator other
sl@0: ** than a semi-colon.  The SQL Server style "go" command is understood
sl@0: ** as is the Oracle "/".
sl@0: */
sl@0: static int _is_command_terminator(const char *zLine){
sl@0:   while( isspace(*(unsigned char*)zLine) ){ zLine++; };
sl@0:   if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1;  /* Oracle */
sl@0:   if( tolower(zLine[0])=='g' && tolower(zLine[1])=='o'
sl@0:          && _all_whitespace(&zLine[2]) ){
sl@0:     return 1;  /* SQL Server */
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Read input from *in and process it.  If *in==0 then input
sl@0: ** is interactive - the user is typing it it.  Otherwise, input
sl@0: ** is coming from a file or device.  A prompt is issued and history
sl@0: ** is saved only if input is interactive.  An interrupt signal will
sl@0: ** cause this routine to exit immediately, unless input is interactive.
sl@0: **
sl@0: ** Return the number of errors.
sl@0: */
sl@0: static int process_input(struct callback_data *p, FILE *in){
sl@0:   char *zLine = 0;
sl@0:   char *zSql = 0;
sl@0:   int nSql = 0;
sl@0:   int nSqlPrior = 0;
sl@0:   char *zErrMsg;
sl@0:   int rc;
sl@0:   int errCnt = 0;
sl@0:   int lineno = 0;
sl@0:   int startline = 0;
sl@0: 
sl@0:   while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
sl@0:     fflush(p->out);
sl@0:     free(zLine);
sl@0:     zLine = one_input_line(zSql, in);
sl@0:     if( zLine==0 ){
sl@0:       break;  /* We have reached EOF */
sl@0:     }
sl@0:     if( seenInterrupt ){
sl@0:       if( in!=0 ) break;
sl@0:       seenInterrupt = 0;
sl@0:     }
sl@0:     lineno++;
sl@0:     if( p->echoOn ) printf("%s\n", zLine);
sl@0:     if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
sl@0:     if( zLine && zLine[0]=='.' && nSql==0 ){
sl@0:       rc = do_meta_command(zLine, p);
sl@0:       if( rc==2 ){
sl@0:         break;
sl@0:       }else if( rc ){
sl@0:         errCnt++;
sl@0:       }
sl@0:       continue;
sl@0:     }
sl@0:     if( _is_command_terminator(zLine) ){
sl@0:       memcpy(zLine,";",2);
sl@0:     }
sl@0:     nSqlPrior = nSql;
sl@0:     if( zSql==0 ){
sl@0:       int i;
sl@0:       for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){}
sl@0:       if( zLine[i]!=0 ){
sl@0:         nSql = strlen(zLine);
sl@0:         zSql = malloc( nSql+1 );
sl@0:         if( zSql==0 ){
sl@0:           fprintf(stderr, "out of memory\n");
sl@0:           exit(1);
sl@0:         }
sl@0:         memcpy(zSql, zLine, nSql+1);
sl@0:         startline = lineno;
sl@0:       }
sl@0:     }else{
sl@0:       int len = strlen(zLine);
sl@0:       zSql = realloc( zSql, nSql + len + 2 );
sl@0:       if( zSql==0 ){
sl@0:         fprintf(stderr,"%s: out of memory!\n", Argv0);
sl@0:         exit(1);
sl@0:       }
sl@0:       zSql[nSql++] = '\n';
sl@0:       memcpy(&zSql[nSql], zLine, len+1);
sl@0:       nSql += len;
sl@0:     }
sl@0:     if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
sl@0:                 && sqlite3_complete(zSql) ){
sl@0:       p->cnt = 0;
sl@0:       open_db(p);
sl@0:       BEGIN_TIMER;
sl@0:       rc = sqlite3_exec(p->db, zSql, callback, p, &zErrMsg);
sl@0:       END_TIMER;
sl@0:       if( rc || zErrMsg ){
sl@0:         char zPrefix[100];
sl@0:         if( in!=0 || !stdin_is_interactive ){
sl@0:           sqlite3_snprintf(sizeof(zPrefix), zPrefix, 
sl@0:                            "SQL error near line %d:", startline);
sl@0:         }else{
sl@0:           sqlite3_snprintf(sizeof(zPrefix), zPrefix, "SQL error:");
sl@0:         }
sl@0:         if( zErrMsg!=0 ){
sl@0:           printf("%s %s\n", zPrefix, zErrMsg);
sl@0:           sqlite3_free(zErrMsg);
sl@0:           zErrMsg = 0;
sl@0:         }else{
sl@0:           printf("%s %s\n", zPrefix, sqlite3_errmsg(p->db));
sl@0:         }
sl@0:         errCnt++;
sl@0:       }
sl@0:       free(zSql);
sl@0:       zSql = 0;
sl@0:       nSql = 0;
sl@0:     }
sl@0:   }
sl@0:   if( zSql ){
sl@0:     if( !_all_whitespace(zSql) ) printf("Incomplete SQL: %s\n", zSql);
sl@0:     free(zSql);
sl@0:   }
sl@0:   free(zLine);
sl@0:   return errCnt;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return a pathname which is the user's home directory.  A
sl@0: ** 0 return indicates an error of some kind.  Space to hold the
sl@0: ** resulting string is obtained from malloc().  The calling
sl@0: ** function should free the result.
sl@0: */
sl@0: static char *find_home_dir(void){
sl@0:   char *home_dir = NULL;
sl@0: 
sl@0: #if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE)
sl@0:   struct passwd *pwent;
sl@0:   uid_t uid = getuid();
sl@0:   if( (pwent=getpwuid(uid)) != NULL) {
sl@0:     home_dir = pwent->pw_dir;
sl@0:   }
sl@0: #endif
sl@0: 
sl@0: #if defined(_WIN32_WCE)
sl@0:   /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
sl@0:    */
sl@0:   home_dir = strdup("/");
sl@0: #else
sl@0: 
sl@0: #if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
sl@0:   if (!home_dir) {
sl@0:     home_dir = getenv("USERPROFILE");
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   if (!home_dir) {
sl@0:     home_dir = getenv("HOME");
sl@0:   }
sl@0: 
sl@0: #if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
sl@0:   if (!home_dir) {
sl@0:     char *zDrive, *zPath;
sl@0:     int n;
sl@0:     zDrive = getenv("HOMEDRIVE");
sl@0:     zPath = getenv("HOMEPATH");
sl@0:     if( zDrive && zPath ){
sl@0:       n = strlen(zDrive) + strlen(zPath) + 1;
sl@0:       home_dir = malloc( n );
sl@0:       if( home_dir==0 ) return 0;
sl@0:       sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
sl@0:       return home_dir;
sl@0:     }
sl@0:     home_dir = "c:\\";
sl@0:   }
sl@0: #endif
sl@0: 
sl@0: #endif /* !_WIN32_WCE */
sl@0: 
sl@0:   if( home_dir ){
sl@0:     int n = strlen(home_dir) + 1;
sl@0:     char *z = malloc( n );
sl@0:     if( z ) memcpy(z, home_dir, n);
sl@0:     home_dir = z;
sl@0:   }
sl@0: 
sl@0:   return home_dir;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Read input from the file given by sqliterc_override.  Or if that
sl@0: ** parameter is NULL, take input from ~/.sqliterc
sl@0: */
sl@0: static void process_sqliterc(
sl@0:   struct callback_data *p,        /* Configuration data */
sl@0:   const char *sqliterc_override   /* Name of config file. NULL to use default */
sl@0: ){
sl@0:   char *home_dir = NULL;
sl@0:   const char *sqliterc = sqliterc_override;
sl@0:   char *zBuf = 0;
sl@0:   FILE *in = NULL;
sl@0:   int nBuf;
sl@0: 
sl@0:   if (sqliterc == NULL) {
sl@0:     home_dir = find_home_dir();
sl@0:     if( home_dir==0 ){
sl@0:       fprintf(stderr,"%s: cannot locate your home directory!\n", Argv0);
sl@0:       return;
sl@0:     }
sl@0:     nBuf = strlen(home_dir) + 16;
sl@0:     zBuf = malloc( nBuf );
sl@0:     if( zBuf==0 ){
sl@0:       fprintf(stderr,"%s: out of memory!\n", Argv0);
sl@0:       exit(1);
sl@0:     }
sl@0:     sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir);
sl@0:     free(home_dir);
sl@0:     sqliterc = (const char*)zBuf;
sl@0:   }
sl@0:   in = fopen(sqliterc,"rb");
sl@0:   if( in ){
sl@0:     if( stdin_is_interactive ){
sl@0:       printf("-- Loading resources from %s\n",sqliterc);
sl@0:     }
sl@0:     process_input(p,in);
sl@0:     fclose(in);
sl@0:   }
sl@0:   free(zBuf);
sl@0:   return;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Show available command line options
sl@0: */
sl@0: static const char zOptions[] = 
sl@0:   "   -init filename       read/process named file\n"
sl@0:   "   -echo                print commands before execution\n"
sl@0:   "   -[no]header          turn headers on or off\n"
sl@0:   "   -bail                stop after hitting an error\n"
sl@0:   "   -interactive         force interactive I/O\n"
sl@0:   "   -batch               force batch I/O\n"
sl@0:   "   -column              set output mode to 'column'\n"
sl@0:   "   -csv                 set output mode to 'csv'\n"
sl@0:   "   -html                set output mode to HTML\n"
sl@0:   "   -line                set output mode to 'line'\n"
sl@0:   "   -list                set output mode to 'list'\n"
sl@0:   "   -separator 'x'       set output field separator (|)\n"
sl@0:   "   -nullvalue 'text'    set text string for NULL values\n"
sl@0:   "   -version             show SQLite version\n"
sl@0: ;
sl@0: static void usage(int showDetail){
sl@0:   fprintf(stderr,
sl@0:       "Usage: %s [OPTIONS] FILENAME [SQL]\n"  
sl@0:       "FILENAME is the name of an SQLite database. A new database is created\n"
sl@0:       "if the file does not previously exist.\n", Argv0);
sl@0:   if( showDetail ){
sl@0:     fprintf(stderr, "OPTIONS include:\n%s", zOptions);
sl@0:   }else{
sl@0:     fprintf(stderr, "Use the -help option for additional information\n");
sl@0:   }
sl@0:   exit(1);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Initialize the state information in data
sl@0: */
sl@0: static void main_init(struct callback_data *data) {
sl@0:   memset(data, 0, sizeof(*data));
sl@0:   data->mode = MODE_List;
sl@0:   memcpy(data->separator,"|", 2);
sl@0:   data->showHeader = 0;
sl@0:   sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
sl@0:   sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");
sl@0: }
sl@0: 
sl@0: int main(int argc, char **argv){
sl@0:   char *zErrMsg = 0;
sl@0:   struct callback_data data;
sl@0:   const char *zInitFile = 0;
sl@0:   char *zFirstCmd = 0;
sl@0:   int i;
sl@0:   int rc = 0;
sl@0: 
sl@0:   Argv0 = argv[0];
sl@0:   main_init(&data);
sl@0:   stdin_is_interactive = isatty(0);
sl@0: 
sl@0:   /* Make sure we have a valid signal handler early, before anything
sl@0:   ** else is done.
sl@0:   */
sl@0: #ifdef SIGINT
sl@0:   signal(SIGINT, interrupt_handler);
sl@0: #endif
sl@0: 
sl@0:   /* Do an initial pass through the command-line argument to locate
sl@0:   ** the name of the database file, the name of the initialization file,
sl@0:   ** and the first command to execute.
sl@0:   */
sl@0:   for(i=1; i<argc-1; i++){
sl@0:     char *z;
sl@0:     if( argv[i][0]!='-' ) break;
sl@0:     z = argv[i];
sl@0:     if( z[0]=='-' && z[1]=='-' ) z++;
sl@0:     if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){
sl@0:       i++;
sl@0:     }else if( strcmp(argv[i],"-init")==0 ){
sl@0:       i++;
sl@0:       zInitFile = argv[i];
sl@0:     }
sl@0:   }
sl@0:   if( i<argc ){
sl@0: #if defined(SQLITE_OS_OS2) && SQLITE_OS_OS2
sl@0:     data.zDbFilename = (const char *)convertCpPathToUtf8( argv[i++] );
sl@0: #else
sl@0:     data.zDbFilename = argv[i++];
sl@0: #endif
sl@0:   }else{
sl@0: #ifndef SQLITE_OMIT_MEMORYDB
sl@0:     data.zDbFilename = ":memory:";
sl@0: #else
sl@0:     data.zDbFilename = 0;
sl@0: #endif
sl@0:   }
sl@0:   if( i<argc ){
sl@0:     zFirstCmd = argv[i++];
sl@0:   }
sl@0:   data.out = stdout;
sl@0: 
sl@0: #ifdef SQLITE_OMIT_MEMORYDB
sl@0:   if( data.zDbFilename==0 ){
sl@0:     fprintf(stderr,"%s: no database filename specified\n", argv[0]);
sl@0:     exit(1);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* Go ahead and open the database file if it already exists.  If the
sl@0:   ** file does not exist, delay opening it.  This prevents empty database
sl@0:   ** files from being created if a user mistypes the database name argument
sl@0:   ** to the sqlite command-line tool.
sl@0:   */
sl@0:   if( access(data.zDbFilename, 0)==0 ){
sl@0:     open_db(&data);
sl@0:   }
sl@0: 
sl@0:   /* Process the initialization file if there is one.  If no -init option
sl@0:   ** is given on the command line, look for a file named ~/.sqliterc and
sl@0:   ** try to process it.
sl@0:   */
sl@0:   process_sqliterc(&data,zInitFile);
sl@0: 
sl@0:   /* Make a second pass through the command-line argument and set
sl@0:   ** options.  This second pass is delayed until after the initialization
sl@0:   ** file is processed so that the command-line arguments will override
sl@0:   ** settings in the initialization file.
sl@0:   */
sl@0:   for(i=1; i<argc && argv[i][0]=='-'; i++){
sl@0:     char *z = argv[i];
sl@0:     if( z[1]=='-' ){ z++; }
sl@0:     if( strcmp(z,"-init")==0 ){
sl@0:       i++;
sl@0:     }else if( strcmp(z,"-html")==0 ){
sl@0:       data.mode = MODE_Html;
sl@0:     }else if( strcmp(z,"-list")==0 ){
sl@0:       data.mode = MODE_List;
sl@0:     }else if( strcmp(z,"-line")==0 ){
sl@0:       data.mode = MODE_Line;
sl@0:     }else if( strcmp(z,"-column")==0 ){
sl@0:       data.mode = MODE_Column;
sl@0:     }else if( strcmp(z,"-csv")==0 ){
sl@0:       data.mode = MODE_Csv;
sl@0:       memcpy(data.separator,",",2);
sl@0:     }else if( strcmp(z,"-separator")==0 ){
sl@0:       i++;
sl@0:       sqlite3_snprintf(sizeof(data.separator), data.separator,
sl@0:                        "%.*s",(int)sizeof(data.separator)-1,argv[i]);
sl@0:     }else if( strcmp(z,"-nullvalue")==0 ){
sl@0:       i++;
sl@0:       sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
sl@0:                        "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]);
sl@0:     }else if( strcmp(z,"-header")==0 ){
sl@0:       data.showHeader = 1;
sl@0:     }else if( strcmp(z,"-noheader")==0 ){
sl@0:       data.showHeader = 0;
sl@0:     }else if( strcmp(z,"-echo")==0 ){
sl@0:       data.echoOn = 1;
sl@0:     }else if( strcmp(z,"-bail")==0 ){
sl@0:       bail_on_error = 1;
sl@0:     }else if( strcmp(z,"-version")==0 ){
sl@0:       printf("%s\n", sqlite3_libversion());
sl@0:       return 0;
sl@0:     }else if( strcmp(z,"-interactive")==0 ){
sl@0:       stdin_is_interactive = 1;
sl@0:     }else if( strcmp(z,"-batch")==0 ){
sl@0:       stdin_is_interactive = 0;
sl@0:     }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){
sl@0:       usage(1);
sl@0:     }else{
sl@0:       fprintf(stderr,"%s: unknown option: %s\n", Argv0, z);
sl@0:       fprintf(stderr,"Use -help for a list of options.\n");
sl@0:       return 1;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   if( zFirstCmd ){
sl@0:     /* Run just the command that follows the database name
sl@0:     */
sl@0:     if( zFirstCmd[0]=='.' ){
sl@0:       do_meta_command(zFirstCmd, &data);
sl@0:       exit(0);
sl@0:     }else{
sl@0:       int rc;
sl@0:       open_db(&data);
sl@0:       rc = sqlite3_exec(data.db, zFirstCmd, callback, &data, &zErrMsg);
sl@0:       if( rc!=0 && zErrMsg!=0 ){
sl@0:         fprintf(stderr,"SQL error: %s\n", zErrMsg);
sl@0:         exit(1);
sl@0:       }
sl@0:     }
sl@0:   }else{
sl@0:     /* Run commands received from standard input
sl@0:     */
sl@0:     if( stdin_is_interactive ){
sl@0:       char *zHome;
sl@0:       char *zHistory = 0;
sl@0:       int nHistory;
sl@0:       printf(
sl@0:         "SQLite version %s\n"
sl@0:         "Enter \".help\" for instructions\n"
sl@0:         "Enter SQL statements terminated with a \";\"\n",
sl@0:         sqlite3_libversion()
sl@0:       );
sl@0:       zHome = find_home_dir();
sl@0:       if( zHome && (zHistory = malloc(nHistory = strlen(zHome)+20))!=0 ){
sl@0:         sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
sl@0:       }
sl@0: #if defined(HAVE_READLINE) && HAVE_READLINE==1
sl@0:       if( zHistory ) read_history(zHistory);
sl@0: #endif
sl@0:       rc = process_input(&data, 0);
sl@0:       if( zHistory ){
sl@0:         stifle_history(100);
sl@0:         write_history(zHistory);
sl@0:         free(zHistory);
sl@0:       }
sl@0:       free(zHome);
sl@0:     }else{
sl@0:       rc = process_input(&data, stdin);
sl@0:     }
sl@0:   }
sl@0:   set_table_name(&data, 0);
sl@0:   if( db ){
sl@0:     if( sqlite3_close(db)!=SQLITE_OK ){
sl@0:       fprintf(stderr,"error closing database: %s\n", sqlite3_errmsg(db));
sl@0:     }
sl@0:   }
sl@0:   return rc;
sl@0: }