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