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