PageRenderTime 121ms CodeModel.GetById 11ms app.highlight 97ms RepoModel.GetById 1ms app.codeStats 0ms

/External/Sqlite/src/shell.c

http://awoe.googlecode.com/
C | 2144 lines | 1732 code | 128 blank | 284 comment | 445 complexity | 22f3b197a66a68a74445d087a75f9942 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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*/
  59extern 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 */
  75static struct rusage sBegin;
  76
  77/* True if the timer is enabled */
  78static int enableTimer = 0;
  79
  80/*
  81** Begin timing an operation
  82*/
  83static void beginTimer(void){
  84  if( enableTimer ){
  85    getrusage(RUSAGE_SELF, &sBegin);
  86  }
  87}
  88
  89/* Return the difference of two time_structs in seconds */
  90static 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*/
  98static 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 */
 117static HANDLE hProcess;
 118static FILETIME ftKernelBegin;
 119static FILETIME ftUserBegin;
 120typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
 121static GETPROCTIMES getProcessTimesAddr = NULL;
 122
 123/* True if the timer is enabled */
 124static 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*/
 130static 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*/
 156static 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 */
 164static 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*/
 173static 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*/
 202static 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*/
 208static 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*/
 215static sqlite3 *db = 0;
 216
 217/*
 218** True if an interrupt (Control-C) has been received.
 219*/
 220static 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*/
 226static char *Argv0;
 227
 228/*
 229** Prompt strings. Initialized in main. Settable with
 230**   .prompt main continue
 231*/
 232static char mainPrompt[20];     /* First line prompt. default: "sqlite> "*/
 233static char continuePrompt[20]; /* Continuation prompt. default: "   ...> " */
 234
 235/*
 236** Write I/O traces to the following stream.
 237*/
 238#ifdef SQLITE_ENABLE_IOTRACE
 239static 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
 249static 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*/
 265static 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*/
 297static const char *zShellStatic = 0;
 298static 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*/
 320static 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*/
 368static 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
 386struct 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*/
 398struct callback_data {
 399  sqlite3 *db;           /* The database */
 400  int echoOn;            /* True to echo input commands */
 401  int statsOn;           /* True to display memory stats before each finalize */
 402  int cnt;               /* Number of records displayed so far */
 403  FILE *out;             /* Write results here */
 404  int mode;              /* An output mode setting */
 405  int writableSchema;    /* True if PRAGMA writable_schema=ON */
 406  int showHeader;        /* True to show column names in List or Column mode */
 407  char *zDestTable;      /* Name of destination table when MODE_Insert */
 408  char separator[20];    /* Separator character for MODE_List */
 409  int colWidth[100];     /* Requested width of each column when in column mode*/
 410  int actualWidth[100];  /* Actual width of each column */
 411  char nullvalue[20];    /* The text to print when a NULL comes back from
 412                         ** the database */
 413  struct previous_mode_data explainPrev;
 414                         /* Holds the mode information just before
 415                         ** .explain ON */
 416  char outfile[FILENAME_MAX]; /* Filename for *out */
 417  const char *zDbFilename;    /* name of the database file */
 418  sqlite3_stmt *pStmt;   /* Current statement if any. */
 419  FILE *pLog;            /* Write log output here */
 420};
 421
 422/*
 423** These are the allowed modes.
 424*/
 425#define MODE_Line     0  /* One column per line.  Blank line between records */
 426#define MODE_Column   1  /* One record per line in neat columns */
 427#define MODE_List     2  /* One record per line with a separator */
 428#define MODE_Semi     3  /* Same as MODE_List but append ";" to each line */
 429#define MODE_Html     4  /* Generate an XHTML table */
 430#define MODE_Insert   5  /* Generate SQL "insert" statements */
 431#define MODE_Tcl      6  /* Generate ANSI-C or TCL quoted elements */
 432#define MODE_Csv      7  /* Quote strings, numbers are plain */
 433#define MODE_Explain  8  /* Like MODE_Column, but do not truncate data */
 434
 435static const char *modeDescr[] = {
 436  "line",
 437  "column",
 438  "list",
 439  "semi",
 440  "html",
 441  "insert",
 442  "tcl",
 443  "csv",
 444  "explain",
 445};
 446
 447/*
 448** Number of elements in an array
 449*/
 450#define ArraySize(X)  (int)(sizeof(X)/sizeof(X[0]))
 451
 452/*
 453** Compute a string length that is limited to what can be stored in
 454** lower 30 bits of a 32-bit signed integer.
 455*/
 456static int strlen30(const char *z){
 457  const char *z2 = z;
 458  while( *z2 ){ z2++; }
 459  return 0x3fffffff & (int)(z2 - z);
 460}
 461
 462/*
 463** A callback for the sqlite3_log() interface.
 464*/
 465static void shellLog(void *pArg, int iErrCode, const char *zMsg){
 466  struct callback_data *p = (struct callback_data*)pArg;
 467  if( p->pLog==0 ) return;
 468  fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
 469  fflush(p->pLog);
 470}
 471
 472/*
 473** Output the given string as a hex-encoded blob (eg. X'1234' )
 474*/
 475static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
 476  int i;
 477  char *zBlob = (char *)pBlob;
 478  fprintf(out,"X'");
 479  for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]); }
 480  fprintf(out,"'");
 481}
 482
 483/*
 484** Output the given string as a quoted string using SQL quoting conventions.
 485*/
 486static void output_quoted_string(FILE *out, const char *z){
 487  int i;
 488  int nSingle = 0;
 489  for(i=0; z[i]; i++){
 490    if( z[i]=='\'' ) nSingle++;
 491  }
 492  if( nSingle==0 ){
 493    fprintf(out,"'%s'",z);
 494  }else{
 495    fprintf(out,"'");
 496    while( *z ){
 497      for(i=0; z[i] && z[i]!='\''; i++){}
 498      if( i==0 ){
 499        fprintf(out,"''");
 500        z++;
 501      }else if( z[i]=='\'' ){
 502        fprintf(out,"%.*s''",i,z);
 503        z += i+1;
 504      }else{
 505        fprintf(out,"%s",z);
 506        break;
 507      }
 508    }
 509    fprintf(out,"'");
 510  }
 511}
 512
 513/*
 514** Output the given string as a quoted according to C or TCL quoting rules.
 515*/
 516static void output_c_string(FILE *out, const char *z){
 517  unsigned int c;
 518  fputc('"', out);
 519  while( (c = *(z++))!=0 ){
 520    if( c=='\\' ){
 521      fputc(c, out);
 522      fputc(c, out);
 523    }else if( c=='\t' ){
 524      fputc('\\', out);
 525      fputc('t', out);
 526    }else if( c=='\n' ){
 527      fputc('\\', out);
 528      fputc('n', out);
 529    }else if( c=='\r' ){
 530      fputc('\\', out);
 531      fputc('r', out);
 532    }else if( !isprint(c) ){
 533      fprintf(out, "\\%03o", c&0xff);
 534    }else{
 535      fputc(c, out);
 536    }
 537  }
 538  fputc('"', out);
 539}
 540
 541/*
 542** Output the given string with characters that are special to
 543** HTML escaped.
 544*/
 545static void output_html_string(FILE *out, const char *z){
 546  int i;
 547  while( *z ){
 548    for(i=0;   z[i] 
 549            && z[i]!='<' 
 550            && z[i]!='&' 
 551            && z[i]!='>' 
 552            && z[i]!='\"' 
 553            && z[i]!='\'';
 554        i++){}
 555    if( i>0 ){
 556      fprintf(out,"%.*s",i,z);
 557    }
 558    if( z[i]=='<' ){
 559      fprintf(out,"&lt;");
 560    }else if( z[i]=='&' ){
 561      fprintf(out,"&amp;");
 562    }else if( z[i]=='>' ){
 563      fprintf(out,"&gt;");
 564    }else if( z[i]=='\"' ){
 565      fprintf(out,"&quot;");
 566    }else if( z[i]=='\'' ){
 567      fprintf(out,"&#39;");
 568    }else{
 569      break;
 570    }
 571    z += i + 1;
 572  }
 573}
 574
 575/*
 576** If a field contains any character identified by a 1 in the following
 577** array, then the string must be quoted for CSV.
 578*/
 579static const char needCsvQuote[] = {
 580  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
 581  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
 582  1, 0, 1, 0, 0, 0, 0, 1,   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, 0, 
 587  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 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  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
 596};
 597
 598/*
 599** Output a single term of CSV.  Actually, p->separator is used for
 600** the separator, which may or may not be a comma.  p->nullvalue is
 601** the null value.  Strings are quoted using ANSI-C rules.  Numbers
 602** appear outside of quotes.
 603*/
 604static void output_csv(struct callback_data *p, const char *z, int bSep){
 605  FILE *out = p->out;
 606  if( z==0 ){
 607    fprintf(out,"%s",p->nullvalue);
 608  }else{
 609    int i;
 610    int nSep = strlen30(p->separator);
 611    for(i=0; z[i]; i++){
 612      if( needCsvQuote[((unsigned char*)z)[i]] 
 613         || (z[i]==p->separator[0] && 
 614             (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
 615        i = 0;
 616        break;
 617      }
 618    }
 619    if( i==0 ){
 620      putc('"', out);
 621      for(i=0; z[i]; i++){
 622        if( z[i]=='"' ) putc('"', out);
 623        putc(z[i], out);
 624      }
 625      putc('"', out);
 626    }else{
 627      fprintf(out, "%s", z);
 628    }
 629  }
 630  if( bSep ){
 631    fprintf(p->out, "%s", p->separator);
 632  }
 633}
 634
 635#ifdef SIGINT
 636/*
 637** This routine runs when the user presses Ctrl-C
 638*/
 639static void interrupt_handler(int NotUsed){
 640  UNUSED_PARAMETER(NotUsed);
 641  seenInterrupt = 1;
 642  if( db ) sqlite3_interrupt(db);
 643}
 644#endif
 645
 646/*
 647** This is the callback routine that the shell
 648** invokes for each row of a query result.
 649*/
 650static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){
 651  int i;
 652  struct callback_data *p = (struct callback_data*)pArg;
 653
 654  switch( p->mode ){
 655    case MODE_Line: {
 656      int w = 5;
 657      if( azArg==0 ) break;
 658      for(i=0; i<nArg; i++){
 659        int len = strlen30(azCol[i] ? azCol[i] : "");
 660        if( len>w ) w = len;
 661      }
 662      if( p->cnt++>0 ) fprintf(p->out,"\n");
 663      for(i=0; i<nArg; i++){
 664        fprintf(p->out,"%*s = %s\n", w, azCol[i],
 665                azArg[i] ? azArg[i] : p->nullvalue);
 666      }
 667      break;
 668    }
 669    case MODE_Explain:
 670    case MODE_Column: {
 671      if( p->cnt++==0 ){
 672        for(i=0; i<nArg; i++){
 673          int w, n;
 674          if( i<ArraySize(p->colWidth) ){
 675            w = p->colWidth[i];
 676          }else{
 677            w = 0;
 678          }
 679          if( w<=0 ){
 680            w = strlen30(azCol[i] ? azCol[i] : "");
 681            if( w<10 ) w = 10;
 682            n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);
 683            if( w<n ) w = n;
 684          }
 685          if( i<ArraySize(p->actualWidth) ){
 686            p->actualWidth[i] = w;
 687          }
 688          if( p->showHeader ){
 689            fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": "  ");
 690          }
 691        }
 692        if( p->showHeader ){
 693          for(i=0; i<nArg; i++){
 694            int w;
 695            if( i<ArraySize(p->actualWidth) ){
 696               w = p->actualWidth[i];
 697            }else{
 698               w = 10;
 699            }
 700            fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
 701                   "----------------------------------------------------------",
 702                    i==nArg-1 ? "\n": "  ");
 703          }
 704        }
 705      }
 706      if( azArg==0 ) break;
 707      for(i=0; i<nArg; i++){
 708        int w;
 709        if( i<ArraySize(p->actualWidth) ){
 710           w = p->actualWidth[i];
 711        }else{
 712           w = 10;
 713        }
 714        if( p->mode==MODE_Explain && azArg[i] && 
 715           strlen30(azArg[i])>w ){
 716          w = strlen30(azArg[i]);
 717        }
 718        fprintf(p->out,"%-*.*s%s",w,w,
 719            azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": "  ");
 720      }
 721      break;
 722    }
 723    case MODE_Semi:
 724    case MODE_List: {
 725      if( p->cnt++==0 && p->showHeader ){
 726        for(i=0; i<nArg; i++){
 727          fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
 728        }
 729      }
 730      if( azArg==0 ) break;
 731      for(i=0; i<nArg; i++){
 732        char *z = azArg[i];
 733        if( z==0 ) z = p->nullvalue;
 734        fprintf(p->out, "%s", z);
 735        if( i<nArg-1 ){
 736          fprintf(p->out, "%s", p->separator);
 737        }else if( p->mode==MODE_Semi ){
 738          fprintf(p->out, ";\n");
 739        }else{
 740          fprintf(p->out, "\n");
 741        }
 742      }
 743      break;
 744    }
 745    case MODE_Html: {
 746      if( p->cnt++==0 && p->showHeader ){
 747        fprintf(p->out,"<TR>");
 748        for(i=0; i<nArg; i++){
 749          fprintf(p->out,"<TH>");
 750          output_html_string(p->out, azCol[i]);
 751          fprintf(p->out,"</TH>\n");
 752        }
 753        fprintf(p->out,"</TR>\n");
 754      }
 755      if( azArg==0 ) break;
 756      fprintf(p->out,"<TR>");
 757      for(i=0; i<nArg; i++){
 758        fprintf(p->out,"<TD>");
 759        output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
 760        fprintf(p->out,"</TD>\n");
 761      }
 762      fprintf(p->out,"</TR>\n");
 763      break;
 764    }
 765    case MODE_Tcl: {
 766      if( p->cnt++==0 && p->showHeader ){
 767        for(i=0; i<nArg; i++){
 768          output_c_string(p->out,azCol[i] ? azCol[i] : "");
 769          fprintf(p->out, "%s", p->separator);
 770        }
 771        fprintf(p->out,"\n");
 772      }
 773      if( azArg==0 ) break;
 774      for(i=0; i<nArg; i++){
 775        output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
 776        fprintf(p->out, "%s", p->separator);
 777      }
 778      fprintf(p->out,"\n");
 779      break;
 780    }
 781    case MODE_Csv: {
 782      if( p->cnt++==0 && p->showHeader ){
 783        for(i=0; i<nArg; i++){
 784          output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
 785        }
 786        fprintf(p->out,"\n");
 787      }
 788      if( azArg==0 ) break;
 789      for(i=0; i<nArg; i++){
 790        output_csv(p, azArg[i], i<nArg-1);
 791      }
 792      fprintf(p->out,"\n");
 793      break;
 794    }
 795    case MODE_Insert: {
 796      p->cnt++;
 797      if( azArg==0 ) break;
 798      fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
 799      for(i=0; i<nArg; i++){
 800        char *zSep = i>0 ? ",": "";
 801        if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
 802          fprintf(p->out,"%sNULL",zSep);
 803        }else if( aiType && aiType[i]==SQLITE_TEXT ){
 804          if( zSep[0] ) fprintf(p->out,"%s",zSep);
 805          output_quoted_string(p->out, azArg[i]);
 806        }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){
 807          fprintf(p->out,"%s%s",zSep, azArg[i]);
 808        }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
 809          const void *pBlob = sqlite3_column_blob(p->pStmt, i);
 810          int nBlob = sqlite3_column_bytes(p->pStmt, i);
 811          if( zSep[0] ) fprintf(p->out,"%s",zSep);
 812          output_hex_blob(p->out, pBlob, nBlob);
 813        }else if( isNumber(azArg[i], 0) ){
 814          fprintf(p->out,"%s%s",zSep, azArg[i]);
 815        }else{
 816          if( zSep[0] ) fprintf(p->out,"%s",zSep);
 817          output_quoted_string(p->out, azArg[i]);
 818        }
 819      }
 820      fprintf(p->out,");\n");
 821      break;
 822    }
 823  }
 824  return 0;
 825}
 826
 827/*
 828** This is the callback routine that the SQLite library
 829** invokes for each row of a query result.
 830*/
 831static int callback(void *pArg, int nArg, char **azArg, char **azCol){
 832  /* since we don't have type info, call the shell_callback with a NULL value */
 833  return shell_callback(pArg, nArg, azArg, azCol, NULL);
 834}
 835
 836/*
 837** Set the destination table field of the callback_data structure to
 838** the name of the table given.  Escape any quote characters in the
 839** table name.
 840*/
 841static void set_table_name(struct callback_data *p, const char *zName){
 842  int i, n;
 843  int needQuote;
 844  char *z;
 845
 846  if( p->zDestTable ){
 847    free(p->zDestTable);
 848    p->zDestTable = 0;
 849  }
 850  if( zName==0 ) return;
 851  needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
 852  for(i=n=0; zName[i]; i++, n++){
 853    if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
 854      needQuote = 1;
 855      if( zName[i]=='\'' ) n++;
 856    }
 857  }
 858  if( needQuote ) n += 2;
 859  z = p->zDestTable = malloc( n+1 );
 860  if( z==0 ){
 861    fprintf(stderr,"Error: out of memory\n");
 862    exit(1);
 863  }
 864  n = 0;
 865  if( needQuote ) z[n++] = '\'';
 866  for(i=0; zName[i]; i++){
 867    z[n++] = zName[i];
 868    if( zName[i]=='\'' ) z[n++] = '\'';
 869  }
 870  if( needQuote ) z[n++] = '\'';
 871  z[n] = 0;
 872}
 873
 874/* zIn is either a pointer to a NULL-terminated string in memory obtained
 875** from malloc(), or a NULL pointer. The string pointed to by zAppend is
 876** added to zIn, and the result returned in memory obtained from malloc().
 877** zIn, if it was not NULL, is freed.
 878**
 879** If the third argument, quote, is not '\0', then it is used as a 
 880** quote character for zAppend.
 881*/
 882static char *appendText(char *zIn, char const *zAppend, char quote){
 883  int len;
 884  int i;
 885  int nAppend = strlen30(zAppend);
 886  int nIn = (zIn?strlen30(zIn):0);
 887
 888  len = nAppend+nIn+1;
 889  if( quote ){
 890    len += 2;
 891    for(i=0; i<nAppend; i++){
 892      if( zAppend[i]==quote ) len++;
 893    }
 894  }
 895
 896  zIn = (char *)realloc(zIn, len);
 897  if( !zIn ){
 898    return 0;
 899  }
 900
 901  if( quote ){
 902    char *zCsr = &zIn[nIn];
 903    *zCsr++ = quote;
 904    for(i=0; i<nAppend; i++){
 905      *zCsr++ = zAppend[i];
 906      if( zAppend[i]==quote ) *zCsr++ = quote;
 907    }
 908    *zCsr++ = quote;
 909    *zCsr++ = '\0';
 910    assert( (zCsr-zIn)==len );
 911  }else{
 912    memcpy(&zIn[nIn], zAppend, nAppend);
 913    zIn[len-1] = '\0';
 914  }
 915
 916  return zIn;
 917}
 918
 919
 920/*
 921** Execute a query statement that has a single result column.  Print
 922** that result column on a line by itself with a semicolon terminator.
 923**
 924** This is used, for example, to show the schema of the database by
 925** querying the SQLITE_MASTER table.
 926*/
 927static int run_table_dump_query(
 928  FILE *out,              /* Send output here */
 929  sqlite3 *db,            /* Database to query */
 930  const char *zSelect,    /* SELECT statement to extract content */
 931  const char *zFirstRow   /* Print before first row, if not NULL */
 932){
 933  sqlite3_stmt *pSelect;
 934  int rc;
 935  rc = sqlite3_prepare(db, zSelect, -1, &pSelect, 0);
 936  if( rc!=SQLITE_OK || !pSelect ){
 937    return rc;
 938  }
 939  rc = sqlite3_step(pSelect);
 940  while( rc==SQLITE_ROW ){
 941    if( zFirstRow ){
 942      fprintf(out, "%s", zFirstRow);
 943      zFirstRow = 0;
 944    }
 945    fprintf(out, "%s;\n", sqlite3_column_text(pSelect, 0));
 946    rc = sqlite3_step(pSelect);
 947  }
 948  return sqlite3_finalize(pSelect);
 949}
 950
 951/*
 952** Allocate space and save off current error string.
 953*/
 954static char *save_err_msg(
 955  sqlite3 *db            /* Database to query */
 956){
 957  int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
 958  char *zErrMsg = sqlite3_malloc(nErrMsg);
 959  if( zErrMsg ){
 960    memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
 961  }
 962  return zErrMsg;
 963}
 964
 965/*
 966** Display memory stats.
 967*/
 968static int display_stats(
 969  sqlite3 *db,                /* Database to query */
 970  struct callback_data *pArg, /* Pointer to struct callback_data */
 971  int bReset                  /* True to reset the stats */
 972){
 973  int iCur;
 974  int iHiwtr;
 975
 976  if( pArg && pArg->out ){
 977    
 978    iHiwtr = iCur = -1;
 979    sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
 980    fprintf(pArg->out, "Memory Used:                         %d (max %d) bytes\n", iCur, iHiwtr);
 981    iHiwtr = iCur = -1;
 982    sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
 983    fprintf(pArg->out, "Number of Allocations:               %d (max %d)\n", iCur, iHiwtr);
 984/*
 985** Not currently used by the CLI.
 986**    iHiwtr = iCur = -1;
 987**    sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
 988**    fprintf(pArg->out, "Number of Pcache Pages Used:         %d (max %d) pages\n", iCur, iHiwtr);
 989*/
 990    iHiwtr = iCur = -1;
 991    sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
 992    fprintf(pArg->out, "Number of Pcache Overflow Bytes:     %d (max %d) bytes\n", iCur, iHiwtr);
 993/*
 994** Not currently used by the CLI.
 995**    iHiwtr = iCur = -1;
 996**    sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
 997**    fprintf(pArg->out, "Number of Scratch Allocations Used:  %d (max %d)\n", iCur, iHiwtr);
 998*/
 999    iHiwtr = iCur = -1;
1000    sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1001    fprintf(pArg->out, "Number of Scratch Overflow Bytes:    %d (max %d) bytes\n", iCur, iHiwtr);
1002    iHiwtr = iCur = -1;
1003    sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1004    fprintf(pArg->out, "Largest Allocation:                  %d bytes\n", iHiwtr);
1005    iHiwtr = iCur = -1;
1006    sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1007    fprintf(pArg->out, "Largest Pcache Allocation:           %d bytes\n", iHiwtr);
1008    iHiwtr = iCur = -1;
1009    sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1010    fprintf(pArg->out, "Largest Scratch Allocation:          %d bytes\n", iHiwtr);
1011#ifdef YYTRACKMAXSTACKDEPTH
1012    iHiwtr = iCur = -1;
1013    sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1014    fprintf(pArg->out, "Deepest Parser Stack:                %d (max %d)\n", iCur, iHiwtr);
1015#endif
1016  }
1017
1018  if( pArg && pArg->out && db ){
1019    iHiwtr = iCur = -1;
1020    sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, &iCur, &iHiwtr, bReset);
1021    fprintf(pArg->out, "Lookaside Slots Used:                %d (max %d)\n", iCur, iHiwtr);
1022    iHiwtr = iCur = -1;
1023    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1024    fprintf(pArg->out, "Pager Heap Usage:                    %d bytes\n", iCur); 
1025    iHiwtr = iCur = -1;
1026    sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1027    fprintf(pArg->out, "Schema Heap Usage:                   %d bytes\n", iCur); 
1028    iHiwtr = iCur = -1;
1029    sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1030    fprintf(pArg->out, "Statement Heap/Lookaside Usage:      %d bytes\n", iCur); 
1031  }
1032
1033  if( pArg && pArg->out && db && pArg->pStmt ){
1034    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, bReset);
1035    fprintf(pArg->out, "Fullscan Steps:                      %d\n", iCur);
1036    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1037    fprintf(pArg->out, "Sort Operations:                     %d\n", iCur);
1038    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX, bReset);
1039    fprintf(pArg->out, "Autoindex Inserts:                   %d\n", iCur);
1040  }
1041
1042  return 0;
1043}
1044
1045/*
1046** Execute a statement or set of statements.  Print 
1047** any result rows/columns depending on the current mode 
1048** set via the supplied callback.
1049**
1050** This is very similar to SQLite's built-in sqlite3_exec() 
1051** function except it takes a slightly different callback 
1052** and callback data argument.
1053*/
1054static int shell_exec(
1055  sqlite3 *db,                                /* An open database */
1056  const char *zSql,                           /* SQL to be evaluated */
1057  int (*xCallback)(void*,int,char**,char**,int*),   /* Callback function */
1058                                              /* (not the same as sqlite3_exec) */
1059  struct callback_data *pArg,                 /* Pointer to struct callback_data */
1060  char **pzErrMsg                             /* Error msg written here */
1061){
1062  sqlite3_stmt *pStmt = NULL;     /* Statement to execute. */
1063  int rc = SQLITE_OK;             /* Return Code */
1064  const char *zLeftover;          /* Tail of unprocessed SQL */
1065
1066  if( pzErrMsg ){
1067    *pzErrMsg = NULL;
1068  }
1069
1070  while( zSql[0] && (SQLITE_OK == rc) ){
1071    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1072    if( SQLITE_OK != rc ){
1073      if( pzErrMsg ){
1074        *pzErrMsg = save_err_msg(db);
1075      }
1076    }else{
1077      if( !pStmt ){
1078        /* this happens for a comment or white-space */
1079        zSql = zLeftover;
1080        while( isspace(zSql[0]) ) zSql++;
1081        continue;
1082      }
1083
1084      /* save off the prepared statment handle and reset row count */
1085      if( pArg ){
1086        pArg->pStmt = pStmt;
1087        pArg->cnt = 0;
1088      }
1089
1090      /* echo the sql statement if echo on */
1091      if( pArg && pArg->echoOn ){
1092        const char *zStmtSql = sqlite3_sql(pStmt);
1093        fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1094      }
1095
1096      /* perform the first step.  this will tell us if we
1097      ** have a result set or not and how wide it is.
1098      */
1099      rc = sqlite3_step(pStmt);
1100      /* if we have a result set... */
1101      if( SQLITE_ROW == rc ){
1102        /* if we have a callback... */
1103        if( xCallback ){
1104          /* allocate space for col name ptr, value ptr, and type */
1105          int nCol = sqlite3_column_count(pStmt);
1106          void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1107          if( !pData ){
1108            rc = SQLITE_NOMEM;
1109          }else{
1110            char **azCols = (char **)pData;      /* Names of result columns */
1111            char **azVals = &azCols[nCol];       /* Results */
1112            int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1113            int i;
1114            assert(sizeof(int) <= sizeof(char *)); 
1115            /* save off ptrs to column names */
1116            for(i=0; i<nCol; i++){
1117              azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1118            }
1119            do{
1120              /* extract the data and data types */
1121              for(i=0; i<nCol; i++){
1122                azVals[i] = (char *)sqlite3_column_text(pStmt, i);
1123                aiTypes[i] = sqlite3_column_type(pStmt, i);
1124                if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1125                  rc = SQLITE_NOMEM;
1126                  break; /* from for */
1127                }
1128              } /* end for */
1129
1130              /* if data and types extracted successfully... */
1131              if( SQLITE_ROW == rc ){ 
1132                /* call the supplied callback with the result row data */
1133                if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1134                  rc = SQLITE_ABORT;
1135                }else{
1136                  rc = sqlite3_step(pStmt);
1137                }
1138              }
1139            } while( SQLITE_ROW == rc );
1140            sqlite3_free(pData);
1141          }
1142        }else{
1143          do{
1144            rc = sqlite3_step(pStmt);
1145          } while( rc == SQLITE_ROW );
1146        }
1147      }
1148
1149      /* print usage stats if stats on */
1150      if( pArg && pArg->statsOn ){
1151        display_stats(db, pArg, 0);
1152      }
1153
1154      /* Finalize the statement just executed. If this fails, save a 
1155      ** copy of the error message. Otherwise, set zSql to point to the
1156      ** next statement to execute. */
1157      rc = sqlite3_finalize(pStmt);
1158      if( rc==SQLITE_OK ){
1159        zSql = zLeftover;
1160        while( isspace(zSql[0]) ) zSql++;
1161      }else if( pzErrMsg ){
1162        *pzErrMsg = save_err_msg(db);
1163      }
1164
1165      /* clear saved stmt handle */
1166      if( pArg ){
1167        pArg->pStmt = NULL;
1168      }
1169    }
1170  } /* end while */
1171
1172  return rc;
1173}
1174
1175
1176/*
1177** This is a different callback routine used for dumping the database.
1178** Each row received by this callback consists of a table name,
1179** the table type ("index" or "table") and SQL to create the table.
1180** This routine should print text sufficient to recreate the table.
1181*/
1182static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1183  int rc;
1184  const char *zTable;
1185  const char *zType;
1186  const char *zSql;
1187  const char *zPrepStmt = 0;
1188  struct callback_data *p = (struct callback_data *)pArg;
1189
1190  UNUSED_PARAMETER(azCol);
1191  if( nArg!=3 ) return 1;
1192  zTable = azArg[0];
1193  zType = azArg[1];
1194  zSql = azArg[2];
1195  
1196  if( strcmp(zTable, "sqlite_sequence")==0 ){
1197    zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1198  }else if( strcmp(zTable, "sqlite_stat1")==0 ){
1199    fprintf(p->out, "ANALYZE sqlite_master;\n");
1200  }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1201    return 0;
1202  }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1203    char *zIns;
1204    if( !p->writableSchema ){
1205      fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1206      p->writableSchema = 1;
1207    }
1208    zIns = sqlite3_mprintf(
1209       "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1210       "VALUES('table','%q','%q',0,'%q');",
1211       zTable, zTable, zSql);
1212    fprintf(p->out, "%s\n", zIns);
1213    sqlite3_free(zIns);
1214    return 0;
1215  }else{
1216    fprintf(p->out, "%s;\n", zSql);
1217  }
1218
1219  if( strcmp(zType, "table")==0 ){
1220    sqlite3_stmt *pTableInfo = 0;
1221    char *zSelect = 0;
1222    char *zTableInfo = 0;
1223    char *zTmp = 0;
1224    int nRow = 0;
1225   
1226    zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1227    zTableInfo = appendText(zTableInfo, zTable, '"');
1228    zTableInfo = appendText(zTableInfo, ");", 0);
1229
1230    rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1231    free(zTableInfo);
1232    if( rc!=SQLITE_OK || !pTableInfo ){
1233      return 1;
1234    }
1235
1236    zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1237    zTmp = appendText(zTmp, zTable, '"');
1238    if( zTmp ){
1239      zSelect = appendText(zSelect, zTmp, '\'');
1240    }
1241    zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1242    rc = sqlite3_step(pTableInfo);
1243    while( rc==SQLITE_ROW ){
1244      const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1245      zSelect = appendText(zSelect, "quote(", 0);
1246      zSelect = appendText(zSelect, zText, '"');
1247      rc = sqlite3_step(pTableInfo);
1248      if( rc==SQLITE_ROW ){
1249        zSelect = appendText(zSelect, ") || ',' || ", 0);
1250      }else{
1251        zSelect = appendText(zSelect, ") ", 0);
1252      }
1253      nRow++;
1254    }
1255    rc = sqlite3_finalize(pTableInfo);
1256    if( rc!=SQLITE_OK || nRow==0 ){
1257      free(zSelect);
1258      return 1;
1259    }
1260    zSelect = appendText(zSelect, "|| ')' FROM  ", 0);
1261    zSelect = appendText(zSelect, zTable, '"');
1262
1263    rc = run_table_dump_query(p->out, p->db, zSelect, zPrepStmt);
1264    if( rc==SQLITE_CORRUPT ){
1265      zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1266      rc = run_table_dump_query(p->out, p->db, zSelect, 0);
1267    }
1268    if( zSelect ) free(zSelect);
1269  }
1270  return 0;
1271}
1272
1273/*
1274** Run zQuery.  Use dump_callback() as the callback routine so that
1275** the contents of the query are output as SQL statements.
1276**
1277** If we get a SQLITE_CORRUPT error, rerun the query after appending
1278** "ORDER BY rowid DESC" to the end.
1279*/
1280static int run_schema_dump_query(
1281  struct callback_data *p, 
1282  const char *zQuery,
1283  char **pzErrMsg
1284){
1285  int rc;
1286  rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg);
1287  if( rc==SQLITE_CORRUPT ){
1288    char *zQ2;
1289    int len = strlen30(zQuery);
1290    if( pzErrMsg ) sqlite3_free(*pzErrMsg);
1291    zQ2 = malloc( len+100 );
1292    if( zQ2==0 ) return rc;
1293    sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery);
1294    rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg);
1295    free(zQ2);
1296  }
1297  return rc;
1298}
1299
1300/*
1301** Text of a help message
1302*/
1303static char zHelp[] =
1304  ".backup ?DB? FILE      Backup DB (default \"main\") to FILE\n"
1305  ".bail ON|OFF           Stop after hitting an error.  Default OFF\n"
1306  ".databases             List names and files of attached databases\n"
1307  ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
1308  "                         If TABLE specified, only dump tables matching\n"
1309  "                         LIKE pattern TABLE.\n"
1310  ".echo ON|OFF           Turn command echo on or off\n"
1311  ".exit                  Exit this program\n"
1312  ".explain ?ON|OFF?      Turn output mode suitable for EXPLAIN on or off.\n"
1313  "                         With no args, it turns EXPLAIN on.\n"
1314  ".header(s) ON|OFF      Turn display of headers on or off\n"
1315  ".help                  Show this message\n"
1316  ".import FILE TABLE     Import data from FILE into TABLE\n"
1317  ".indices ?TABLE?       Show names of all indices\n"
1318  "                         If TABLE specified, only show indices for tables\n"
1319  "                         matching LIKE pattern TABLE.\n"
1320#ifdef SQLITE_ENABLE_IOTRACE
1321  ".iotrace FILE          Enable I/O diagnostic logging to FILE\n"
1322#endif
1323#ifndef SQLITE_OMIT_LOAD_EXTENSION
1324  ".load FILE ?ENTRY?     Load an extension library\n"
1325#endif
1326  ".log FILE|off          Turn logging on or off.  FILE can be stderr/stdout\n"
1327  ".mode MODE ?TABLE?     Set output mode where MODE is one of:\n"
1328  "                         csv      Comma-separated values\n"
1329  "                         column   Left-aligned columns.  (See .width)\n"
1330  "                         html     HTML <table> code\n"
1331  "                         insert   SQL insert statements for TABLE\n"
1332  "                         line     One value per line\n"
1333  "                         list     Values delimited by .separator string\n"
1334  "                         tabs     Tab-separated values\n"
1335  "                         tcl      TCL list elements\n"
1336  ".nullvalue STRING      Print STRING in place of NULL values\n"
1337  ".output FILENAME       Send output to FILENAME\n"
1338  ".output stdout         Send output to the screen\n"
1339  ".prompt MAIN CONTINUE  Replace the standard prompts\n"
1340  ".quit                  Exit this program\n"
1341  ".read FILENAME         Execute SQL in FILENAME\n"
1342  ".restore ?DB? FILE     Restore content of DB (default \"main\") from FILE\n"
1343  ".schema ?TABLE?        Show the CREATE statements\n"
1344  "                         If TABLE specified, only show tables matching\n"
1345  "                         LIKE pattern TABLE.\n"
1346  ".separator STRING      Change separator used by output mode and .import\n"
1347  ".show                  Show the current values for various settings\n"
1348  ".stats ON|OFF          Turn stats on or off\n"
1349  ".tables ?TABLE?        List names of tables\n"
1350  "                         If TABLE specified, only list tables matching\n"
1351  "                         LIKE pattern TABLE.\n"
1352  ".timeout MS            Try opening locked tables for MS milliseconds\n"
1353  ".width NUM1 NUM2 ...   Set column widths for \"column\" mode\n"
1354;
1355
1356static char zTimerHelp[] =
1357  ".timer ON|OFF          Turn the CPU timer measurement on or off\n"
1358;
1359
1360/* Forward reference */
1361static int process_input(struct callback_data *p, FILE *in);
1362
1363/*
1364** Make sure the database is open.  If it is not, then open it.  If
1365** the database fails to open, print an error message and exit.
1366*/
1367static void open_db(struct callback_data *p){
1368  if( p->db==0 ){
1369    sqlite3_open(p->zDbFilename, &p->db);
1370    db = p->db;
1371    if( db && sqlite3_errcode(db)==SQLITE_OK ){
1372      sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1373          shellstaticFunc, 0, 0);
1374    }
1375    if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1376      fprintf(stderr,"Error: unable to open database \"%s\": %s\n", 
1377          p->zDbFilename, sqlite3_errmsg(db));
1378      exit(1);
1379    }
1380#ifndef SQLITE_OMIT_LOAD_EXTENSION
1381    sqlite3_enable_load_extension(p->db, 1);
1382#endif
1383  }
1384}
1385
1386/*
1387** Do C-language style dequoting.
1388**
1389**    \t    -> tab
1390**    \n    -> newline
1391**    \r    -> carriage return
1392**    \NNN  -> ascii character NNN in octal
1393**    \\    -> backslash
1394*/
1395static void resolve_backslashes(char *z){
1396  int i, j;
1397  char c;
1398  for(i=j=0; (c = z[i])!=0; i++, j++){
1399    if( c=='\\' ){
1400      c = z[++i];
1401      if( c=='n' ){
1402        c = '\n';
1403      }else if( c=='t' ){
1404        c = '\t';
1405      }else if( c=='r' ){
1406        c = '\r';
1407      }else if( c>='0' && c<='7' ){
1408        c -= '0';
1409        if( z[i+1]>='0' && z[i+1]<='7' ){
1410          i++;
1411          c = (c<<3) + z[i] - '0';
1412          if( z[i+1]>='0' && z[i+1]<='7' ){
1413            i++;
1414            c = (c<<3) + z[i] - '0';
1415          }
1416        }
1417      }
1418    }
1419    z[j] = c;
1420  }
1421  z[j] = 0;
1422}
1423
1424/*
1425** Interpret zArg as a boolean value.  Return either 0 or 1.
1426*/
1427static int booleanValue(char *zArg){
1428  int val = atoi(zArg);
1429  int j;
1430  for(j=0; zArg[j]; j++){
1431    zArg[j] = (char)tolower(zArg[j]);
1432  }
1433  if( strcmp(zArg,"on")==0 ){
1434    val = 1;
1435  }else if( strcmp(zArg,"yes")==0 ){
1436    val = 1;
1437  }
1438  return val;
1439}
1440
1441/*
1442** If an input line begins with "." then invoke this routine to
1443** process that line.
1444**
1445** Return 1 on error, 2 to exit, and 0 otherwise.
1446*/
1447static int do_meta_command(char *zLine, struct callback_data *p){
1448  int i = 1;
1449  int nArg = 0;
1450  int n, c;
1451  int rc = 0;
1452  char *azArg[50];
1453
1454  /* Parse the input line into tokens.
1455  */
1456  while( zLine[i] && nArg<ArraySize(azArg) ){
1457    while( isspace((unsigned char)zLine[i]) ){ i++; }
1458    if( zLine[i]==0 ) break;
1459    if( zLine[i]=='\'' || zLine[i]=='"' ){
1460      int delim = zLine[i++];
1461      azArg[nArg++] = &zLine[i];
1462      while( zLine[i] && zLine[i]!=delim ){ i++; }
1463      if( zLine[i]==delim ){
1464        zLine[i++] = 0;
1465      }
1466      if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1467    }else{
1468      azArg[nArg++] = &zLine[i];
1469      while( zLine[i] && !isspace((unsigned char)zLine[i]) ){ i++; }
1470      if( zLine[i] ) zLine[i++] = 0;
1471      resolve_backslashes(azArg[nArg-1]);
1472    }
1473  }
1474
1475  /* Process the input line.
1476  */
1477  if( nArg==0 ) return 0; /* no tokens, no error */
1478  n = strlen30(azArg[0]);
1479  c = azArg[0][0];
1480  if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 && nArg>1 && nArg<4){
1481    const char *zDestFile;
1482    const char *zDb;
1483    sqlite3 *pDest;
1484    sqlite3_backup *pBackup;
1485    if( nArg==2 ){
1486      zDestFile = azArg[1];
1487      zDb = "main";
1488    }else{
1489      zDestFile = azArg[2];
1490      zDb = azArg[1];
1491    }
1492    rc = sqlite3_open(zDestFile, &pDest);
1493    if( rc!=SQLITE_OK ){
1494      fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
1495      sqlite3_close(pDest);
1496      return 1;
1497    }
1498    open_db(p);
1499    pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
1500    if( pBackup==0 ){
1501      fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1502      sqlite3_close(pDest);
1503      return 1;
1504    }
1505    while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
1506    sqlite3_backup_finish(pBackup);
1507    if( rc==SQLITE_DONE ){
1508      rc = 0;
1509    }else{
1510      fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
1511      rc = 1;
1512    }
1513    sqlite3_close(pDest);
1514  }else
1515
1516  if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){
1517    bail_on_error = booleanValue(azArg[1]);
1518  }else
1519
1520  if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
1521    struct callback_data data;
1522    char *zErrMsg = 0;
1523    open_db(p);
1524    memcpy(&data, p, sizeof(data));
1525    data.showHeader = 1;
1526    data.mode = MODE_Column;
1527    data.colWidth[0] = 3;
1528    data.colWidth[1] = 15;
1529    data.colWidth[2] = 58;
1530    data.cnt = 0;
1531    sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
1532    if( zErrMsg ){
1533      fprintf(stderr,"Error: %s\n", zErrMsg);
1534      sqlite3_free(zErrMsg);
1535      rc = 1;
1536    }
1537  }else
1538
1539  if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
1540    char *zErrMsg = 0;
1541    open_db(p);
1542    /* When playing back a "dump", the content might appear in an order
1543    ** which causes immediate foreign key constraints to be violated.
1544    ** So disable foreign-key constraint enforcement to prevent problems. */
1545    fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
1546    fprintf(p->out, "BEGIN TRANSACTION;\n");
1547    p->writableSchema = 0;
1548    sqlite3_exec(p->db, "PRAGMA writable_schema=ON", 0, 0, 0);
1549    if( nArg==1 ){
1550      run_schema_dump_query(p, 
1551        "SELECT name, type, sql FROM sqlite_master "
1552        "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'", 0
1553      );
1554      run_schema_dump_query(p, 
1555        "SELECT name, type, sql FROM sqlite_master "
1556        "WHERE name=='sqlite_sequence'", 0
1557      );
1558      run_table_dump_query(p->out, p->db,
1559        "SELECT sql FROM sqlite_master "
1560        "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
1561      );
1562    }else{
1563      int i;
1564      for(i=1; i<nArg; i++){
1565        zShellStatic = azArg[i];
1566        run_schema_dump_query(p,
1567          "SELECT name, type, sql FROM sqlite_master "
1568          "WHERE tbl_name LIKE shellstatic() AND type=='table'"
1569          "  AND sql NOT NULL", 0);
1570        run_table_dump_query(p->out, p->db,
1571          "SELECT sql FROM sqlite_master "
1572          "WHERE sql NOT NULL"
1573          "  AND type IN ('index','trigger','view')"
1574          "  AND tbl_name LIKE shellstatic()", 0
1575        );
1576        zShellStatic = 0;
1577      }
1578    }
1579    if( p->writableSchema ){
1580      fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
1581      p->writableSchema = 0;
1582    }
1583    sqlite3_exec(p->db, "PRAGMA writable_schema=OFF", 0, 0, 0);
1584    if( zErrMsg ){
1585      fprintf(stderr,"Error: %s\n", zErrMsg);
1586      sqlite3_free(zErrMsg);
1587    }else{
1588      fprintf(p->out, "COMMIT;\n");
1589    }
1590  }else
1591
1592  if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){
1593    p->echoOn = booleanValue(azArg[1]);
1594  }else
1595
1596  if( c=='e' && strncmp(azArg[0], "exit", n)==0  && nArg==1 ){
1597    rc = 2;
1598  }else
1599
1600  if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){
1601    int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
1602    if(val == 1) {
1603      if(!p->explainPrev.valid) {
1604        p->explainPrev.valid = 1;
1605        p->explainPrev.mode = p->mode;
1606        p->explainPrev.showHeader = p->showHeader;
1607        memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
1608      }
1609      /* We could put this code under the !p->explainValid
1610      ** condition so that it does not execute if we are already in
1611      ** explain mode. However, always executing it allows us an easy
1612      ** was to reset to explain mode in case the user previously
1613      ** did an .explain followed by a .width, .mode or .header
1614      ** command.
1615      */
1616      p->mode = MODE_Explain;
1617      p->showHeader = 1;
1618      memset(p->colWidth,0,ArraySize(p->colWidth));
1619      p->colWidth[0] = 4;                  /* addr */
1620      p->colWidth[1] = 13;                 /* opcode */
1621      p->colWidth[2] = 4;                  /* P1 */
1622      p->colWidth[3] = 4;                  /* P2 */
1623      p->colWidth[4] = 4;                  /* P3 */
1624      p->colWidth[5] = 13;                 /* P4 */
1625      p->colWidth[6] = 2;                  /* P5 */
1626      p->colWidth[7] = 13;                  /* Comment */
1627    }else if (p->explainPrev.valid) {
1628      p->explainPrev.valid = 0;
1629      p->mode = p->explainPrev.mode;
1630      p->showHeader = p->explainPrev.showHeader;
1631      memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
1632    }
1633  }else
1634
1635  if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
1636                 strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){
1637    p->showHeader = booleanValue(azArg[1]);
1638  }else
1639
1640  if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1641    fprintf(stderr,"%s",zHelp);
1642    if( HAS_TIMER ){
1643      fprintf(stderr,"%s",zTimerHelp);
1644    }
1645  }else
1646
1647  if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1648    char *zTable = azArg[2];    /* Insert data into this table */
1649    char *zFile = azArg[1];     /* The file from which to extract data */
1650    sqlite3_stmt *pStmt = NULL; /* A statement */
1651    int nCol;                   /* Number of columns in the …

Large files files are truncated, but you can click here to view the full file