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 ** If requested, include the SQLite compiler options file for MSVC. 22 */ 23 #if defined(INCLUDE_MSVC_H) 24 #include "msvc.h" 25 #endif 26 27 /* 28 ** No support for loadable extensions in VxWorks. 29 */ 30 #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION 31 # define SQLITE_OMIT_LOAD_EXTENSION 1 32 #endif 33 34 /* 35 ** Enable large-file support for fopen() and friends on unix. 36 */ 37 #ifndef SQLITE_DISABLE_LFS 38 # define _LARGE_FILE 1 39 # ifndef _FILE_OFFSET_BITS 40 # define _FILE_OFFSET_BITS 64 41 # endif 42 # define _LARGEFILE_SOURCE 1 43 #endif 44 45 #include <stdlib.h> 46 #include <string.h> 47 #include <stdio.h> 48 #include <assert.h> 49 #include "sqlite3.h" 50 #if SQLITE_USER_AUTHENTICATION 51 # include "sqlite3userauth.h" 52 #endif 53 #include <ctype.h> 54 #include <stdarg.h> 55 56 #if !defined(_WIN32) && !defined(WIN32) 57 # include <signal.h> 58 # if !defined(__RTP__) && !defined(_WRS_KERNEL) 59 # include <pwd.h> 60 # endif 61 # include <unistd.h> 62 # include <sys/types.h> 63 #endif 64 65 #if HAVE_READLINE 66 # include <readline/readline.h> 67 # include <readline/history.h> 68 #endif 69 70 #if HAVE_EDITLINE 71 # include <editline/readline.h> 72 #endif 73 74 #if HAVE_EDITLINE || HAVE_READLINE 75 76 # define shell_add_history(X) add_history(X) 77 # define shell_read_history(X) read_history(X) 78 # define shell_write_history(X) write_history(X) 79 # define shell_stifle_history(X) stifle_history(X) 80 # define shell_readline(X) readline(X) 81 82 #elif HAVE_LINENOISE 83 84 # include "linenoise.h" 85 # define shell_add_history(X) linenoiseHistoryAdd(X) 86 # define shell_read_history(X) linenoiseHistoryLoad(X) 87 # define shell_write_history(X) linenoiseHistorySave(X) 88 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X) 89 # define shell_readline(X) linenoise(X) 90 91 #else 92 93 # define shell_read_history(X) 94 # define shell_write_history(X) 95 # define shell_stifle_history(X) 96 97 # define SHELL_USE_LOCAL_GETLINE 1 98 #endif 99 100 101 #if defined(_WIN32) || defined(WIN32) 102 # include <io.h> 103 # include <fcntl.h> 104 #define isatty(h) _isatty(h) 105 #ifndef access 106 # define access(f,m) _access((f),(m)) 107 #endif 108 #undef popen 109 #define popen _popen 110 #undef pclose 111 #define pclose _pclose 112 #else 113 /* Make sure isatty() has a prototype. 114 */ 115 extern int isatty(int); 116 117 #if !defined(__RTP__) && !defined(_WRS_KERNEL) 118 /* popen and pclose are not C89 functions and so are sometimes omitted from 119 ** the <stdio.h> header */ 120 extern FILE *popen(const char*,const char*); 121 extern int pclose(FILE*); 122 #else 123 # define SQLITE_OMIT_POPEN 1 124 #endif 125 126 #endif 127 128 #if defined(_WIN32_WCE) 129 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() 130 * thus we always assume that we have a console. That can be 131 * overridden with the -batch command line option. 132 */ 133 #define isatty(x) 1 134 #endif 135 136 /* ctype macros that work with signed characters */ 137 #define IsSpace(X) isspace((unsigned char)X) 138 #define IsDigit(X) isdigit((unsigned char)X) 139 #define ToLower(X) (char)tolower((unsigned char)X) 140 141 /* On Windows, we normally run with output mode of TEXT so that \n characters 142 ** are automatically translated into \r\n. However, this behavior needs 143 ** to be disabled in some cases (ex: when generating CSV output and when 144 ** rendering quoted strings that contain \n characters). The following 145 ** routines take care of that. 146 */ 147 #if defined(_WIN32) || defined(WIN32) 148 static void setBinaryMode(FILE *out){ 149 fflush(out); 150 _setmode(_fileno(out), _O_BINARY); 151 } 152 static void setTextMode(FILE *out){ 153 fflush(out); 154 _setmode(_fileno(out), _O_TEXT); 155 } 156 #else 157 # define setBinaryMode(X) 158 # define setTextMode(X) 159 #endif 160 161 162 /* True if the timer is enabled */ 163 static int enableTimer = 0; 164 165 /* Return the current wall-clock time */ 166 static sqlite3_int64 timeOfDay(void){ 167 static sqlite3_vfs *clockVfs = 0; 168 sqlite3_int64 t; 169 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0); 170 if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){ 171 clockVfs->xCurrentTimeInt64(clockVfs, &t); 172 }else{ 173 double r; 174 clockVfs->xCurrentTime(clockVfs, &r); 175 t = (sqlite3_int64)(r*86400000.0); 176 } 177 return t; 178 } 179 180 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux) 181 #include <sys/time.h> 182 #include <sys/resource.h> 183 184 /* VxWorks does not support getrusage() as far as we can determine */ 185 #if defined(_WRS_KERNEL) || defined(__RTP__) 186 struct rusage { 187 struct timeval ru_utime; /* user CPU time used */ 188 struct timeval ru_stime; /* system CPU time used */ 189 }; 190 #define getrusage(A,B) memset(B,0,sizeof(*B)) 191 #endif 192 193 /* Saved resource information for the beginning of an operation */ 194 static struct rusage sBegin; /* CPU time at start */ 195 static sqlite3_int64 iBegin; /* Wall-clock time at start */ 196 197 /* 198 ** Begin timing an operation 199 */ 200 static void beginTimer(void){ 201 if( enableTimer ){ 202 getrusage(RUSAGE_SELF, &sBegin); 203 iBegin = timeOfDay(); 204 } 205 } 206 207 /* Return the difference of two time_structs in seconds */ 208 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ 209 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + 210 (double)(pEnd->tv_sec - pStart->tv_sec); 211 } 212 213 /* 214 ** Print the timing results. 215 */ 216 static void endTimer(void){ 217 if( enableTimer ){ 218 sqlite3_int64 iEnd = timeOfDay(); 219 struct rusage sEnd; 220 getrusage(RUSAGE_SELF, &sEnd); 221 printf("Run Time: real %.3f user %f sys %f\n", 222 (iEnd - iBegin)*0.001, 223 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), 224 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); 225 } 226 } 227 228 #define BEGIN_TIMER beginTimer() 229 #define END_TIMER endTimer() 230 #define HAS_TIMER 1 231 232 #elif (defined(_WIN32) || defined(WIN32)) 233 234 #include <windows.h> 235 236 /* Saved resource information for the beginning of an operation */ 237 static HANDLE hProcess; 238 static FILETIME ftKernelBegin; 239 static FILETIME ftUserBegin; 240 static sqlite3_int64 ftWallBegin; 241 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, 242 LPFILETIME, LPFILETIME); 243 static GETPROCTIMES getProcessTimesAddr = NULL; 244 245 /* 246 ** Check to see if we have timer support. Return 1 if necessary 247 ** support found (or found previously). 248 */ 249 static int hasTimer(void){ 250 if( getProcessTimesAddr ){ 251 return 1; 252 } else { 253 /* GetProcessTimes() isn't supported in WIN95 and some other Windows 254 ** versions. See if the version we are running on has it, and if it 255 ** does, save off a pointer to it and the current process handle. 256 */ 257 hProcess = GetCurrentProcess(); 258 if( hProcess ){ 259 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); 260 if( NULL != hinstLib ){ 261 getProcessTimesAddr = 262 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); 263 if( NULL != getProcessTimesAddr ){ 264 return 1; 265 } 266 FreeLibrary(hinstLib); 267 } 268 } 269 } 270 return 0; 271 } 272 273 /* 274 ** Begin timing an operation 275 */ 276 static void beginTimer(void){ 277 if( enableTimer && getProcessTimesAddr ){ 278 FILETIME ftCreation, ftExit; 279 getProcessTimesAddr(hProcess,&ftCreation,&ftExit, 280 &ftKernelBegin,&ftUserBegin); 281 ftWallBegin = timeOfDay(); 282 } 283 } 284 285 /* Return the difference of two FILETIME structs in seconds */ 286 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ 287 sqlite_int64 i64Start = *((sqlite_int64 *) pStart); 288 sqlite_int64 i64End = *((sqlite_int64 *) pEnd); 289 return (double) ((i64End - i64Start) / 10000000.0); 290 } 291 292 /* 293 ** Print the timing results. 294 */ 295 static void endTimer(void){ 296 if( enableTimer && getProcessTimesAddr){ 297 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; 298 sqlite3_int64 ftWallEnd = timeOfDay(); 299 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd); 300 printf("Run Time: real %.3f user %f sys %f\n", 301 (ftWallEnd - ftWallBegin)*0.001, 302 timeDiff(&ftUserBegin, &ftUserEnd), 303 timeDiff(&ftKernelBegin, &ftKernelEnd)); 304 } 305 } 306 307 #define BEGIN_TIMER beginTimer() 308 #define END_TIMER endTimer() 309 #define HAS_TIMER hasTimer() 310 311 #else 312 #define BEGIN_TIMER 313 #define END_TIMER 314 #define HAS_TIMER 0 315 #endif 316 317 /* 318 ** Used to prevent warnings about unused parameters 319 */ 320 #define UNUSED_PARAMETER(x) (void)(x) 321 322 /* 323 ** If the following flag is set, then command execution stops 324 ** at an error if we are not interactive. 325 */ 326 static int bail_on_error = 0; 327 328 /* 329 ** Threat stdin as an interactive input if the following variable 330 ** is true. Otherwise, assume stdin is connected to a file or pipe. 331 */ 332 static int stdin_is_interactive = 1; 333 334 /* 335 ** The following is the open SQLite database. We make a pointer 336 ** to this database a static variable so that it can be accessed 337 ** by the SIGINT handler to interrupt database processing. 338 */ 339 static sqlite3 *db = 0; 340 341 /* 342 ** True if an interrupt (Control-C) has been received. 343 */ 344 static volatile int seenInterrupt = 0; 345 346 /* 347 ** This is the name of our program. It is set in main(), used 348 ** in a number of other places, mostly for error messages. 349 */ 350 static char *Argv0; 351 352 /* 353 ** Prompt strings. Initialized in main. Settable with 354 ** .prompt main continue 355 */ 356 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ 357 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ 358 359 /* 360 ** Write I/O traces to the following stream. 361 */ 362 #ifdef SQLITE_ENABLE_IOTRACE 363 static FILE *iotrace = 0; 364 #endif 365 366 /* 367 ** This routine works like printf in that its first argument is a 368 ** format string and subsequent arguments are values to be substituted 369 ** in place of % fields. The result of formatting this string 370 ** is written to iotrace. 371 */ 372 #ifdef SQLITE_ENABLE_IOTRACE 373 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){ 374 va_list ap; 375 char *z; 376 if( iotrace==0 ) return; 377 va_start(ap, zFormat); 378 z = sqlite3_vmprintf(zFormat, ap); 379 va_end(ap); 380 fprintf(iotrace, "%s", z); 381 sqlite3_free(z); 382 } 383 #endif 384 385 386 /* 387 ** Determines if a string is a number of not. 388 */ 389 static int isNumber(const char *z, int *realnum){ 390 if( *z=='-' || *z=='+' ) z++; 391 if( !IsDigit(*z) ){ 392 return 0; 393 } 394 z++; 395 if( realnum ) *realnum = 0; 396 while( IsDigit(*z) ){ z++; } 397 if( *z=='.' ){ 398 z++; 399 if( !IsDigit(*z) ) return 0; 400 while( IsDigit(*z) ){ z++; } 401 if( realnum ) *realnum = 1; 402 } 403 if( *z=='e' || *z=='E' ){ 404 z++; 405 if( *z=='+' || *z=='-' ) z++; 406 if( !IsDigit(*z) ) return 0; 407 while( IsDigit(*z) ){ z++; } 408 if( realnum ) *realnum = 1; 409 } 410 return *z==0; 411 } 412 413 /* 414 ** A global char* and an SQL function to access its current value 415 ** from within an SQL statement. This program used to use the 416 ** sqlite_exec_printf() API to substitue a string into an SQL statement. 417 ** The correct way to do this with sqlite3 is to use the bind API, but 418 ** since the shell is built around the callback paradigm it would be a lot 419 ** of work. Instead just use this hack, which is quite harmless. 420 */ 421 static const char *zShellStatic = 0; 422 static void shellstaticFunc( 423 sqlite3_context *context, 424 int argc, 425 sqlite3_value **argv 426 ){ 427 assert( 0==argc ); 428 assert( zShellStatic ); 429 UNUSED_PARAMETER(argc); 430 UNUSED_PARAMETER(argv); 431 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC); 432 } 433 434 435 /* 436 ** This routine reads a line of text from FILE in, stores 437 ** the text in memory obtained from malloc() and returns a pointer 438 ** to the text. NULL is returned at end of file, or if malloc() 439 ** fails. 440 ** 441 ** If zLine is not NULL then it is a malloced buffer returned from 442 ** a previous call to this routine that may be reused. 443 */ 444 static char *local_getline(char *zLine, FILE *in){ 445 int nLine = zLine==0 ? 0 : 100; 446 int n = 0; 447 448 while( 1 ){ 449 if( n+100>nLine ){ 450 nLine = nLine*2 + 100; 451 zLine = realloc(zLine, nLine); 452 if( zLine==0 ) return 0; 453 } 454 if( fgets(&zLine[n], nLine - n, in)==0 ){ 455 if( n==0 ){ 456 free(zLine); 457 return 0; 458 } 459 zLine[n] = 0; 460 break; 461 } 462 while( zLine[n] ) n++; 463 if( n>0 && zLine[n-1]=='\n' ){ 464 n--; 465 if( n>0 && zLine[n-1]=='\r' ) n--; 466 zLine[n] = 0; 467 break; 468 } 469 } 470 return zLine; 471 } 472 473 /* 474 ** Retrieve a single line of input text. 475 ** 476 ** If in==0 then read from standard input and prompt before each line. 477 ** If isContinuation is true, then a continuation prompt is appropriate. 478 ** If isContinuation is zero, then the main prompt should be used. 479 ** 480 ** If zPrior is not NULL then it is a buffer from a prior call to this 481 ** routine that can be reused. 482 ** 483 ** The result is stored in space obtained from malloc() and must either 484 ** be freed by the caller or else passed back into this routine via the 485 ** zPrior argument for reuse. 486 */ 487 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){ 488 char *zPrompt; 489 char *zResult; 490 if( in!=0 ){ 491 zResult = local_getline(zPrior, in); 492 }else{ 493 zPrompt = isContinuation ? continuePrompt : mainPrompt; 494 #if SHELL_USE_LOCAL_GETLINE 495 printf("%s", zPrompt); 496 fflush(stdout); 497 zResult = local_getline(zPrior, stdin); 498 #else 499 free(zPrior); 500 zResult = shell_readline(zPrompt); 501 if( zResult && *zResult ) shell_add_history(zResult); 502 #endif 503 } 504 return zResult; 505 } 506 507 /* 508 ** Shell output mode information from before ".explain on", 509 ** saved so that it can be restored by ".explain off" 510 */ 511 typedef struct SavedModeInfo SavedModeInfo; 512 struct SavedModeInfo { 513 int valid; /* Is there legit data in here? */ 514 int mode; /* Mode prior to ".explain on" */ 515 int showHeader; /* The ".header" setting prior to ".explain on" */ 516 int colWidth[100]; /* Column widths prior to ".explain on" */ 517 }; 518 519 /* 520 ** State information about the database connection is contained in an 521 ** instance of the following structure. 522 */ 523 typedef struct ShellState ShellState; 524 struct ShellState { 525 sqlite3 *db; /* The database */ 526 int echoOn; /* True to echo input commands */ 527 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */ 528 int statsOn; /* True to display memory stats before each finalize */ 529 int scanstatsOn; /* True to display scan stats before each finalize */ 530 int outCount; /* Revert to stdout when reaching zero */ 531 int cnt; /* Number of records displayed so far */ 532 FILE *out; /* Write results here */ 533 FILE *traceOut; /* Output for sqlite3_trace() */ 534 int nErr; /* Number of errors seen */ 535 int mode; /* An output mode setting */ 536 int writableSchema; /* True if PRAGMA writable_schema=ON */ 537 int showHeader; /* True to show column names in List or Column mode */ 538 unsigned shellFlgs; /* Various flags */ 539 char *zDestTable; /* Name of destination table when MODE_Insert */ 540 char colSeparator[20]; /* Column separator character for several modes */ 541 char rowSeparator[20]; /* Row separator character for MODE_Ascii */ 542 int colWidth[100]; /* Requested width of each column when in column mode*/ 543 int actualWidth[100]; /* Actual width of each column */ 544 char nullValue[20]; /* The text to print when a NULL comes back from 545 ** the database */ 546 SavedModeInfo normalMode;/* Holds the mode just before .explain ON */ 547 char outfile[FILENAME_MAX]; /* Filename for *out */ 548 const char *zDbFilename; /* name of the database file */ 549 char *zFreeOnClose; /* Filename to free when closing */ 550 const char *zVfs; /* Name of VFS to use */ 551 sqlite3_stmt *pStmt; /* Current statement if any. */ 552 FILE *pLog; /* Write log output here */ 553 int *aiIndent; /* Array of indents used in MODE_Explain */ 554 int nIndent; /* Size of array aiIndent[] */ 555 int iIndent; /* Index of current op in aiIndent[] */ 556 }; 557 558 /* 559 ** These are the allowed shellFlgs values 560 */ 561 #define SHFLG_Scratch 0x00001 /* The --scratch option is used */ 562 #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */ 563 #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */ 564 565 /* 566 ** These are the allowed modes. 567 */ 568 #define MODE_Line 0 /* One column per line. Blank line between records */ 569 #define MODE_Column 1 /* One record per line in neat columns */ 570 #define MODE_List 2 /* One record per line with a separator */ 571 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ 572 #define MODE_Html 4 /* Generate an XHTML table */ 573 #define MODE_Insert 5 /* Generate SQL "insert" statements */ 574 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */ 575 #define MODE_Csv 7 /* Quote strings, numbers are plain */ 576 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */ 577 #define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */ 578 579 static const char *modeDescr[] = { 580 "line", 581 "column", 582 "list", 583 "semi", 584 "html", 585 "insert", 586 "tcl", 587 "csv", 588 "explain", 589 "ascii", 590 }; 591 592 /* 593 ** These are the column/row/line separators used by the various 594 ** import/export modes. 595 */ 596 #define SEP_Column "|" 597 #define SEP_Row "\n" 598 #define SEP_Tab "\t" 599 #define SEP_Space " " 600 #define SEP_Comma "," 601 #define SEP_CrLf "\r\n" 602 #define SEP_Unit "\x1F" 603 #define SEP_Record "\x1E" 604 605 /* 606 ** Number of elements in an array 607 */ 608 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) 609 610 /* 611 ** Compute a string length that is limited to what can be stored in 612 ** lower 30 bits of a 32-bit signed integer. 613 */ 614 static int strlen30(const char *z){ 615 const char *z2 = z; 616 while( *z2 ){ z2++; } 617 return 0x3fffffff & (int)(z2 - z); 618 } 619 620 /* 621 ** A callback for the sqlite3_log() interface. 622 */ 623 static void shellLog(void *pArg, int iErrCode, const char *zMsg){ 624 ShellState *p = (ShellState*)pArg; 625 if( p->pLog==0 ) return; 626 fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg); 627 fflush(p->pLog); 628 } 629 630 /* 631 ** Output the given string as a hex-encoded blob (eg. X'1234' ) 632 */ 633 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ 634 int i; 635 char *zBlob = (char *)pBlob; 636 fprintf(out,"X'"); 637 for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); } 638 fprintf(out,"'"); 639 } 640 641 /* 642 ** Output the given string as a quoted string using SQL quoting conventions. 643 */ 644 static void output_quoted_string(FILE *out, const char *z){ 645 int i; 646 int nSingle = 0; 647 setBinaryMode(out); 648 for(i=0; z[i]; i++){ 649 if( z[i]=='\'' ) nSingle++; 650 } 651 if( nSingle==0 ){ 652 fprintf(out,"'%s'",z); 653 }else{ 654 fprintf(out,"'"); 655 while( *z ){ 656 for(i=0; z[i] && z[i]!='\''; i++){} 657 if( i==0 ){ 658 fprintf(out,"''"); 659 z++; 660 }else if( z[i]=='\'' ){ 661 fprintf(out,"%.*s''",i,z); 662 z += i+1; 663 }else{ 664 fprintf(out,"%s",z); 665 break; 666 } 667 } 668 fprintf(out,"'"); 669 } 670 setTextMode(out); 671 } 672 673 /* 674 ** Output the given string as a quoted according to C or TCL quoting rules. 675 */ 676 static void output_c_string(FILE *out, const char *z){ 677 unsigned int c; 678 fputc('"', out); 679 while( (c = *(z++))!=0 ){ 680 if( c=='\\' ){ 681 fputc(c, out); 682 fputc(c, out); 683 }else if( c=='"' ){ 684 fputc('\\', out); 685 fputc('"', out); 686 }else if( c=='\t' ){ 687 fputc('\\', out); 688 fputc('t', out); 689 }else if( c=='\n' ){ 690 fputc('\\', out); 691 fputc('n', out); 692 }else if( c=='\r' ){ 693 fputc('\\', out); 694 fputc('r', out); 695 }else if( !isprint(c&0xff) ){ 696 fprintf(out, "\\%03o", c&0xff); 697 }else{ 698 fputc(c, out); 699 } 700 } 701 fputc('"', out); 702 } 703 704 /* 705 ** Output the given string with characters that are special to 706 ** HTML escaped. 707 */ 708 static void output_html_string(FILE *out, const char *z){ 709 int i; 710 if( z==0 ) z = ""; 711 while( *z ){ 712 for(i=0; z[i] 713 && z[i]!='<' 714 && z[i]!='&' 715 && z[i]!='>' 716 && z[i]!='\"' 717 && z[i]!='\''; 718 i++){} 719 if( i>0 ){ 720 fprintf(out,"%.*s",i,z); 721 } 722 if( z[i]=='<' ){ 723 fprintf(out,"<"); 724 }else if( z[i]=='&' ){ 725 fprintf(out,"&"); 726 }else if( z[i]=='>' ){ 727 fprintf(out,">"); 728 }else if( z[i]=='\"' ){ 729 fprintf(out,"""); 730 }else if( z[i]=='\'' ){ 731 fprintf(out,"'"); 732 }else{ 733 break; 734 } 735 z += i + 1; 736 } 737 } 738 739 /* 740 ** If a field contains any character identified by a 1 in the following 741 ** array, then the string must be quoted for CSV. 742 */ 743 static const char needCsvQuote[] = { 744 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 745 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 746 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 747 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 748 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 750 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 751 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 752 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 753 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 754 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 755 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 756 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 757 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 758 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 759 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 760 }; 761 762 /* 763 ** Output a single term of CSV. Actually, p->colSeparator is used for 764 ** the separator, which may or may not be a comma. p->nullValue is 765 ** the null value. Strings are quoted if necessary. The separator 766 ** is only issued if bSep is true. 767 */ 768 static void output_csv(ShellState *p, const char *z, int bSep){ 769 FILE *out = p->out; 770 if( z==0 ){ 771 fprintf(out,"%s",p->nullValue); 772 }else{ 773 int i; 774 int nSep = strlen30(p->colSeparator); 775 for(i=0; z[i]; i++){ 776 if( needCsvQuote[((unsigned char*)z)[i]] 777 || (z[i]==p->colSeparator[0] && 778 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){ 779 i = 0; 780 break; 781 } 782 } 783 if( i==0 ){ 784 putc('"', out); 785 for(i=0; z[i]; i++){ 786 if( z[i]=='"' ) putc('"', out); 787 putc(z[i], out); 788 } 789 putc('"', out); 790 }else{ 791 fprintf(out, "%s", z); 792 } 793 } 794 if( bSep ){ 795 fprintf(p->out, "%s", p->colSeparator); 796 } 797 } 798 799 #ifdef SIGINT 800 /* 801 ** This routine runs when the user presses Ctrl-C 802 */ 803 static void interrupt_handler(int NotUsed){ 804 UNUSED_PARAMETER(NotUsed); 805 seenInterrupt++; 806 if( seenInterrupt>2 ) exit(1); 807 if( db ) sqlite3_interrupt(db); 808 } 809 #endif 810 811 /* 812 ** This is the callback routine that the shell 813 ** invokes for each row of a query result. 814 */ 815 static int shell_callback( 816 void *pArg, 817 int nArg, /* Number of result columns */ 818 char **azArg, /* Text of each result column */ 819 char **azCol, /* Column names */ 820 int *aiType /* Column types */ 821 ){ 822 int i; 823 ShellState *p = (ShellState*)pArg; 824 825 switch( p->mode ){ 826 case MODE_Line: { 827 int w = 5; 828 if( azArg==0 ) break; 829 for(i=0; i<nArg; i++){ 830 int len = strlen30(azCol[i] ? azCol[i] : ""); 831 if( len>w ) w = len; 832 } 833 if( p->cnt++>0 ) fprintf(p->out, "%s", p->rowSeparator); 834 for(i=0; i<nArg; i++){ 835 fprintf(p->out,"%*s = %s%s", w, azCol[i], 836 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator); 837 } 838 break; 839 } 840 case MODE_Explain: 841 case MODE_Column: { 842 if( p->cnt++==0 ){ 843 for(i=0; i<nArg; i++){ 844 int w, n; 845 if( i<ArraySize(p->colWidth) ){ 846 w = p->colWidth[i]; 847 }else{ 848 w = 0; 849 } 850 if( w==0 ){ 851 w = strlen30(azCol[i] ? azCol[i] : ""); 852 if( w<10 ) w = 10; 853 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue); 854 if( w<n ) w = n; 855 } 856 if( i<ArraySize(p->actualWidth) ){ 857 p->actualWidth[i] = w; 858 } 859 if( p->showHeader ){ 860 if( w<0 ){ 861 fprintf(p->out,"%*.*s%s",-w,-w,azCol[i], 862 i==nArg-1 ? p->rowSeparator : " "); 863 }else{ 864 fprintf(p->out,"%-*.*s%s",w,w,azCol[i], 865 i==nArg-1 ? p->rowSeparator : " "); 866 } 867 } 868 } 869 if( p->showHeader ){ 870 for(i=0; i<nArg; i++){ 871 int w; 872 if( i<ArraySize(p->actualWidth) ){ 873 w = p->actualWidth[i]; 874 if( w<0 ) w = -w; 875 }else{ 876 w = 10; 877 } 878 fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------" 879 "----------------------------------------------------------", 880 i==nArg-1 ? p->rowSeparator : " "); 881 } 882 } 883 } 884 if( azArg==0 ) break; 885 for(i=0; i<nArg; i++){ 886 int w; 887 if( i<ArraySize(p->actualWidth) ){ 888 w = p->actualWidth[i]; 889 }else{ 890 w = 10; 891 } 892 if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){ 893 w = strlen30(azArg[i]); 894 } 895 if( i==1 && p->aiIndent && p->pStmt ){ 896 if( p->iIndent<p->nIndent ){ 897 fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], ""); 898 } 899 p->iIndent++; 900 } 901 if( w<0 ){ 902 fprintf(p->out,"%*.*s%s",-w,-w, 903 azArg[i] ? azArg[i] : p->nullValue, 904 i==nArg-1 ? p->rowSeparator : " "); 905 }else{ 906 fprintf(p->out,"%-*.*s%s",w,w, 907 azArg[i] ? azArg[i] : p->nullValue, 908 i==nArg-1 ? p->rowSeparator : " "); 909 } 910 } 911 break; 912 } 913 case MODE_Semi: 914 case MODE_List: { 915 if( p->cnt++==0 && p->showHeader ){ 916 for(i=0; i<nArg; i++){ 917 fprintf(p->out,"%s%s",azCol[i], 918 i==nArg-1 ? p->rowSeparator : p->colSeparator); 919 } 920 } 921 if( azArg==0 ) break; 922 for(i=0; i<nArg; i++){ 923 char *z = azArg[i]; 924 if( z==0 ) z = p->nullValue; 925 fprintf(p->out, "%s", z); 926 if( i<nArg-1 ){ 927 fprintf(p->out, "%s", p->colSeparator); 928 }else if( p->mode==MODE_Semi ){ 929 fprintf(p->out, ";%s", p->rowSeparator); 930 }else{ 931 fprintf(p->out, "%s", p->rowSeparator); 932 } 933 } 934 break; 935 } 936 case MODE_Html: { 937 if( p->cnt++==0 && p->showHeader ){ 938 fprintf(p->out,"<TR>"); 939 for(i=0; i<nArg; i++){ 940 fprintf(p->out,"<TH>"); 941 output_html_string(p->out, azCol[i]); 942 fprintf(p->out,"</TH>\n"); 943 } 944 fprintf(p->out,"</TR>\n"); 945 } 946 if( azArg==0 ) break; 947 fprintf(p->out,"<TR>"); 948 for(i=0; i<nArg; i++){ 949 fprintf(p->out,"<TD>"); 950 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 951 fprintf(p->out,"</TD>\n"); 952 } 953 fprintf(p->out,"</TR>\n"); 954 break; 955 } 956 case MODE_Tcl: { 957 if( p->cnt++==0 && p->showHeader ){ 958 for(i=0; i<nArg; i++){ 959 output_c_string(p->out,azCol[i] ? azCol[i] : ""); 960 if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator); 961 } 962 fprintf(p->out, "%s", p->rowSeparator); 963 } 964 if( azArg==0 ) break; 965 for(i=0; i<nArg; i++){ 966 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 967 if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator); 968 } 969 fprintf(p->out, "%s", p->rowSeparator); 970 break; 971 } 972 case MODE_Csv: { 973 setBinaryMode(p->out); 974 if( p->cnt++==0 && p->showHeader ){ 975 for(i=0; i<nArg; i++){ 976 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1); 977 } 978 fprintf(p->out, "%s", p->rowSeparator); 979 } 980 if( nArg>0 ){ 981 for(i=0; i<nArg; i++){ 982 output_csv(p, azArg[i], i<nArg-1); 983 } 984 fprintf(p->out, "%s", p->rowSeparator); 985 } 986 setTextMode(p->out); 987 break; 988 } 989 case MODE_Insert: { 990 p->cnt++; 991 if( azArg==0 ) break; 992 fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable); 993 for(i=0; i<nArg; i++){ 994 char *zSep = i>0 ? ",": ""; 995 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 996 fprintf(p->out,"%sNULL",zSep); 997 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 998 if( zSep[0] ) fprintf(p->out,"%s",zSep); 999 output_quoted_string(p->out, azArg[i]); 1000 }else if( aiType && (aiType[i]==SQLITE_INTEGER 1001 || aiType[i]==SQLITE_FLOAT) ){ 1002 fprintf(p->out,"%s%s",zSep, azArg[i]); 1003 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 1004 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 1005 int nBlob = sqlite3_column_bytes(p->pStmt, i); 1006 if( zSep[0] ) fprintf(p->out,"%s",zSep); 1007 output_hex_blob(p->out, pBlob, nBlob); 1008 }else if( isNumber(azArg[i], 0) ){ 1009 fprintf(p->out,"%s%s",zSep, azArg[i]); 1010 }else{ 1011 if( zSep[0] ) fprintf(p->out,"%s",zSep); 1012 output_quoted_string(p->out, azArg[i]); 1013 } 1014 } 1015 fprintf(p->out,");\n"); 1016 break; 1017 } 1018 case MODE_Ascii: { 1019 if( p->cnt++==0 && p->showHeader ){ 1020 for(i=0; i<nArg; i++){ 1021 if( i>0 ) fprintf(p->out, "%s", p->colSeparator); 1022 fprintf(p->out,"%s",azCol[i] ? azCol[i] : ""); 1023 } 1024 fprintf(p->out, "%s", p->rowSeparator); 1025 } 1026 if( azArg==0 ) break; 1027 for(i=0; i<nArg; i++){ 1028 if( i>0 ) fprintf(p->out, "%s", p->colSeparator); 1029 fprintf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue); 1030 } 1031 fprintf(p->out, "%s", p->rowSeparator); 1032 break; 1033 } 1034 } 1035 return 0; 1036 } 1037 1038 /* 1039 ** This is the callback routine that the SQLite library 1040 ** invokes for each row of a query result. 1041 */ 1042 static int callback(void *pArg, int nArg, char **azArg, char **azCol){ 1043 /* since we don't have type info, call the shell_callback with a NULL value */ 1044 return shell_callback(pArg, nArg, azArg, azCol, NULL); 1045 } 1046 1047 /* 1048 ** Set the destination table field of the ShellState structure to 1049 ** the name of the table given. Escape any quote characters in the 1050 ** table name. 1051 */ 1052 static void set_table_name(ShellState *p, const char *zName){ 1053 int i, n; 1054 int needQuote; 1055 char *z; 1056 1057 if( p->zDestTable ){ 1058 free(p->zDestTable); 1059 p->zDestTable = 0; 1060 } 1061 if( zName==0 ) return; 1062 needQuote = !isalpha((unsigned char)*zName) && *zName!='_'; 1063 for(i=n=0; zName[i]; i++, n++){ 1064 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){ 1065 needQuote = 1; 1066 if( zName[i]=='\'' ) n++; 1067 } 1068 } 1069 if( needQuote ) n += 2; 1070 z = p->zDestTable = malloc( n+1 ); 1071 if( z==0 ){ 1072 fprintf(stderr,"Error: out of memory\n"); 1073 exit(1); 1074 } 1075 n = 0; 1076 if( needQuote ) z[n++] = '\''; 1077 for(i=0; zName[i]; i++){ 1078 z[n++] = zName[i]; 1079 if( zName[i]=='\'' ) z[n++] = '\''; 1080 } 1081 if( needQuote ) z[n++] = '\''; 1082 z[n] = 0; 1083 } 1084 1085 /* zIn is either a pointer to a NULL-terminated string in memory obtained 1086 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is 1087 ** added to zIn, and the result returned in memory obtained from malloc(). 1088 ** zIn, if it was not NULL, is freed. 1089 ** 1090 ** If the third argument, quote, is not '\0', then it is used as a 1091 ** quote character for zAppend. 1092 */ 1093 static char *appendText(char *zIn, char const *zAppend, char quote){ 1094 int len; 1095 int i; 1096 int nAppend = strlen30(zAppend); 1097 int nIn = (zIn?strlen30(zIn):0); 1098 1099 len = nAppend+nIn+1; 1100 if( quote ){ 1101 len += 2; 1102 for(i=0; i<nAppend; i++){ 1103 if( zAppend[i]==quote ) len++; 1104 } 1105 } 1106 1107 zIn = (char *)realloc(zIn, len); 1108 if( !zIn ){ 1109 return 0; 1110 } 1111 1112 if( quote ){ 1113 char *zCsr = &zIn[nIn]; 1114 *zCsr++ = quote; 1115 for(i=0; i<nAppend; i++){ 1116 *zCsr++ = zAppend[i]; 1117 if( zAppend[i]==quote ) *zCsr++ = quote; 1118 } 1119 *zCsr++ = quote; 1120 *zCsr++ = '\0'; 1121 assert( (zCsr-zIn)==len ); 1122 }else{ 1123 memcpy(&zIn[nIn], zAppend, nAppend); 1124 zIn[len-1] = '\0'; 1125 } 1126 1127 return zIn; 1128 } 1129 1130 1131 /* 1132 ** Execute a query statement that will generate SQL output. Print 1133 ** the result columns, comma-separated, on a line and then add a 1134 ** semicolon terminator to the end of that line. 1135 ** 1136 ** If the number of columns is 1 and that column contains text "--" 1137 ** then write the semicolon on a separate line. That way, if a 1138 ** "--" comment occurs at the end of the statement, the comment 1139 ** won't consume the semicolon terminator. 1140 */ 1141 static int run_table_dump_query( 1142 ShellState *p, /* Query context */ 1143 const char *zSelect, /* SELECT statement to extract content */ 1144 const char *zFirstRow /* Print before first row, if not NULL */ 1145 ){ 1146 sqlite3_stmt *pSelect; 1147 int rc; 1148 int nResult; 1149 int i; 1150 const char *z; 1151 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0); 1152 if( rc!=SQLITE_OK || !pSelect ){ 1153 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db)); 1154 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 1155 return rc; 1156 } 1157 rc = sqlite3_step(pSelect); 1158 nResult = sqlite3_column_count(pSelect); 1159 while( rc==SQLITE_ROW ){ 1160 if( zFirstRow ){ 1161 fprintf(p->out, "%s", zFirstRow); 1162 zFirstRow = 0; 1163 } 1164 z = (const char*)sqlite3_column_text(pSelect, 0); 1165 fprintf(p->out, "%s", z); 1166 for(i=1; i<nResult; i++){ 1167 fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i)); 1168 } 1169 if( z==0 ) z = ""; 1170 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++; 1171 if( z[0] ){ 1172 fprintf(p->out, "\n;\n"); 1173 }else{ 1174 fprintf(p->out, ";\n"); 1175 } 1176 rc = sqlite3_step(pSelect); 1177 } 1178 rc = sqlite3_finalize(pSelect); 1179 if( rc!=SQLITE_OK ){ 1180 fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db)); 1181 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 1182 } 1183 return rc; 1184 } 1185 1186 /* 1187 ** Allocate space and save off current error string. 1188 */ 1189 static char *save_err_msg( 1190 sqlite3 *db /* Database to query */ 1191 ){ 1192 int nErrMsg = 1+strlen30(sqlite3_errmsg(db)); 1193 char *zErrMsg = sqlite3_malloc(nErrMsg); 1194 if( zErrMsg ){ 1195 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg); 1196 } 1197 return zErrMsg; 1198 } 1199 1200 /* 1201 ** Display memory stats. 1202 */ 1203 static int display_stats( 1204 sqlite3 *db, /* Database to query */ 1205 ShellState *pArg, /* Pointer to ShellState */ 1206 int bReset /* True to reset the stats */ 1207 ){ 1208 int iCur; 1209 int iHiwtr; 1210 1211 if( pArg && pArg->out ){ 1212 1213 iHiwtr = iCur = -1; 1214 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset); 1215 fprintf(pArg->out, 1216 "Memory Used: %d (max %d) bytes\n", 1217 iCur, iHiwtr); 1218 iHiwtr = iCur = -1; 1219 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset); 1220 fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n", 1221 iCur, iHiwtr); 1222 if( pArg->shellFlgs & SHFLG_Pagecache ){ 1223 iHiwtr = iCur = -1; 1224 sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset); 1225 fprintf(pArg->out, 1226 "Number of Pcache Pages Used: %d (max %d) pages\n", 1227 iCur, iHiwtr); 1228 } 1229 iHiwtr = iCur = -1; 1230 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset); 1231 fprintf(pArg->out, 1232 "Number of Pcache Overflow Bytes: %d (max %d) bytes\n", 1233 iCur, iHiwtr); 1234 if( pArg->shellFlgs & SHFLG_Scratch ){ 1235 iHiwtr = iCur = -1; 1236 sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset); 1237 fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n", 1238 iCur, iHiwtr); 1239 } 1240 iHiwtr = iCur = -1; 1241 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset); 1242 fprintf(pArg->out, 1243 "Number of Scratch Overflow Bytes: %d (max %d) bytes\n", 1244 iCur, iHiwtr); 1245 iHiwtr = iCur = -1; 1246 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset); 1247 fprintf(pArg->out, "Largest Allocation: %d bytes\n", 1248 iHiwtr); 1249 iHiwtr = iCur = -1; 1250 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset); 1251 fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n", 1252 iHiwtr); 1253 iHiwtr = iCur = -1; 1254 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset); 1255 fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n", 1256 iHiwtr); 1257 #ifdef YYTRACKMAXSTACKDEPTH 1258 iHiwtr = iCur = -1; 1259 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset); 1260 fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n", 1261 iCur, iHiwtr); 1262 #endif 1263 } 1264 1265 if( pArg && pArg->out && db ){ 1266 if( pArg->shellFlgs & SHFLG_Lookaside ){ 1267 iHiwtr = iCur = -1; 1268 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, 1269 &iCur, &iHiwtr, bReset); 1270 fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n", 1271 iCur, iHiwtr); 1272 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, 1273 &iCur, &iHiwtr, bReset); 1274 fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr); 1275 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, 1276 &iCur, &iHiwtr, bReset); 1277 fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr); 1278 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, 1279 &iCur, &iHiwtr, bReset); 1280 fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr); 1281 } 1282 iHiwtr = iCur = -1; 1283 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset); 1284 fprintf(pArg->out, "Pager Heap Usage: %d bytes\n",iCur); 1285 iHiwtr = iCur = -1; 1286 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1); 1287 fprintf(pArg->out, "Page cache hits: %d\n", iCur); 1288 iHiwtr = iCur = -1; 1289 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1); 1290 fprintf(pArg->out, "Page cache misses: %d\n", iCur); 1291 iHiwtr = iCur = -1; 1292 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1); 1293 fprintf(pArg->out, "Page cache writes: %d\n", iCur); 1294 iHiwtr = iCur = -1; 1295 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset); 1296 fprintf(pArg->out, "Schema Heap Usage: %d bytes\n",iCur); 1297 iHiwtr = iCur = -1; 1298 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset); 1299 fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",iCur); 1300 } 1301 1302 if( pArg && pArg->out && db && pArg->pStmt ){ 1303 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, 1304 bReset); 1305 fprintf(pArg->out, "Fullscan Steps: %d\n", iCur); 1306 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset); 1307 fprintf(pArg->out, "Sort Operations: %d\n", iCur); 1308 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset); 1309 fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur); 1310 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset); 1311 fprintf(pArg->out, "Virtual Machine Steps: %d\n", iCur); 1312 } 1313 1314 return 0; 1315 } 1316 1317 /* 1318 ** Display scan stats. 1319 */ 1320 static void display_scanstats( 1321 sqlite3 *db, /* Database to query */ 1322 ShellState *pArg /* Pointer to ShellState */ 1323 ){ 1324 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS 1325 int i, k, n, mx; 1326 fprintf(pArg->out, "-------- scanstats --------\n"); 1327 mx = 0; 1328 for(k=0; k<=mx; k++){ 1329 double rEstLoop = 1.0; 1330 for(i=n=0; 1; i++){ 1331 sqlite3_stmt *p = pArg->pStmt; 1332 sqlite3_int64 nLoop, nVisit; 1333 double rEst; 1334 int iSid; 1335 const char *zExplain; 1336 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){ 1337 break; 1338 } 1339 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid); 1340 if( iSid>mx ) mx = iSid; 1341 if( iSid!=k ) continue; 1342 if( n==0 ){ 1343 rEstLoop = (double)nLoop; 1344 if( k>0 ) fprintf(pArg->out, "-------- subquery %d -------\n", k); 1345 } 1346 n++; 1347 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit); 1348 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst); 1349 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain); 1350 fprintf(pArg->out, "Loop %2d: %s\n", n, zExplain); 1351 rEstLoop *= rEst; 1352 fprintf(pArg->out, 1353 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n", 1354 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst 1355 ); 1356 } 1357 } 1358 fprintf(pArg->out, "---------------------------\n"); 1359 #endif 1360 } 1361 1362 /* 1363 ** Parameter azArray points to a zero-terminated array of strings. zStr 1364 ** points to a single nul-terminated string. Return non-zero if zStr 1365 ** is equal, according to strcmp(), to any of the strings in the array. 1366 ** Otherwise, return zero. 1367 */ 1368 static int str_in_array(const char *zStr, const char **azArray){ 1369 int i; 1370 for(i=0; azArray[i]; i++){ 1371 if( 0==strcmp(zStr, azArray[i]) ) return 1; 1372 } 1373 return 0; 1374 } 1375 1376 /* 1377 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate 1378 ** and populate the ShellState.aiIndent[] array with the number of 1379 ** spaces each opcode should be indented before it is output. 1380 ** 1381 ** The indenting rules are: 1382 ** 1383 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent 1384 ** all opcodes that occur between the p2 jump destination and the opcode 1385 ** itself by 2 spaces. 1386 ** 1387 ** * For each "Goto", if the jump destination is earlier in the program 1388 ** and ends on one of: 1389 ** Yield SeekGt SeekLt RowSetRead Rewind 1390 ** or if the P1 parameter is one instead of zero, 1391 ** then indent all opcodes between the earlier instruction 1392 ** and "Goto" by 2 spaces. 1393 */ 1394 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){ 1395 const char *zSql; /* The text of the SQL statement */ 1396 const char *z; /* Used to check if this is an EXPLAIN */ 1397 int *abYield = 0; /* True if op is an OP_Yield */ 1398 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */ 1399 int iOp; /* Index of operation in p->aiIndent[] */ 1400 1401 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 1402 "NextIfOpen", "PrevIfOpen", 0 }; 1403 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead", 1404 "Rewind", 0 }; 1405 const char *azGoto[] = { "Goto", 0 }; 1406 1407 /* Try to figure out if this is really an EXPLAIN statement. If this 1408 ** cannot be verified, return early. */ 1409 zSql = sqlite3_sql(pSql); 1410 if( zSql==0 ) return; 1411 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++); 1412 if( sqlite3_strnicmp(z, "explain", 7) ) return; 1413 1414 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){ 1415 int i; 1416 int iAddr = sqlite3_column_int(pSql, 0); 1417 const char *zOp = (const char*)sqlite3_column_text(pSql, 1); 1418 1419 /* Set p2 to the P2 field of the current opcode. Then, assuming that 1420 ** p2 is an instruction address, set variable p2op to the index of that 1421 ** instruction in the aiIndent[] array. p2 and p2op may be different if 1422 ** the current instruction is part of a sub-program generated by an 1423 ** SQL trigger or foreign key. */ 1424 int p2 = sqlite3_column_int(pSql, 3); 1425 int p2op = (p2 + (iOp-iAddr)); 1426 1427 /* Grow the p->aiIndent array as required */ 1428 if( iOp>=nAlloc ){ 1429 nAlloc += 100; 1430 p->aiIndent = (int*)sqlite3_realloc(p->aiIndent, nAlloc*sizeof(int)); 1431 abYield = (int*)sqlite3_realloc(abYield, nAlloc*sizeof(int)); 1432 } 1433 abYield[iOp] = str_in_array(zOp, azYield); 1434 p->aiIndent[iOp] = 0; 1435 p->nIndent = iOp+1; 1436 1437 if( str_in_array(zOp, azNext) ){ 1438 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 1439 } 1440 if( str_in_array(zOp, azGoto) && p2op<p->nIndent 1441 && (abYield[p2op] || sqlite3_column_int(pSql, 2)) 1442 ){ 1443 for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2; 1444 } 1445 } 1446 1447 p->iIndent = 0; 1448 sqlite3_free(abYield); 1449 sqlite3_reset(pSql); 1450 } 1451 1452 /* 1453 ** Free the array allocated by explain_data_prepare(). 1454 */ 1455 static void explain_data_delete(ShellState *p){ 1456 sqlite3_free(p->aiIndent); 1457 p->aiIndent = 0; 1458 p->nIndent = 0; 1459 p->iIndent = 0; 1460 } 1461 1462 /* 1463 ** Execute a statement or set of statements. Print 1464 ** any result rows/columns depending on the current mode 1465 ** set via the supplied callback. 1466 ** 1467 ** This is very similar to SQLite's built-in sqlite3_exec() 1468 ** function except it takes a slightly different callback 1469 ** and callback data argument. 1470 */ 1471 static int shell_exec( 1472 sqlite3 *db, /* An open database */ 1473 const char *zSql, /* SQL to be evaluated */ 1474 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */ 1475 /* (not the same as sqlite3_exec) */ 1476 ShellState *pArg, /* Pointer to ShellState */ 1477 char **pzErrMsg /* Error msg written here */ 1478 ){ 1479 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */ 1480 int rc = SQLITE_OK; /* Return Code */ 1481 int rc2; 1482 const char *zLeftover; /* Tail of unprocessed SQL */ 1483 1484 if( pzErrMsg ){ 1485 *pzErrMsg = NULL; 1486 } 1487 1488 while( zSql[0] && (SQLITE_OK == rc) ){ 1489 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); 1490 if( SQLITE_OK != rc ){ 1491 if( pzErrMsg ){ 1492 *pzErrMsg = save_err_msg(db); 1493 } 1494 }else{ 1495 if( !pStmt ){ 1496 /* this happens for a comment or white-space */ 1497 zSql = zLeftover; 1498 while( IsSpace(zSql[0]) ) zSql++; 1499 continue; 1500 } 1501 1502 /* save off the prepared statment handle and reset row count */ 1503 if( pArg ){ 1504 pArg->pStmt = pStmt; 1505 pArg->cnt = 0; 1506 } 1507 1508 /* echo the sql statement if echo on */ 1509 if( pArg && pArg->echoOn ){ 1510 const char *zStmtSql = sqlite3_sql(pStmt); 1511 fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql); 1512 } 1513 1514 /* Show the EXPLAIN QUERY PLAN if .eqp is on */ 1515 if( pArg && pArg->autoEQP ){ 1516 sqlite3_stmt *pExplain; 1517 char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", 1518 sqlite3_sql(pStmt)); 1519 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 1520 if( rc==SQLITE_OK ){ 1521 while( sqlite3_step(pExplain)==SQLITE_ROW ){ 1522 fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0)); 1523 fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1)); 1524 fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2)); 1525 fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3)); 1526 } 1527 } 1528 sqlite3_finalize(pExplain); 1529 sqlite3_free(zEQP); 1530 } 1531 1532 /* If the shell is currently in ".explain" mode, gather the extra 1533 ** data required to add indents to the output.*/ 1534 if( pArg && pArg->mode==MODE_Explain ){ 1535 explain_data_prepare(pArg, pStmt); 1536 } 1537 1538 /* perform the first step. this will tell us if we 1539 ** have a result set or not and how wide it is. 1540 */ 1541 rc = sqlite3_step(pStmt); 1542 /* if we have a result set... */ 1543 if( SQLITE_ROW == rc ){ 1544 /* if we have a callback... */ 1545 if( xCallback ){ 1546 /* allocate space for col name ptr, value ptr, and type */ 1547 int nCol = sqlite3_column_count(pStmt); 1548 void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1); 1549 if( !pData ){ 1550 rc = SQLITE_NOMEM; 1551 }else{ 1552 char **azCols = (char **)pData; /* Names of result columns */ 1553 char **azVals = &azCols[nCol]; /* Results */ 1554 int *aiTypes = (int *)&azVals[nCol]; /* Result types */ 1555 int i, x; 1556 assert(sizeof(int) <= sizeof(char *)); 1557 /* save off ptrs to column names */ 1558 for(i=0; i<nCol; i++){ 1559 azCols[i] = (char *)sqlite3_column_name(pStmt, i); 1560 } 1561 do{ 1562 /* extract the data and data types */ 1563 for(i=0; i<nCol; i++){ 1564 aiTypes[i] = x = sqlite3_column_type(pStmt, i); 1565 if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){ 1566 azVals[i] = ""; 1567 }else{ 1568 azVals[i] = (char*)sqlite3_column_text(pStmt, i); 1569 } 1570 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){ 1571 rc = SQLITE_NOMEM; 1572 break; /* from for */ 1573 } 1574 } /* end for */ 1575 1576 /* if data and types extracted successfully... */ 1577 if( SQLITE_ROW == rc ){ 1578 /* call the supplied callback with the result row data */ 1579 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){ 1580 rc = SQLITE_ABORT; 1581 }else{ 1582 rc = sqlite3_step(pStmt); 1583 } 1584 } 1585 } while( SQLITE_ROW == rc ); 1586 sqlite3_free(pData); 1587 } 1588 }else{ 1589 do{ 1590 rc = sqlite3_step(pStmt); 1591 } while( rc == SQLITE_ROW ); 1592 } 1593 } 1594 1595 explain_data_delete(pArg); 1596 1597 /* print usage stats if stats on */ 1598 if( pArg && pArg->statsOn ){ 1599 display_stats(db, pArg, 0); 1600 } 1601 1602 /* print loop-counters if required */ 1603 if( pArg && pArg->scanstatsOn ){ 1604 display_scanstats(db, pArg); 1605 } 1606 1607 /* Finalize the statement just executed. If this fails, save a 1608 ** copy of the error message. Otherwise, set zSql to point to the 1609 ** next statement to execute. */ 1610 rc2 = sqlite3_finalize(pStmt); 1611 if( rc!=SQLITE_NOMEM ) rc = rc2; 1612 if( rc==SQLITE_OK ){ 1613 zSql = zLeftover; 1614 while( IsSpace(zSql[0]) ) zSql++; 1615 }else if( pzErrMsg ){ 1616 *pzErrMsg = save_err_msg(db); 1617 } 1618 1619 /* clear saved stmt handle */ 1620 if( pArg ){ 1621 pArg->pStmt = NULL; 1622 } 1623 } 1624 } /* end while */ 1625 1626 return rc; 1627 } 1628 1629 1630 /* 1631 ** This is a different callback routine used for dumping the database. 1632 ** Each row received by this callback consists of a table name, 1633 ** the table type ("index" or "table") and SQL to create the table. 1634 ** This routine should print text sufficient to recreate the table. 1635 */ 1636 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){ 1637 int rc; 1638 const char *zTable; 1639 const char *zType; 1640 const char *zSql; 1641 const char *zPrepStmt = 0; 1642 ShellState *p = (ShellState *)pArg; 1643 1644 UNUSED_PARAMETER(azCol); 1645 if( nArg!=3 ) return 1; 1646 zTable = azArg[0]; 1647 zType = azArg[1]; 1648 zSql = azArg[2]; 1649 1650 if( strcmp(zTable, "sqlite_sequence")==0 ){ 1651 zPrepStmt = "DELETE FROM sqlite_sequence;\n"; 1652 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){ 1653 fprintf(p->out, "ANALYZE sqlite_master;\n"); 1654 }else if( strncmp(zTable, "sqlite_", 7)==0 ){ 1655 return 0; 1656 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ 1657 char *zIns; 1658 if( !p->writableSchema ){ 1659 fprintf(p->out, "PRAGMA writable_schema=ON;\n"); 1660 p->writableSchema = 1; 1661 } 1662 zIns = sqlite3_mprintf( 1663 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)" 1664 "VALUES('table','%q','%q',0,'%q');", 1665 zTable, zTable, zSql); 1666 fprintf(p->out, "%s\n", zIns); 1667 sqlite3_free(zIns); 1668 return 0; 1669 }else{ 1670 fprintf(p->out, "%s;\n", zSql); 1671 } 1672 1673 if( strcmp(zType, "table")==0 ){ 1674 sqlite3_stmt *pTableInfo = 0; 1675 char *zSelect = 0; 1676 char *zTableInfo = 0; 1677 char *zTmp = 0; 1678 int nRow = 0; 1679 1680 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0); 1681 zTableInfo = appendText(zTableInfo, zTable, '"'); 1682 zTableInfo = appendText(zTableInfo, ");", 0); 1683 1684 rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0); 1685 free(zTableInfo); 1686 if( rc!=SQLITE_OK || !pTableInfo ){ 1687 return 1; 1688 } 1689 1690 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0); 1691 /* Always quote the table name, even if it appears to be pure ascii, 1692 ** in case it is a keyword. Ex: INSERT INTO "table" ... */ 1693 zTmp = appendText(zTmp, zTable, '"'); 1694 if( zTmp ){ 1695 zSelect = appendText(zSelect, zTmp, '\''); 1696 free(zTmp); 1697 } 1698 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0); 1699 rc = sqlite3_step(pTableInfo); 1700 while( rc==SQLITE_ROW ){ 1701 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1); 1702 zSelect = appendText(zSelect, "quote(", 0); 1703 zSelect = appendText(zSelect, zText, '"'); 1704 rc = sqlite3_step(pTableInfo); 1705 if( rc==SQLITE_ROW ){ 1706 zSelect = appendText(zSelect, "), ", 0); 1707 }else{ 1708 zSelect = appendText(zSelect, ") ", 0); 1709 } 1710 nRow++; 1711 } 1712 rc = sqlite3_finalize(pTableInfo); 1713 if( rc!=SQLITE_OK || nRow==0 ){ 1714 free(zSelect); 1715 return 1; 1716 } 1717 zSelect = appendText(zSelect, "|| ')' FROM ", 0); 1718 zSelect = appendText(zSelect, zTable, '"'); 1719 1720 rc = run_table_dump_query(p, zSelect, zPrepStmt); 1721 if( rc==SQLITE_CORRUPT ){ 1722 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0); 1723 run_table_dump_query(p, zSelect, 0); 1724 } 1725 free(zSelect); 1726 } 1727 return 0; 1728 } 1729 1730 /* 1731 ** Run zQuery. Use dump_callback() as the callback routine so that 1732 ** the contents of the query are output as SQL statements. 1733 ** 1734 ** If we get a SQLITE_CORRUPT error, rerun the query after appending 1735 ** "ORDER BY rowid DESC" to the end. 1736 */ 1737 static int run_schema_dump_query( 1738 ShellState *p, 1739 const char *zQuery 1740 ){ 1741 int rc; 1742 char *zErr = 0; 1743 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr); 1744 if( rc==SQLITE_CORRUPT ){ 1745 char *zQ2; 1746 int len = strlen30(zQuery); 1747 fprintf(p->out, "/****** CORRUPTION ERROR *******/\n"); 1748 if( zErr ){ 1749 fprintf(p->out, "/****** %s ******/\n", zErr); 1750 sqlite3_free(zErr); 1751 zErr = 0; 1752 } 1753 zQ2 = malloc( len+100 ); 1754 if( zQ2==0 ) return rc; 1755 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery); 1756 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr); 1757 if( rc ){ 1758 fprintf(p->out, "/****** ERROR: %s ******/\n", zErr); 1759 }else{ 1760 rc = SQLITE_CORRUPT; 1761 } 1762 sqlite3_free(zErr); 1763 free(zQ2); 1764 } 1765 return rc; 1766 } 1767 1768 /* 1769 ** Text of a help message 1770 */ 1771 static char zHelp[] = 1772 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n" 1773 ".bail on|off Stop after hitting an error. Default OFF\n" 1774 ".clone NEWDB Clone data into NEWDB from the existing database\n" 1775 ".databases List names and files of attached databases\n" 1776 ".dbinfo ?DB? Show status information about the database\n" 1777 ".dump ?TABLE? ... Dump the database in an SQL text format\n" 1778 " If TABLE specified, only dump tables matching\n" 1779 " LIKE pattern TABLE.\n" 1780 ".echo on|off Turn command echo on or off\n" 1781 ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n" 1782 ".exit Exit this program\n" 1783 ".explain ?on|off? Turn output mode suitable for EXPLAIN on or off.\n" 1784 " With no args, it turns EXPLAIN on.\n" 1785 ".fullschema Show schema and the content of sqlite_stat tables\n" 1786 ".headers on|off Turn display of headers on or off\n" 1787 ".help Show this message\n" 1788 ".import FILE TABLE Import data from FILE into TABLE\n" 1789 ".indexes ?TABLE? Show names of all indexes\n" 1790 " If TABLE specified, only show indexes for tables\n" 1791 " matching LIKE pattern TABLE.\n" 1792 #ifdef SQLITE_ENABLE_IOTRACE 1793 ".iotrace FILE Enable I/O diagnostic logging to FILE\n" 1794 #endif 1795 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1796 ".load FILE ?ENTRY? Load an extension library\n" 1797 #endif 1798 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n" 1799 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n" 1800 " ascii Columns/rows delimited by 0x1F and 0x1E\n" 1801 " csv Comma-separated values\n" 1802 " column Left-aligned columns. (See .width)\n" 1803 " html HTML <table> code\n" 1804 " insert SQL insert statements for TABLE\n" 1805 " line One value per line\n" 1806 " list Values delimited by .separator strings\n" 1807 " tabs Tab-separated values\n" 1808 " tcl TCL list elements\n" 1809 ".nullvalue STRING Use STRING in place of NULL values\n" 1810 ".once FILENAME Output for the next SQL command only to FILENAME\n" 1811 ".open ?FILENAME? Close existing database and reopen FILENAME\n" 1812 ".output ?FILENAME? Send output to FILENAME or stdout\n" 1813 ".print STRING... Print literal STRING\n" 1814 ".prompt MAIN CONTINUE Replace the standard prompts\n" 1815 ".quit Exit this program\n" 1816 ".read FILENAME Execute SQL in FILENAME\n" 1817 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n" 1818 ".save FILE Write in-memory database into FILE\n" 1819 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n" 1820 ".schema ?TABLE? Show the CREATE statements\n" 1821 " If TABLE specified, only show tables matching\n" 1822 " LIKE pattern TABLE.\n" 1823 ".separator COL ?ROW? Change the column separator and optionally the row\n" 1824 " separator for both the output mode and .import\n" 1825 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n" 1826 ".show Show the current values for various settings\n" 1827 ".stats on|off Turn stats on or off\n" 1828 ".system CMD ARGS... Run CMD ARGS... in a system shell\n" 1829 ".tables ?TABLE? List names of tables\n" 1830 " If TABLE specified, only list tables matching\n" 1831 " LIKE pattern TABLE.\n" 1832 ".timeout MS Try opening locked tables for MS milliseconds\n" 1833 ".timer on|off Turn SQL timer on or off\n" 1834 ".trace FILE|off Output each SQL statement as it is run\n" 1835 ".vfsname ?AUX? Print the name of the VFS stack\n" 1836 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n" 1837 " Negative values right-justify\n" 1838 ; 1839 1840 /* Forward reference */ 1841 static int process_input(ShellState *p, FILE *in); 1842 /* 1843 ** Implementation of the "readfile(X)" SQL function. The entire content 1844 ** of the file named X is read and returned as a BLOB. NULL is returned 1845 ** if the file does not exist or is unreadable. 1846 */ 1847 static void readfileFunc( 1848 sqlite3_context *context, 1849 int argc, 1850 sqlite3_value **argv 1851 ){ 1852 const char *zName; 1853 FILE *in; 1854 long nIn; 1855 void *pBuf; 1856 1857 zName = (const char*)sqlite3_value_text(argv[0]); 1858 if( zName==0 ) return; 1859 in = fopen(zName, "rb"); 1860 if( in==0 ) return; 1861 fseek(in, 0, SEEK_END); 1862 nIn = ftell(in); 1863 rewind(in); 1864 pBuf = sqlite3_malloc( nIn ); 1865 if( pBuf && 1==fread(pBuf, nIn, 1, in) ){ 1866 sqlite3_result_blob(context, pBuf, nIn, sqlite3_free); 1867 }else{ 1868 sqlite3_free(pBuf); 1869 } 1870 fclose(in); 1871 } 1872 1873 /* 1874 ** Implementation of the "writefile(X,Y)" SQL function. The argument Y 1875 ** is written into file X. The number of bytes written is returned. Or 1876 ** NULL is returned if something goes wrong, such as being unable to open 1877 ** file X for writing. 1878 */ 1879 static void writefileFunc( 1880 sqlite3_context *context, 1881 int argc, 1882 sqlite3_value **argv 1883 ){ 1884 FILE *out; 1885 const char *z; 1886 sqlite3_int64 rc; 1887 const char *zFile; 1888 1889 zFile = (const char*)sqlite3_value_text(argv[0]); 1890 if( zFile==0 ) return; 1891 out = fopen(zFile, "wb"); 1892 if( out==0 ) return; 1893 z = (const char*)sqlite3_value_blob(argv[1]); 1894 if( z==0 ){ 1895 rc = 0; 1896 }else{ 1897 rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out); 1898 } 1899 fclose(out); 1900 sqlite3_result_int64(context, rc); 1901 } 1902 1903 /* 1904 ** Make sure the database is open. If it is not, then open it. If 1905 ** the database fails to open, print an error message and exit. 1906 */ 1907 static void open_db(ShellState *p, int keepAlive){ 1908 if( p->db==0 ){ 1909 sqlite3_initialize(); 1910 sqlite3_open(p->zDbFilename, &p->db); 1911 db = p->db; 1912 if( db && sqlite3_errcode(db)==SQLITE_OK ){ 1913 sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0, 1914 shellstaticFunc, 0, 0); 1915 } 1916 if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){ 1917 fprintf(stderr,"Error: unable to open database \"%s\": %s\n", 1918 p->zDbFilename, sqlite3_errmsg(db)); 1919 if( keepAlive ) return; 1920 exit(1); 1921 } 1922 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1923 sqlite3_enable_load_extension(p->db, 1); 1924 #endif 1925 sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0, 1926 readfileFunc, 0, 0); 1927 sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0, 1928 writefileFunc, 0, 0); 1929 } 1930 } 1931 1932 /* 1933 ** Do C-language style dequoting. 1934 ** 1935 ** \t -> tab 1936 ** \n -> newline 1937 ** \r -> carriage return 1938 ** \" -> " 1939 ** \NNN -> ascii character NNN in octal 1940 ** \\ -> backslash 1941 */ 1942 static void resolve_backslashes(char *z){ 1943 int i, j; 1944 char c; 1945 while( *z && *z!='\\' ) z++; 1946 for(i=j=0; (c = z[i])!=0; i++, j++){ 1947 if( c=='\\' ){ 1948 c = z[++i]; 1949 if( c=='n' ){ 1950 c = '\n'; 1951 }else if( c=='t' ){ 1952 c = '\t'; 1953 }else if( c=='r' ){ 1954 c = '\r'; 1955 }else if( c=='\\' ){ 1956 c = '\\'; 1957 }else if( c>='0' && c<='7' ){ 1958 c -= '0'; 1959 if( z[i+1]>='0' && z[i+1]<='7' ){ 1960 i++; 1961 c = (c<<3) + z[i] - '0'; 1962 if( z[i+1]>='0' && z[i+1]<='7' ){ 1963 i++; 1964 c = (c<<3) + z[i] - '0'; 1965 } 1966 } 1967 } 1968 } 1969 z[j] = c; 1970 } 1971 if( j<i ) z[j] = 0; 1972 } 1973 1974 /* 1975 ** Return the value of a hexadecimal digit. Return -1 if the input 1976 ** is not a hex digit. 1977 */ 1978 static int hexDigitValue(char c){ 1979 if( c>='0' && c<='9' ) return c - '0'; 1980 if( c>='a' && c<='f' ) return c - 'a' + 10; 1981 if( c>='A' && c<='F' ) return c - 'A' + 10; 1982 return -1; 1983 } 1984 1985 /* 1986 ** Interpret zArg as an integer value, possibly with suffixes. 1987 */ 1988 static sqlite3_int64 integerValue(const char *zArg){ 1989 sqlite3_int64 v = 0; 1990 static const struct { char *zSuffix; int iMult; } aMult[] = { 1991 { "KiB", 1024 }, 1992 { "MiB", 1024*1024 }, 1993 { "GiB", 1024*1024*1024 }, 1994 { "KB", 1000 }, 1995 { "MB", 1000000 }, 1996 { "GB", 1000000000 }, 1997 { "K", 1000 }, 1998 { "M", 1000000 }, 1999 { "G", 1000000000 }, 2000 }; 2001 int i; 2002 int isNeg = 0; 2003 if( zArg[0]=='-' ){ 2004 isNeg = 1; 2005 zArg++; 2006 }else if( zArg[0]=='+' ){ 2007 zArg++; 2008 } 2009 if( zArg[0]=='0' && zArg[1]=='x' ){ 2010 int x; 2011 zArg += 2; 2012 while( (x = hexDigitValue(zArg[0]))>=0 ){ 2013 v = (v<<4) + x; 2014 zArg++; 2015 } 2016 }else{ 2017 while( IsDigit(zArg[0]) ){ 2018 v = v*10 + zArg[0] - '0'; 2019 zArg++; 2020 } 2021 } 2022 for(i=0; i<ArraySize(aMult); i++){ 2023 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){ 2024 v *= aMult[i].iMult; 2025 break; 2026 } 2027 } 2028 return isNeg? -v : v; 2029 } 2030 2031 /* 2032 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0 2033 ** for TRUE and FALSE. Return the integer value if appropriate. 2034 */ 2035 static int booleanValue(char *zArg){ 2036 int i; 2037 if( zArg[0]=='0' && zArg[1]=='x' ){ 2038 for(i=2; hexDigitValue(zArg[i])>=0; i++){} 2039 }else{ 2040 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){} 2041 } 2042 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff); 2043 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){ 2044 return 1; 2045 } 2046 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){ 2047 return 0; 2048 } 2049 fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", 2050 zArg); 2051 return 0; 2052 } 2053 2054 /* 2055 ** Close an output file, assuming it is not stderr or stdout 2056 */ 2057 static void output_file_close(FILE *f){ 2058 if( f && f!=stdout && f!=stderr ) fclose(f); 2059 } 2060 2061 /* 2062 ** Try to open an output file. The names "stdout" and "stderr" are 2063 ** recognized and do the right thing. NULL is returned if the output 2064 ** filename is "off". 2065 */ 2066 static FILE *output_file_open(const char *zFile){ 2067 FILE *f; 2068 if( strcmp(zFile,"stdout")==0 ){ 2069 f = stdout; 2070 }else if( strcmp(zFile, "stderr")==0 ){ 2071 f = stderr; 2072 }else if( strcmp(zFile, "off")==0 ){ 2073 f = 0; 2074 }else{ 2075 f = fopen(zFile, "wb"); 2076 if( f==0 ){ 2077 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); 2078 } 2079 } 2080 return f; 2081 } 2082 2083 /* 2084 ** A routine for handling output from sqlite3_trace(). 2085 */ 2086 static void sql_trace_callback(void *pArg, const char *z){ 2087 FILE *f = (FILE*)pArg; 2088 if( f ){ 2089 int i = (int)strlen(z); 2090 while( i>0 && z[i-1]==';' ){ i--; } 2091 fprintf(f, "%.*s;\n", i, z); 2092 } 2093 } 2094 2095 /* 2096 ** A no-op routine that runs with the ".breakpoint" doc-command. This is 2097 ** a useful spot to set a debugger breakpoint. 2098 */ 2099 static void test_breakpoint(void){ 2100 static int nCall = 0; 2101 nCall++; 2102 } 2103 2104 /* 2105 ** An object used to read a CSV and other files for import. 2106 */ 2107 typedef struct ImportCtx ImportCtx; 2108 struct ImportCtx { 2109 const char *zFile; /* Name of the input file */ 2110 FILE *in; /* Read the CSV text from this input stream */ 2111 char *z; /* Accumulated text for a field */ 2112 int n; /* Number of bytes in z */ 2113 int nAlloc; /* Space allocated for z[] */ 2114 int nLine; /* Current line number */ 2115 int cTerm; /* Character that terminated the most recent field */ 2116 int cColSep; /* The column separator character. (Usually ",") */ 2117 int cRowSep; /* The row separator character. (Usually "\n") */ 2118 }; 2119 2120 /* Append a single byte to z[] */ 2121 static void import_append_char(ImportCtx *p, int c){ 2122 if( p->n+1>=p->nAlloc ){ 2123 p->nAlloc += p->nAlloc + 100; 2124 p->z = sqlite3_realloc(p->z, p->nAlloc); 2125 if( p->z==0 ){ 2126 fprintf(stderr, "out of memory\n"); 2127 exit(1); 2128 } 2129 } 2130 p->z[p->n++] = (char)c; 2131 } 2132 2133 /* Read a single field of CSV text. Compatible with rfc4180 and extended 2134 ** with the option of having a separator other than ",". 2135 ** 2136 ** + Input comes from p->in. 2137 ** + Store results in p->z of length p->n. Space to hold p->z comes 2138 ** from sqlite3_malloc(). 2139 ** + Use p->cSep as the column separator. The default is ",". 2140 ** + Use p->rSep as the row separator. The default is "\n". 2141 ** + Keep track of the line number in p->nLine. 2142 ** + Store the character that terminates the field in p->cTerm. Store 2143 ** EOF on end-of-file. 2144 ** + Report syntax errors on stderr 2145 */ 2146 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){ 2147 int c; 2148 int cSep = p->cColSep; 2149 int rSep = p->cRowSep; 2150 p->n = 0; 2151 c = fgetc(p->in); 2152 if( c==EOF || seenInterrupt ){ 2153 p->cTerm = EOF; 2154 return 0; 2155 } 2156 if( c=='"' ){ 2157 int pc, ppc; 2158 int startLine = p->nLine; 2159 int cQuote = c; 2160 pc = ppc = 0; 2161 while( 1 ){ 2162 c = fgetc(p->in); 2163 if( c==rSep ) p->nLine++; 2164 if( c==cQuote ){ 2165 if( pc==cQuote ){ 2166 pc = 0; 2167 continue; 2168 } 2169 } 2170 if( (c==cSep && pc==cQuote) 2171 || (c==rSep && pc==cQuote) 2172 || (c==rSep && pc=='\r' && ppc==cQuote) 2173 || (c==EOF && pc==cQuote) 2174 ){ 2175 do{ p->n--; }while( p->z[p->n]!=cQuote ); 2176 p->cTerm = c; 2177 break; 2178 } 2179 if( pc==cQuote && c!='\r' ){ 2180 fprintf(stderr, "%s:%d: unescaped %c character\n", 2181 p->zFile, p->nLine, cQuote); 2182 } 2183 if( c==EOF ){ 2184 fprintf(stderr, "%s:%d: unterminated %c-quoted field\n", 2185 p->zFile, startLine, cQuote); 2186 p->cTerm = c; 2187 break; 2188 } 2189 import_append_char(p, c); 2190 ppc = pc; 2191 pc = c; 2192 } 2193 }else{ 2194 while( c!=EOF && c!=cSep && c!=rSep ){ 2195 import_append_char(p, c); 2196 c = fgetc(p->in); 2197 } 2198 if( c==rSep ){ 2199 p->nLine++; 2200 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--; 2201 } 2202 p->cTerm = c; 2203 } 2204 if( p->z ) p->z[p->n] = 0; 2205 return p->z; 2206 } 2207 2208 /* Read a single field of ASCII delimited text. 2209 ** 2210 ** + Input comes from p->in. 2211 ** + Store results in p->z of length p->n. Space to hold p->z comes 2212 ** from sqlite3_malloc(). 2213 ** + Use p->cSep as the column separator. The default is "\x1F". 2214 ** + Use p->rSep as the row separator. The default is "\x1E". 2215 ** + Keep track of the row number in p->nLine. 2216 ** + Store the character that terminates the field in p->cTerm. Store 2217 ** EOF on end-of-file. 2218 ** + Report syntax errors on stderr 2219 */ 2220 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){ 2221 int c; 2222 int cSep = p->cColSep; 2223 int rSep = p->cRowSep; 2224 p->n = 0; 2225 c = fgetc(p->in); 2226 if( c==EOF || seenInterrupt ){ 2227 p->cTerm = EOF; 2228 return 0; 2229 } 2230 while( c!=EOF && c!=cSep && c!=rSep ){ 2231 import_append_char(p, c); 2232 c = fgetc(p->in); 2233 } 2234 if( c==rSep ){ 2235 p->nLine++; 2236 } 2237 p->cTerm = c; 2238 if( p->z ) p->z[p->n] = 0; 2239 return p->z; 2240 } 2241 2242 /* 2243 ** Try to transfer data for table zTable. If an error is seen while 2244 ** moving forward, try to go backwards. The backwards movement won't 2245 ** work for WITHOUT ROWID tables. 2246 */ 2247 static void tryToCloneData( 2248 ShellState *p, 2249 sqlite3 *newDb, 2250 const char *zTable 2251 ){ 2252 sqlite3_stmt *pQuery = 0; 2253 sqlite3_stmt *pInsert = 0; 2254 char *zQuery = 0; 2255 char *zInsert = 0; 2256 int rc; 2257 int i, j, n; 2258 int nTable = (int)strlen(zTable); 2259 int k = 0; 2260 int cnt = 0; 2261 const int spinRate = 10000; 2262 2263 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); 2264 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 2265 if( rc ){ 2266 fprintf(stderr, "Error %d: %s on [%s]\n", 2267 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 2268 zQuery); 2269 goto end_data_xfer; 2270 } 2271 n = sqlite3_column_count(pQuery); 2272 zInsert = sqlite3_malloc(200 + nTable + n*3); 2273 if( zInsert==0 ){ 2274 fprintf(stderr, "out of memory\n"); 2275 goto end_data_xfer; 2276 } 2277 sqlite3_snprintf(200+nTable,zInsert, 2278 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable); 2279 i = (int)strlen(zInsert); 2280 for(j=1; j<n; j++){ 2281 memcpy(zInsert+i, ",?", 2); 2282 i += 2; 2283 } 2284 memcpy(zInsert+i, ");", 3); 2285 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0); 2286 if( rc ){ 2287 fprintf(stderr, "Error %d: %s on [%s]\n", 2288 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), 2289 zQuery); 2290 goto end_data_xfer; 2291 } 2292 for(k=0; k<2; k++){ 2293 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 2294 for(i=0; i<n; i++){ 2295 switch( sqlite3_column_type(pQuery, i) ){ 2296 case SQLITE_NULL: { 2297 sqlite3_bind_null(pInsert, i+1); 2298 break; 2299 } 2300 case SQLITE_INTEGER: { 2301 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i)); 2302 break; 2303 } 2304 case SQLITE_FLOAT: { 2305 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i)); 2306 break; 2307 } 2308 case SQLITE_TEXT: { 2309 sqlite3_bind_text(pInsert, i+1, 2310 (const char*)sqlite3_column_text(pQuery,i), 2311 -1, SQLITE_STATIC); 2312 break; 2313 } 2314 case SQLITE_BLOB: { 2315 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i), 2316 sqlite3_column_bytes(pQuery,i), 2317 SQLITE_STATIC); 2318 break; 2319 } 2320 } 2321 } /* End for */ 2322 rc = sqlite3_step(pInsert); 2323 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){ 2324 fprintf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb), 2325 sqlite3_errmsg(newDb)); 2326 } 2327 sqlite3_reset(pInsert); 2328 cnt++; 2329 if( (cnt%spinRate)==0 ){ 2330 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]); 2331 fflush(stdout); 2332 } 2333 } /* End while */ 2334 if( rc==SQLITE_DONE ) break; 2335 sqlite3_finalize(pQuery); 2336 sqlite3_free(zQuery); 2337 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;", 2338 zTable); 2339 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 2340 if( rc ){ 2341 fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable); 2342 break; 2343 } 2344 } /* End for(k=0...) */ 2345 2346 end_data_xfer: 2347 sqlite3_finalize(pQuery); 2348 sqlite3_finalize(pInsert); 2349 sqlite3_free(zQuery); 2350 sqlite3_free(zInsert); 2351 } 2352 2353 2354 /* 2355 ** Try to transfer all rows of the schema that match zWhere. For 2356 ** each row, invoke xForEach() on the object defined by that row. 2357 ** If an error is encountered while moving forward through the 2358 ** sqlite_master table, try again moving backwards. 2359 */ 2360 static void tryToCloneSchema( 2361 ShellState *p, 2362 sqlite3 *newDb, 2363 const char *zWhere, 2364 void (*xForEach)(ShellState*,sqlite3*,const char*) 2365 ){ 2366 sqlite3_stmt *pQuery = 0; 2367 char *zQuery = 0; 2368 int rc; 2369 const unsigned char *zName; 2370 const unsigned char *zSql; 2371 char *zErrMsg = 0; 2372 2373 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" 2374 " WHERE %s", zWhere); 2375 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 2376 if( rc ){ 2377 fprintf(stderr, "Error: (%d) %s on [%s]\n", 2378 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 2379 zQuery); 2380 goto end_schema_xfer; 2381 } 2382 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 2383 zName = sqlite3_column_text(pQuery, 0); 2384 zSql = sqlite3_column_text(pQuery, 1); 2385 printf("%s... ", zName); fflush(stdout); 2386 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 2387 if( zErrMsg ){ 2388 fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 2389 sqlite3_free(zErrMsg); 2390 zErrMsg = 0; 2391 } 2392 if( xForEach ){ 2393 xForEach(p, newDb, (const char*)zName); 2394 } 2395 printf("done\n"); 2396 } 2397 if( rc!=SQLITE_DONE ){ 2398 sqlite3_finalize(pQuery); 2399 sqlite3_free(zQuery); 2400 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" 2401 " WHERE %s ORDER BY rowid DESC", zWhere); 2402 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 2403 if( rc ){ 2404 fprintf(stderr, "Error: (%d) %s on [%s]\n", 2405 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 2406 zQuery); 2407 goto end_schema_xfer; 2408 } 2409 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 2410 zName = sqlite3_column_text(pQuery, 0); 2411 zSql = sqlite3_column_text(pQuery, 1); 2412 printf("%s... ", zName); fflush(stdout); 2413 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 2414 if( zErrMsg ){ 2415 fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 2416 sqlite3_free(zErrMsg); 2417 zErrMsg = 0; 2418 } 2419 if( xForEach ){ 2420 xForEach(p, newDb, (const char*)zName); 2421 } 2422 printf("done\n"); 2423 } 2424 } 2425 end_schema_xfer: 2426 sqlite3_finalize(pQuery); 2427 sqlite3_free(zQuery); 2428 } 2429 2430 /* 2431 ** Open a new database file named "zNewDb". Try to recover as much information 2432 ** as possible out of the main database (which might be corrupt) and write it 2433 ** into zNewDb. 2434 */ 2435 static void tryToClone(ShellState *p, const char *zNewDb){ 2436 int rc; 2437 sqlite3 *newDb = 0; 2438 if( access(zNewDb,0)==0 ){ 2439 fprintf(stderr, "File \"%s\" already exists.\n", zNewDb); 2440 return; 2441 } 2442 rc = sqlite3_open(zNewDb, &newDb); 2443 if( rc ){ 2444 fprintf(stderr, "Cannot create output database: %s\n", 2445 sqlite3_errmsg(newDb)); 2446 }else{ 2447 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0); 2448 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0); 2449 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData); 2450 tryToCloneSchema(p, newDb, "type!='table'", 0); 2451 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0); 2452 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 2453 } 2454 sqlite3_close(newDb); 2455 } 2456 2457 /* 2458 ** Change the output file back to stdout 2459 */ 2460 static void output_reset(ShellState *p){ 2461 if( p->outfile[0]=='|' ){ 2462 #ifndef SQLITE_OMIT_POPEN 2463 pclose(p->out); 2464 #endif 2465 }else{ 2466 output_file_close(p->out); 2467 } 2468 p->outfile[0] = 0; 2469 p->out = stdout; 2470 } 2471 2472 /* 2473 ** Run an SQL command and return the single integer result. 2474 */ 2475 static int db_int(ShellState *p, const char *zSql){ 2476 sqlite3_stmt *pStmt; 2477 int res = 0; 2478 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 2479 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ 2480 res = sqlite3_column_int(pStmt,0); 2481 } 2482 sqlite3_finalize(pStmt); 2483 return res; 2484 } 2485 2486 /* 2487 ** Convert a 2-byte or 4-byte big-endian integer into a native integer 2488 */ 2489 unsigned int get2byteInt(unsigned char *a){ 2490 return (a[0]<<8) + a[1]; 2491 } 2492 unsigned int get4byteInt(unsigned char *a){ 2493 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3]; 2494 } 2495 2496 /* 2497 ** Implementation of the ".info" command. 2498 ** 2499 ** Return 1 on error, 2 to exit, and 0 otherwise. 2500 */ 2501 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){ 2502 static const struct { const char *zName; int ofst; } aField[] = { 2503 { "file change counter:", 24 }, 2504 { "database page count:", 28 }, 2505 { "freelist page count:", 36 }, 2506 { "schema cookie:", 40 }, 2507 { "schema format:", 44 }, 2508 { "default cache size:", 48 }, 2509 { "autovacuum top root:", 52 }, 2510 { "incremental vacuum:", 64 }, 2511 { "text encoding:", 56 }, 2512 { "user version:", 60 }, 2513 { "application id:", 68 }, 2514 { "software version:", 96 }, 2515 }; 2516 static const struct { const char *zName; const char *zSql; } aQuery[] = { 2517 { "number of tables:", 2518 "SELECT count(*) FROM %s WHERE type='table'" }, 2519 { "number of indexes:", 2520 "SELECT count(*) FROM %s WHERE type='index'" }, 2521 { "number of triggers:", 2522 "SELECT count(*) FROM %s WHERE type='trigger'" }, 2523 { "number of views:", 2524 "SELECT count(*) FROM %s WHERE type='view'" }, 2525 { "schema size:", 2526 "SELECT total(length(sql)) FROM %s" }, 2527 }; 2528 sqlite3_file *pFile; 2529 int i; 2530 char *zSchemaTab; 2531 char *zDb = nArg>=2 ? azArg[1] : "main"; 2532 unsigned char aHdr[100]; 2533 open_db(p, 0); 2534 if( p->db==0 ) return 1; 2535 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile); 2536 if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){ 2537 return 1; 2538 } 2539 i = pFile->pMethods->xRead(pFile, aHdr, 100, 0); 2540 if( i!=SQLITE_OK ){ 2541 fprintf(stderr, "unable to read database header\n"); 2542 return 1; 2543 } 2544 i = get2byteInt(aHdr+16); 2545 if( i==1 ) i = 65536; 2546 fprintf(p->out, "%-20s %d\n", "database page size:", i); 2547 fprintf(p->out, "%-20s %d\n", "write format:", aHdr[18]); 2548 fprintf(p->out, "%-20s %d\n", "read format:", aHdr[19]); 2549 fprintf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]); 2550 for(i=0; i<sizeof(aField)/sizeof(aField[0]); i++){ 2551 int ofst = aField[i].ofst; 2552 unsigned int val = get4byteInt(aHdr + ofst); 2553 fprintf(p->out, "%-20s %u", aField[i].zName, val); 2554 switch( ofst ){ 2555 case 56: { 2556 if( val==1 ) fprintf(p->out, " (utf8)"); 2557 if( val==2 ) fprintf(p->out, " (utf16le)"); 2558 if( val==3 ) fprintf(p->out, " (utf16be)"); 2559 } 2560 } 2561 fprintf(p->out, "\n"); 2562 } 2563 if( zDb==0 ){ 2564 zSchemaTab = sqlite3_mprintf("main.sqlite_master"); 2565 }else if( strcmp(zDb,"temp")==0 ){ 2566 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master"); 2567 }else{ 2568 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb); 2569 } 2570 for(i=0; i<sizeof(aQuery)/sizeof(aQuery[0]); i++){ 2571 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab); 2572 int val = db_int(p, zSql); 2573 sqlite3_free(zSql); 2574 fprintf(p->out, "%-20s %d\n", aQuery[i].zName, val); 2575 } 2576 sqlite3_free(zSchemaTab); 2577 return 0; 2578 } 2579 2580 2581 /* 2582 ** If an input line begins with "." then invoke this routine to 2583 ** process that line. 2584 ** 2585 ** Return 1 on error, 2 to exit, and 0 otherwise. 2586 */ 2587 static int do_meta_command(char *zLine, ShellState *p){ 2588 int i = 1; 2589 int nArg = 0; 2590 int n, c; 2591 int rc = 0; 2592 char *azArg[50]; 2593 2594 /* Parse the input line into tokens. 2595 */ 2596 while( zLine[i] && nArg<ArraySize(azArg) ){ 2597 while( IsSpace(zLine[i]) ){ i++; } 2598 if( zLine[i]==0 ) break; 2599 if( zLine[i]=='\'' || zLine[i]=='"' ){ 2600 int delim = zLine[i++]; 2601 azArg[nArg++] = &zLine[i]; 2602 while( zLine[i] && zLine[i]!=delim ){ 2603 if( zLine[i]=='\\' && delim=='"' && zLine[i+1]!=0 ) i++; 2604 i++; 2605 } 2606 if( zLine[i]==delim ){ 2607 zLine[i++] = 0; 2608 } 2609 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]); 2610 }else{ 2611 azArg[nArg++] = &zLine[i]; 2612 while( zLine[i] && !IsSpace(zLine[i]) ){ i++; } 2613 if( zLine[i] ) zLine[i++] = 0; 2614 resolve_backslashes(azArg[nArg-1]); 2615 } 2616 } 2617 2618 /* Process the input line. 2619 */ 2620 if( nArg==0 ) return 0; /* no tokens, no error */ 2621 n = strlen30(azArg[0]); 2622 c = azArg[0][0]; 2623 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0) 2624 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0) 2625 ){ 2626 const char *zDestFile = 0; 2627 const char *zDb = 0; 2628 sqlite3 *pDest; 2629 sqlite3_backup *pBackup; 2630 int j; 2631 for(j=1; j<nArg; j++){ 2632 const char *z = azArg[j]; 2633 if( z[0]=='-' ){ 2634 while( z[0]=='-' ) z++; 2635 /* No options to process at this time */ 2636 { 2637 fprintf(stderr, "unknown option: %s\n", azArg[j]); 2638 return 1; 2639 } 2640 }else if( zDestFile==0 ){ 2641 zDestFile = azArg[j]; 2642 }else if( zDb==0 ){ 2643 zDb = zDestFile; 2644 zDestFile = azArg[j]; 2645 }else{ 2646 fprintf(stderr, "too many arguments to .backup\n"); 2647 return 1; 2648 } 2649 } 2650 if( zDestFile==0 ){ 2651 fprintf(stderr, "missing FILENAME argument on .backup\n"); 2652 return 1; 2653 } 2654 if( zDb==0 ) zDb = "main"; 2655 rc = sqlite3_open(zDestFile, &pDest); 2656 if( rc!=SQLITE_OK ){ 2657 fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile); 2658 sqlite3_close(pDest); 2659 return 1; 2660 } 2661 open_db(p, 0); 2662 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb); 2663 if( pBackup==0 ){ 2664 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 2665 sqlite3_close(pDest); 2666 return 1; 2667 } 2668 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} 2669 sqlite3_backup_finish(pBackup); 2670 if( rc==SQLITE_DONE ){ 2671 rc = 0; 2672 }else{ 2673 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 2674 rc = 1; 2675 } 2676 sqlite3_close(pDest); 2677 }else 2678 2679 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){ 2680 if( nArg==2 ){ 2681 bail_on_error = booleanValue(azArg[1]); 2682 }else{ 2683 fprintf(stderr, "Usage: .bail on|off\n"); 2684 rc = 1; 2685 } 2686 }else 2687 2688 /* The undocumented ".breakpoint" command causes a call to the no-op 2689 ** routine named test_breakpoint(). 2690 */ 2691 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){ 2692 test_breakpoint(); 2693 }else 2694 2695 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){ 2696 if( nArg==2 ){ 2697 tryToClone(p, azArg[1]); 2698 }else{ 2699 fprintf(stderr, "Usage: .clone FILENAME\n"); 2700 rc = 1; 2701 } 2702 }else 2703 2704 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){ 2705 ShellState data; 2706 char *zErrMsg = 0; 2707 open_db(p, 0); 2708 memcpy(&data, p, sizeof(data)); 2709 data.showHeader = 1; 2710 data.mode = MODE_Column; 2711 data.colWidth[0] = 3; 2712 data.colWidth[1] = 15; 2713 data.colWidth[2] = 58; 2714 data.cnt = 0; 2715 sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); 2716 if( zErrMsg ){ 2717 fprintf(stderr,"Error: %s\n", zErrMsg); 2718 sqlite3_free(zErrMsg); 2719 rc = 1; 2720 } 2721 }else 2722 2723 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){ 2724 rc = shell_dbinfo_command(p, nArg, azArg); 2725 }else 2726 2727 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ 2728 open_db(p, 0); 2729 /* When playing back a "dump", the content might appear in an order 2730 ** which causes immediate foreign key constraints to be violated. 2731 ** So disable foreign-key constraint enforcement to prevent problems. */ 2732 if( nArg!=1 && nArg!=2 ){ 2733 fprintf(stderr, "Usage: .dump ?LIKE-PATTERN?\n"); 2734 rc = 1; 2735 goto meta_command_exit; 2736 } 2737 fprintf(p->out, "PRAGMA foreign_keys=OFF;\n"); 2738 fprintf(p->out, "BEGIN TRANSACTION;\n"); 2739 p->writableSchema = 0; 2740 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0); 2741 p->nErr = 0; 2742 if( nArg==1 ){ 2743 run_schema_dump_query(p, 2744 "SELECT name, type, sql FROM sqlite_master " 2745 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'" 2746 ); 2747 run_schema_dump_query(p, 2748 "SELECT name, type, sql FROM sqlite_master " 2749 "WHERE name=='sqlite_sequence'" 2750 ); 2751 run_table_dump_query(p, 2752 "SELECT sql FROM sqlite_master " 2753 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0 2754 ); 2755 }else{ 2756 int i; 2757 for(i=1; i<nArg; i++){ 2758 zShellStatic = azArg[i]; 2759 run_schema_dump_query(p, 2760 "SELECT name, type, sql FROM sqlite_master " 2761 "WHERE tbl_name LIKE shellstatic() AND type=='table'" 2762 " AND sql NOT NULL"); 2763 run_table_dump_query(p, 2764 "SELECT sql FROM sqlite_master " 2765 "WHERE sql NOT NULL" 2766 " AND type IN ('index','trigger','view')" 2767 " AND tbl_name LIKE shellstatic()", 0 2768 ); 2769 zShellStatic = 0; 2770 } 2771 } 2772 if( p->writableSchema ){ 2773 fprintf(p->out, "PRAGMA writable_schema=OFF;\n"); 2774 p->writableSchema = 0; 2775 } 2776 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 2777 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0); 2778 fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n"); 2779 }else 2780 2781 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){ 2782 if( nArg==2 ){ 2783 p->echoOn = booleanValue(azArg[1]); 2784 }else{ 2785 fprintf(stderr, "Usage: .echo on|off\n"); 2786 rc = 1; 2787 } 2788 }else 2789 2790 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){ 2791 if( nArg==2 ){ 2792 p->autoEQP = booleanValue(azArg[1]); 2793 }else{ 2794 fprintf(stderr, "Usage: .eqp on|off\n"); 2795 rc = 1; 2796 } 2797 }else 2798 2799 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){ 2800 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc); 2801 rc = 2; 2802 }else 2803 2804 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ 2805 int val = nArg>=2 ? booleanValue(azArg[1]) : 1; 2806 if(val == 1) { 2807 if(!p->normalMode.valid) { 2808 p->normalMode.valid = 1; 2809 p->normalMode.mode = p->mode; 2810 p->normalMode.showHeader = p->showHeader; 2811 memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth)); 2812 } 2813 /* We could put this code under the !p->explainValid 2814 ** condition so that it does not execute if we are already in 2815 ** explain mode. However, always executing it allows us an easy 2816 ** was to reset to explain mode in case the user previously 2817 ** did an .explain followed by a .width, .mode or .header 2818 ** command. 2819 */ 2820 p->mode = MODE_Explain; 2821 p->showHeader = 1; 2822 memset(p->colWidth,0,sizeof(p->colWidth)); 2823 p->colWidth[0] = 4; /* addr */ 2824 p->colWidth[1] = 13; /* opcode */ 2825 p->colWidth[2] = 4; /* P1 */ 2826 p->colWidth[3] = 4; /* P2 */ 2827 p->colWidth[4] = 4; /* P3 */ 2828 p->colWidth[5] = 13; /* P4 */ 2829 p->colWidth[6] = 2; /* P5 */ 2830 p->colWidth[7] = 13; /* Comment */ 2831 }else if (p->normalMode.valid) { 2832 p->normalMode.valid = 0; 2833 p->mode = p->normalMode.mode; 2834 p->showHeader = p->normalMode.showHeader; 2835 memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth)); 2836 } 2837 }else 2838 2839 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){ 2840 ShellState data; 2841 char *zErrMsg = 0; 2842 int doStats = 0; 2843 if( nArg!=1 ){ 2844 fprintf(stderr, "Usage: .fullschema\n"); 2845 rc = 1; 2846 goto meta_command_exit; 2847 } 2848 open_db(p, 0); 2849 memcpy(&data, p, sizeof(data)); 2850 data.showHeader = 0; 2851 data.mode = MODE_Semi; 2852 rc = sqlite3_exec(p->db, 2853 "SELECT sql FROM" 2854 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" 2855 " FROM sqlite_master UNION ALL" 2856 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " 2857 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " 2858 "ORDER BY rowid", 2859 callback, &data, &zErrMsg 2860 ); 2861 if( rc==SQLITE_OK ){ 2862 sqlite3_stmt *pStmt; 2863 rc = sqlite3_prepare_v2(p->db, 2864 "SELECT rowid FROM sqlite_master" 2865 " WHERE name GLOB 'sqlite_stat[134]'", 2866 -1, &pStmt, 0); 2867 doStats = sqlite3_step(pStmt)==SQLITE_ROW; 2868 sqlite3_finalize(pStmt); 2869 } 2870 if( doStats==0 ){ 2871 fprintf(p->out, "/* No STAT tables available */\n"); 2872 }else{ 2873 fprintf(p->out, "ANALYZE sqlite_master;\n"); 2874 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'", 2875 callback, &data, &zErrMsg); 2876 data.mode = MODE_Insert; 2877 data.zDestTable = "sqlite_stat1"; 2878 shell_exec(p->db, "SELECT * FROM sqlite_stat1", 2879 shell_callback, &data,&zErrMsg); 2880 data.zDestTable = "sqlite_stat3"; 2881 shell_exec(p->db, "SELECT * FROM sqlite_stat3", 2882 shell_callback, &data,&zErrMsg); 2883 data.zDestTable = "sqlite_stat4"; 2884 shell_exec(p->db, "SELECT * FROM sqlite_stat4", 2885 shell_callback, &data, &zErrMsg); 2886 fprintf(p->out, "ANALYZE sqlite_master;\n"); 2887 } 2888 }else 2889 2890 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){ 2891 if( nArg==2 ){ 2892 p->showHeader = booleanValue(azArg[1]); 2893 }else{ 2894 fprintf(stderr, "Usage: .headers on|off\n"); 2895 rc = 1; 2896 } 2897 }else 2898 2899 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ 2900 fprintf(p->out, "%s", zHelp); 2901 }else 2902 2903 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){ 2904 char *zTable; /* Insert data into this table */ 2905 char *zFile; /* Name of file to extra content from */ 2906 sqlite3_stmt *pStmt = NULL; /* A statement */ 2907 int nCol; /* Number of columns in the table */ 2908 int nByte; /* Number of bytes in an SQL string */ 2909 int i, j; /* Loop counters */ 2910 int needCommit; /* True to COMMIT or ROLLBACK at end */ 2911 int nSep; /* Number of bytes in p->colSeparator[] */ 2912 char *zSql; /* An SQL statement */ 2913 ImportCtx sCtx; /* Reader context */ 2914 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */ 2915 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */ 2916 2917 if( nArg!=3 ){ 2918 fprintf(stderr, "Usage: .import FILE TABLE\n"); 2919 goto meta_command_exit; 2920 } 2921 zFile = azArg[1]; 2922 zTable = azArg[2]; 2923 seenInterrupt = 0; 2924 memset(&sCtx, 0, sizeof(sCtx)); 2925 open_db(p, 0); 2926 nSep = strlen30(p->colSeparator); 2927 if( nSep==0 ){ 2928 fprintf(stderr, "Error: non-null column separator required for import\n"); 2929 return 1; 2930 } 2931 if( nSep>1 ){ 2932 fprintf(stderr, "Error: multi-character column separators not allowed" 2933 " for import\n"); 2934 return 1; 2935 } 2936 nSep = strlen30(p->rowSeparator); 2937 if( nSep==0 ){ 2938 fprintf(stderr, "Error: non-null row separator required for import\n"); 2939 return 1; 2940 } 2941 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){ 2942 /* When importing CSV (only), if the row separator is set to the 2943 ** default output row separator, change it to the default input 2944 ** row separator. This avoids having to maintain different input 2945 ** and output row separators. */ 2946 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 2947 nSep = strlen30(p->rowSeparator); 2948 } 2949 if( nSep>1 ){ 2950 fprintf(stderr, "Error: multi-character row separators not allowed" 2951 " for import\n"); 2952 return 1; 2953 } 2954 sCtx.zFile = zFile; 2955 sCtx.nLine = 1; 2956 if( sCtx.zFile[0]=='|' ){ 2957 #ifdef SQLITE_OMIT_POPEN 2958 fprintf(stderr, "Error: pipes are not supported in this OS\n"); 2959 return 1; 2960 #else 2961 sCtx.in = popen(sCtx.zFile+1, "r"); 2962 sCtx.zFile = "<pipe>"; 2963 xCloser = pclose; 2964 #endif 2965 }else{ 2966 sCtx.in = fopen(sCtx.zFile, "rb"); 2967 xCloser = fclose; 2968 } 2969 if( p->mode==MODE_Ascii ){ 2970 xRead = ascii_read_one_field; 2971 }else{ 2972 xRead = csv_read_one_field; 2973 } 2974 if( sCtx.in==0 ){ 2975 fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); 2976 return 1; 2977 } 2978 sCtx.cColSep = p->colSeparator[0]; 2979 sCtx.cRowSep = p->rowSeparator[0]; 2980 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable); 2981 if( zSql==0 ){ 2982 fprintf(stderr, "Error: out of memory\n"); 2983 xCloser(sCtx.in); 2984 return 1; 2985 } 2986 nByte = strlen30(zSql); 2987 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 2988 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */ 2989 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){ 2990 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable); 2991 char cSep = '('; 2992 while( xRead(&sCtx) ){ 2993 zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCtx.z); 2994 cSep = ','; 2995 if( sCtx.cTerm!=sCtx.cColSep ) break; 2996 } 2997 if( cSep=='(' ){ 2998 sqlite3_free(zCreate); 2999 sqlite3_free(sCtx.z); 3000 xCloser(sCtx.in); 3001 fprintf(stderr,"%s: empty file\n", sCtx.zFile); 3002 return 1; 3003 } 3004 zCreate = sqlite3_mprintf("%z\n)", zCreate); 3005 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0); 3006 sqlite3_free(zCreate); 3007 if( rc ){ 3008 fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable, 3009 sqlite3_errmsg(db)); 3010 sqlite3_free(sCtx.z); 3011 xCloser(sCtx.in); 3012 return 1; 3013 } 3014 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 3015 } 3016 sqlite3_free(zSql); 3017 if( rc ){ 3018 if (pStmt) sqlite3_finalize(pStmt); 3019 fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db)); 3020 xCloser(sCtx.in); 3021 return 1; 3022 } 3023 nCol = sqlite3_column_count(pStmt); 3024 sqlite3_finalize(pStmt); 3025 pStmt = 0; 3026 if( nCol==0 ) return 0; /* no columns, no error */ 3027 zSql = sqlite3_malloc( nByte*2 + 20 + nCol*2 ); 3028 if( zSql==0 ){ 3029 fprintf(stderr, "Error: out of memory\n"); 3030 xCloser(sCtx.in); 3031 return 1; 3032 } 3033 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable); 3034 j = strlen30(zSql); 3035 for(i=1; i<nCol; i++){ 3036 zSql[j++] = ','; 3037 zSql[j++] = '?'; 3038 } 3039 zSql[j++] = ')'; 3040 zSql[j] = 0; 3041 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 3042 sqlite3_free(zSql); 3043 if( rc ){ 3044 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db)); 3045 if (pStmt) sqlite3_finalize(pStmt); 3046 xCloser(sCtx.in); 3047 return 1; 3048 } 3049 needCommit = sqlite3_get_autocommit(db); 3050 if( needCommit ) sqlite3_exec(db, "BEGIN", 0, 0, 0); 3051 do{ 3052 int startLine = sCtx.nLine; 3053 for(i=0; i<nCol; i++){ 3054 char *z = xRead(&sCtx); 3055 /* 3056 ** Did we reach end-of-file before finding any columns? 3057 ** If so, stop instead of NULL filling the remaining columns. 3058 */ 3059 if( z==0 && i==0 ) break; 3060 /* 3061 ** Did we reach end-of-file OR end-of-line before finding any 3062 ** columns in ASCII mode? If so, stop instead of NULL filling 3063 ** the remaining columns. 3064 */ 3065 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break; 3066 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT); 3067 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){ 3068 fprintf(stderr, "%s:%d: expected %d columns but found %d - " 3069 "filling the rest with NULL\n", 3070 sCtx.zFile, startLine, nCol, i+1); 3071 i += 2; 3072 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; } 3073 } 3074 } 3075 if( sCtx.cTerm==sCtx.cColSep ){ 3076 do{ 3077 xRead(&sCtx); 3078 i++; 3079 }while( sCtx.cTerm==sCtx.cColSep ); 3080 fprintf(stderr, "%s:%d: expected %d columns but found %d - " 3081 "extras ignored\n", 3082 sCtx.zFile, startLine, nCol, i); 3083 } 3084 if( i>=nCol ){ 3085 sqlite3_step(pStmt); 3086 rc = sqlite3_reset(pStmt); 3087 if( rc!=SQLITE_OK ){ 3088 fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, startLine, 3089 sqlite3_errmsg(db)); 3090 } 3091 } 3092 }while( sCtx.cTerm!=EOF ); 3093 3094 xCloser(sCtx.in); 3095 sqlite3_free(sCtx.z); 3096 sqlite3_finalize(pStmt); 3097 if( needCommit ) sqlite3_exec(db, "COMMIT", 0, 0, 0); 3098 }else 3099 3100 if( c=='i' && (strncmp(azArg[0], "indices", n)==0 3101 || strncmp(azArg[0], "indexes", n)==0) ){ 3102 ShellState data; 3103 char *zErrMsg = 0; 3104 open_db(p, 0); 3105 memcpy(&data, p, sizeof(data)); 3106 data.showHeader = 0; 3107 data.mode = MODE_List; 3108 if( nArg==1 ){ 3109 rc = sqlite3_exec(p->db, 3110 "SELECT name FROM sqlite_master " 3111 "WHERE type='index' AND name NOT LIKE 'sqlite_%' " 3112 "UNION ALL " 3113 "SELECT name FROM sqlite_temp_master " 3114 "WHERE type='index' " 3115 "ORDER BY 1", 3116 callback, &data, &zErrMsg 3117 ); 3118 }else if( nArg==2 ){ 3119 zShellStatic = azArg[1]; 3120 rc = sqlite3_exec(p->db, 3121 "SELECT name FROM sqlite_master " 3122 "WHERE type='index' AND tbl_name LIKE shellstatic() " 3123 "UNION ALL " 3124 "SELECT name FROM sqlite_temp_master " 3125 "WHERE type='index' AND tbl_name LIKE shellstatic() " 3126 "ORDER BY 1", 3127 callback, &data, &zErrMsg 3128 ); 3129 zShellStatic = 0; 3130 }else{ 3131 fprintf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n"); 3132 rc = 1; 3133 goto meta_command_exit; 3134 } 3135 if( zErrMsg ){ 3136 fprintf(stderr,"Error: %s\n", zErrMsg); 3137 sqlite3_free(zErrMsg); 3138 rc = 1; 3139 }else if( rc != SQLITE_OK ){ 3140 fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n"); 3141 rc = 1; 3142 } 3143 }else 3144 3145 #ifdef SQLITE_ENABLE_IOTRACE 3146 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ 3147 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...); 3148 if( iotrace && iotrace!=stdout ) fclose(iotrace); 3149 iotrace = 0; 3150 if( nArg<2 ){ 3151 sqlite3IoTrace = 0; 3152 }else if( strcmp(azArg[1], "-")==0 ){ 3153 sqlite3IoTrace = iotracePrintf; 3154 iotrace = stdout; 3155 }else{ 3156 iotrace = fopen(azArg[1], "w"); 3157 if( iotrace==0 ){ 3158 fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); 3159 sqlite3IoTrace = 0; 3160 rc = 1; 3161 }else{ 3162 sqlite3IoTrace = iotracePrintf; 3163 } 3164 } 3165 }else 3166 #endif 3167 3168 #ifndef SQLITE_OMIT_LOAD_EXTENSION 3169 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){ 3170 const char *zFile, *zProc; 3171 char *zErrMsg = 0; 3172 if( nArg<2 ){ 3173 fprintf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n"); 3174 rc = 1; 3175 goto meta_command_exit; 3176 } 3177 zFile = azArg[1]; 3178 zProc = nArg>=3 ? azArg[2] : 0; 3179 open_db(p, 0); 3180 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); 3181 if( rc!=SQLITE_OK ){ 3182 fprintf(stderr, "Error: %s\n", zErrMsg); 3183 sqlite3_free(zErrMsg); 3184 rc = 1; 3185 } 3186 }else 3187 #endif 3188 3189 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){ 3190 if( nArg!=2 ){ 3191 fprintf(stderr, "Usage: .log FILENAME\n"); 3192 rc = 1; 3193 }else{ 3194 const char *zFile = azArg[1]; 3195 output_file_close(p->pLog); 3196 p->pLog = output_file_open(zFile); 3197 } 3198 }else 3199 3200 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){ 3201 const char *zMode = nArg>=2 ? azArg[1] : ""; 3202 int n2 = (int)strlen(zMode); 3203 int c2 = zMode[0]; 3204 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){ 3205 p->mode = MODE_Line; 3206 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){ 3207 p->mode = MODE_Column; 3208 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){ 3209 p->mode = MODE_List; 3210 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){ 3211 p->mode = MODE_Html; 3212 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){ 3213 p->mode = MODE_Tcl; 3214 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space); 3215 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){ 3216 p->mode = MODE_Csv; 3217 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 3218 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 3219 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){ 3220 p->mode = MODE_List; 3221 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab); 3222 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){ 3223 p->mode = MODE_Insert; 3224 set_table_name(p, nArg>=3 ? azArg[2] : "table"); 3225 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){ 3226 p->mode = MODE_Ascii; 3227 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit); 3228 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record); 3229 }else { 3230 fprintf(stderr,"Error: mode should be one of: " 3231 "ascii column csv html insert line list tabs tcl\n"); 3232 rc = 1; 3233 } 3234 }else 3235 3236 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){ 3237 if( nArg==2 ){ 3238 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue, 3239 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]); 3240 }else{ 3241 fprintf(stderr, "Usage: .nullvalue STRING\n"); 3242 rc = 1; 3243 } 3244 }else 3245 3246 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){ 3247 sqlite3 *savedDb = p->db; 3248 const char *zSavedFilename = p->zDbFilename; 3249 char *zNewFilename = 0; 3250 p->db = 0; 3251 if( nArg>=2 ){ 3252 p->zDbFilename = zNewFilename = sqlite3_mprintf("%s", azArg[1]); 3253 } 3254 open_db(p, 1); 3255 if( p->db!=0 ){ 3256 sqlite3_close(savedDb); 3257 sqlite3_free(p->zFreeOnClose); 3258 p->zFreeOnClose = zNewFilename; 3259 }else{ 3260 sqlite3_free(zNewFilename); 3261 p->db = savedDb; 3262 p->zDbFilename = zSavedFilename; 3263 } 3264 }else 3265 3266 if( c=='o' 3267 && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0) 3268 ){ 3269 const char *zFile = nArg>=2 ? azArg[1] : "stdout"; 3270 if( nArg>2 ){ 3271 fprintf(stderr, "Usage: .%s FILE\n", azArg[0]); 3272 rc = 1; 3273 goto meta_command_exit; 3274 } 3275 if( n>1 && strncmp(azArg[0], "once", n)==0 ){ 3276 if( nArg<2 ){ 3277 fprintf(stderr, "Usage: .once FILE\n"); 3278 rc = 1; 3279 goto meta_command_exit; 3280 } 3281 p->outCount = 2; 3282 }else{ 3283 p->outCount = 0; 3284 } 3285 output_reset(p); 3286 if( zFile[0]=='|' ){ 3287 #ifdef SQLITE_OMIT_POPEN 3288 fprintf(stderr,"Error: pipes are not supported in this OS\n"); 3289 rc = 1; 3290 p->out = stdout; 3291 #else 3292 p->out = popen(zFile + 1, "w"); 3293 if( p->out==0 ){ 3294 fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1); 3295 p->out = stdout; 3296 rc = 1; 3297 }else{ 3298 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 3299 } 3300 #endif 3301 }else{ 3302 p->out = output_file_open(zFile); 3303 if( p->out==0 ){ 3304 if( strcmp(zFile,"off")!=0 ){ 3305 fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile); 3306 } 3307 p->out = stdout; 3308 rc = 1; 3309 } else { 3310 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 3311 } 3312 } 3313 }else 3314 3315 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){ 3316 int i; 3317 for(i=1; i<nArg; i++){ 3318 if( i>1 ) fprintf(p->out, " "); 3319 fprintf(p->out, "%s", azArg[i]); 3320 } 3321 fprintf(p->out, "\n"); 3322 }else 3323 3324 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){ 3325 if( nArg >= 2) { 3326 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); 3327 } 3328 if( nArg >= 3) { 3329 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); 3330 } 3331 }else 3332 3333 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){ 3334 rc = 2; 3335 }else 3336 3337 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){ 3338 FILE *alt; 3339 if( nArg!=2 ){ 3340 fprintf(stderr, "Usage: .read FILE\n"); 3341 rc = 1; 3342 goto meta_command_exit; 3343 } 3344 alt = fopen(azArg[1], "rb"); 3345 if( alt==0 ){ 3346 fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); 3347 rc = 1; 3348 }else{ 3349 rc = process_input(p, alt); 3350 fclose(alt); 3351 } 3352 }else 3353 3354 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){ 3355 const char *zSrcFile; 3356 const char *zDb; 3357 sqlite3 *pSrc; 3358 sqlite3_backup *pBackup; 3359 int nTimeout = 0; 3360 3361 if( nArg==2 ){ 3362 zSrcFile = azArg[1]; 3363 zDb = "main"; 3364 }else if( nArg==3 ){ 3365 zSrcFile = azArg[2]; 3366 zDb = azArg[1]; 3367 }else{ 3368 fprintf(stderr, "Usage: .restore ?DB? FILE\n"); 3369 rc = 1; 3370 goto meta_command_exit; 3371 } 3372 rc = sqlite3_open(zSrcFile, &pSrc); 3373 if( rc!=SQLITE_OK ){ 3374 fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); 3375 sqlite3_close(pSrc); 3376 return 1; 3377 } 3378 open_db(p, 0); 3379 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); 3380 if( pBackup==0 ){ 3381 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 3382 sqlite3_close(pSrc); 3383 return 1; 3384 } 3385 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK 3386 || rc==SQLITE_BUSY ){ 3387 if( rc==SQLITE_BUSY ){ 3388 if( nTimeout++ >= 3 ) break; 3389 sqlite3_sleep(100); 3390 } 3391 } 3392 sqlite3_backup_finish(pBackup); 3393 if( rc==SQLITE_DONE ){ 3394 rc = 0; 3395 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ 3396 fprintf(stderr, "Error: source database is busy\n"); 3397 rc = 1; 3398 }else{ 3399 fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 3400 rc = 1; 3401 } 3402 sqlite3_close(pSrc); 3403 }else 3404 3405 3406 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){ 3407 if( nArg==2 ){ 3408 p->scanstatsOn = booleanValue(azArg[1]); 3409 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS 3410 fprintf(stderr, "Warning: .scanstats not available in this build.\n"); 3411 #endif 3412 }else{ 3413 fprintf(stderr, "Usage: .scanstats on|off\n"); 3414 rc = 1; 3415 } 3416 }else 3417 3418 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){ 3419 ShellState data; 3420 char *zErrMsg = 0; 3421 open_db(p, 0); 3422 memcpy(&data, p, sizeof(data)); 3423 data.showHeader = 0; 3424 data.mode = MODE_Semi; 3425 if( nArg==2 ){ 3426 int i; 3427 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]); 3428 if( strcmp(azArg[1],"sqlite_master")==0 ){ 3429 char *new_argv[2], *new_colv[2]; 3430 new_argv[0] = "CREATE TABLE sqlite_master (\n" 3431 " type text,\n" 3432 " name text,\n" 3433 " tbl_name text,\n" 3434 " rootpage integer,\n" 3435 " sql text\n" 3436 ")"; 3437 new_argv[1] = 0; 3438 new_colv[0] = "sql"; 3439 new_colv[1] = 0; 3440 callback(&data, 1, new_argv, new_colv); 3441 rc = SQLITE_OK; 3442 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){ 3443 char *new_argv[2], *new_colv[2]; 3444 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n" 3445 " type text,\n" 3446 " name text,\n" 3447 " tbl_name text,\n" 3448 " rootpage integer,\n" 3449 " sql text\n" 3450 ")"; 3451 new_argv[1] = 0; 3452 new_colv[0] = "sql"; 3453 new_colv[1] = 0; 3454 callback(&data, 1, new_argv, new_colv); 3455 rc = SQLITE_OK; 3456 }else{ 3457 zShellStatic = azArg[1]; 3458 rc = sqlite3_exec(p->db, 3459 "SELECT sql FROM " 3460 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" 3461 " FROM sqlite_master UNION ALL" 3462 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " 3463 "WHERE lower(tbl_name) LIKE shellstatic()" 3464 " AND type!='meta' AND sql NOTNULL " 3465 "ORDER BY rowid", 3466 callback, &data, &zErrMsg); 3467 zShellStatic = 0; 3468 } 3469 }else if( nArg==1 ){ 3470 rc = sqlite3_exec(p->db, 3471 "SELECT sql FROM " 3472 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" 3473 " FROM sqlite_master UNION ALL" 3474 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " 3475 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " 3476 "ORDER BY rowid", 3477 callback, &data, &zErrMsg 3478 ); 3479 }else{ 3480 fprintf(stderr, "Usage: .schema ?LIKE-PATTERN?\n"); 3481 rc = 1; 3482 goto meta_command_exit; 3483 } 3484 if( zErrMsg ){ 3485 fprintf(stderr,"Error: %s\n", zErrMsg); 3486 sqlite3_free(zErrMsg); 3487 rc = 1; 3488 }else if( rc != SQLITE_OK ){ 3489 fprintf(stderr,"Error: querying schema information\n"); 3490 rc = 1; 3491 }else{ 3492 rc = 0; 3493 } 3494 }else 3495 3496 3497 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 3498 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){ 3499 extern int sqlite3SelectTrace; 3500 sqlite3SelectTrace = integerValue(azArg[1]); 3501 }else 3502 #endif 3503 3504 3505 #ifdef SQLITE_DEBUG 3506 /* Undocumented commands for internal testing. Subject to change 3507 ** without notice. */ 3508 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){ 3509 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){ 3510 int i, v; 3511 for(i=1; i<nArg; i++){ 3512 v = booleanValue(azArg[i]); 3513 fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v); 3514 } 3515 } 3516 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){ 3517 int i; sqlite3_int64 v; 3518 for(i=1; i<nArg; i++){ 3519 char zBuf[200]; 3520 v = integerValue(azArg[i]); 3521 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v); 3522 fprintf(p->out, "%s", zBuf); 3523 } 3524 } 3525 }else 3526 #endif 3527 3528 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){ 3529 if( nArg<2 || nArg>3 ){ 3530 fprintf(stderr, "Usage: .separator COL ?ROW?\n"); 3531 rc = 1; 3532 } 3533 if( nArg>=2 ){ 3534 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, 3535 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]); 3536 } 3537 if( nArg>=3 ){ 3538 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, 3539 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]); 3540 } 3541 }else 3542 3543 if( c=='s' 3544 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0) 3545 ){ 3546 char *zCmd; 3547 int i, x; 3548 if( nArg<2 ){ 3549 fprintf(stderr, "Usage: .system COMMAND\n"); 3550 rc = 1; 3551 goto meta_command_exit; 3552 } 3553 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]); 3554 for(i=2; i<nArg; i++){ 3555 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"", 3556 zCmd, azArg[i]); 3557 } 3558 x = system(zCmd); 3559 sqlite3_free(zCmd); 3560 if( x ) fprintf(stderr, "System command returns %d\n", x); 3561 }else 3562 3563 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){ 3564 int i; 3565 if( nArg!=1 ){ 3566 fprintf(stderr, "Usage: .show\n"); 3567 rc = 1; 3568 goto meta_command_exit; 3569 } 3570 fprintf(p->out,"%12.12s: %s\n","echo", p->echoOn ? "on" : "off"); 3571 fprintf(p->out,"%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off"); 3572 fprintf(p->out,"%9.9s: %s\n","explain", p->normalMode.valid ? "on" :"off"); 3573 fprintf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off"); 3574 fprintf(p->out,"%12.12s: %s\n","mode", modeDescr[p->mode]); 3575 fprintf(p->out,"%12.12s: ", "nullvalue"); 3576 output_c_string(p->out, p->nullValue); 3577 fprintf(p->out, "\n"); 3578 fprintf(p->out,"%12.12s: %s\n","output", 3579 strlen30(p->outfile) ? p->outfile : "stdout"); 3580 fprintf(p->out,"%12.12s: ", "colseparator"); 3581 output_c_string(p->out, p->colSeparator); 3582 fprintf(p->out, "\n"); 3583 fprintf(p->out,"%12.12s: ", "rowseparator"); 3584 output_c_string(p->out, p->rowSeparator); 3585 fprintf(p->out, "\n"); 3586 fprintf(p->out,"%12.12s: %s\n","stats", p->statsOn ? "on" : "off"); 3587 fprintf(p->out,"%12.12s: ","width"); 3588 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) { 3589 fprintf(p->out,"%d ",p->colWidth[i]); 3590 } 3591 fprintf(p->out,"\n"); 3592 }else 3593 3594 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){ 3595 if( nArg==2 ){ 3596 p->statsOn = booleanValue(azArg[1]); 3597 }else{ 3598 fprintf(stderr, "Usage: .stats on|off\n"); 3599 rc = 1; 3600 } 3601 }else 3602 3603 if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){ 3604 sqlite3_stmt *pStmt; 3605 char **azResult; 3606 int nRow, nAlloc; 3607 char *zSql = 0; 3608 int ii; 3609 open_db(p, 0); 3610 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); 3611 if( rc ) return rc; 3612 zSql = sqlite3_mprintf( 3613 "SELECT name FROM sqlite_master" 3614 " WHERE type IN ('table','view')" 3615 " AND name NOT LIKE 'sqlite_%%'" 3616 " AND name LIKE ?1"); 3617 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 3618 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1); 3619 if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue; 3620 if( strcmp(zDbName,"temp")==0 ){ 3621 zSql = sqlite3_mprintf( 3622 "%z UNION ALL " 3623 "SELECT 'temp.' || name FROM sqlite_temp_master" 3624 " WHERE type IN ('table','view')" 3625 " AND name NOT LIKE 'sqlite_%%'" 3626 " AND name LIKE ?1", zSql); 3627 }else{ 3628 zSql = sqlite3_mprintf( 3629 "%z UNION ALL " 3630 "SELECT '%q.' || name FROM \"%w\".sqlite_master" 3631 " WHERE type IN ('table','view')" 3632 " AND name NOT LIKE 'sqlite_%%'" 3633 " AND name LIKE ?1", zSql, zDbName, zDbName); 3634 } 3635 } 3636 sqlite3_finalize(pStmt); 3637 zSql = sqlite3_mprintf("%z ORDER BY 1", zSql); 3638 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 3639 sqlite3_free(zSql); 3640 if( rc ) return rc; 3641 nRow = nAlloc = 0; 3642 azResult = 0; 3643 if( nArg>1 ){ 3644 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT); 3645 }else{ 3646 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC); 3647 } 3648 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 3649 if( nRow>=nAlloc ){ 3650 char **azNew; 3651 int n = nAlloc*2 + 10; 3652 azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n); 3653 if( azNew==0 ){ 3654 fprintf(stderr, "Error: out of memory\n"); 3655 break; 3656 } 3657 nAlloc = n; 3658 azResult = azNew; 3659 } 3660 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0)); 3661 if( azResult[nRow] ) nRow++; 3662 } 3663 sqlite3_finalize(pStmt); 3664 if( nRow>0 ){ 3665 int len, maxlen = 0; 3666 int i, j; 3667 int nPrintCol, nPrintRow; 3668 for(i=0; i<nRow; i++){ 3669 len = strlen30(azResult[i]); 3670 if( len>maxlen ) maxlen = len; 3671 } 3672 nPrintCol = 80/(maxlen+2); 3673 if( nPrintCol<1 ) nPrintCol = 1; 3674 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; 3675 for(i=0; i<nPrintRow; i++){ 3676 for(j=i; j<nRow; j+=nPrintRow){ 3677 char *zSp = j<nPrintRow ? "" : " "; 3678 fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:""); 3679 } 3680 fprintf(p->out, "\n"); 3681 } 3682 } 3683 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]); 3684 sqlite3_free(azResult); 3685 }else 3686 3687 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){ 3688 static const struct { 3689 const char *zCtrlName; /* Name of a test-control option */ 3690 int ctrlCode; /* Integer code for that option */ 3691 } aCtrl[] = { 3692 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE }, 3693 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE }, 3694 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET }, 3695 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST }, 3696 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL }, 3697 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS }, 3698 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE }, 3699 { "assert", SQLITE_TESTCTRL_ASSERT }, 3700 { "always", SQLITE_TESTCTRL_ALWAYS }, 3701 { "reserve", SQLITE_TESTCTRL_RESERVE }, 3702 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS }, 3703 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD }, 3704 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC }, 3705 { "byteorder", SQLITE_TESTCTRL_BYTEORDER }, 3706 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT }, 3707 { "imposter", SQLITE_TESTCTRL_IMPOSTER }, 3708 }; 3709 int testctrl = -1; 3710 int rc = 0; 3711 int i, n; 3712 open_db(p, 0); 3713 3714 /* convert testctrl text option to value. allow any unique prefix 3715 ** of the option name, or a numerical value. */ 3716 n = strlen30(azArg[1]); 3717 for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){ 3718 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){ 3719 if( testctrl<0 ){ 3720 testctrl = aCtrl[i].ctrlCode; 3721 }else{ 3722 fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]); 3723 testctrl = -1; 3724 break; 3725 } 3726 } 3727 } 3728 if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]); 3729 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){ 3730 fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]); 3731 }else{ 3732 switch(testctrl){ 3733 3734 /* sqlite3_test_control(int, db, int) */ 3735 case SQLITE_TESTCTRL_OPTIMIZATIONS: 3736 case SQLITE_TESTCTRL_RESERVE: 3737 if( nArg==3 ){ 3738 int opt = (int)strtol(azArg[2], 0, 0); 3739 rc = sqlite3_test_control(testctrl, p->db, opt); 3740 fprintf(p->out, "%d (0x%08x)\n", rc, rc); 3741 } else { 3742 fprintf(stderr,"Error: testctrl %s takes a single int option\n", 3743 azArg[1]); 3744 } 3745 break; 3746 3747 /* sqlite3_test_control(int) */ 3748 case SQLITE_TESTCTRL_PRNG_SAVE: 3749 case SQLITE_TESTCTRL_PRNG_RESTORE: 3750 case SQLITE_TESTCTRL_PRNG_RESET: 3751 case SQLITE_TESTCTRL_BYTEORDER: 3752 if( nArg==2 ){ 3753 rc = sqlite3_test_control(testctrl); 3754 fprintf(p->out, "%d (0x%08x)\n", rc, rc); 3755 } else { 3756 fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]); 3757 } 3758 break; 3759 3760 /* sqlite3_test_control(int, uint) */ 3761 case SQLITE_TESTCTRL_PENDING_BYTE: 3762 if( nArg==3 ){ 3763 unsigned int opt = (unsigned int)integerValue(azArg[2]); 3764 rc = sqlite3_test_control(testctrl, opt); 3765 fprintf(p->out, "%d (0x%08x)\n", rc, rc); 3766 } else { 3767 fprintf(stderr,"Error: testctrl %s takes a single unsigned" 3768 " int option\n", azArg[1]); 3769 } 3770 break; 3771 3772 /* sqlite3_test_control(int, int) */ 3773 case SQLITE_TESTCTRL_ASSERT: 3774 case SQLITE_TESTCTRL_ALWAYS: 3775 case SQLITE_TESTCTRL_NEVER_CORRUPT: 3776 if( nArg==3 ){ 3777 int opt = booleanValue(azArg[2]); 3778 rc = sqlite3_test_control(testctrl, opt); 3779 fprintf(p->out, "%d (0x%08x)\n", rc, rc); 3780 } else { 3781 fprintf(stderr,"Error: testctrl %s takes a single int option\n", 3782 azArg[1]); 3783 } 3784 break; 3785 3786 /* sqlite3_test_control(int, char *) */ 3787 #ifdef SQLITE_N_KEYWORD 3788 case SQLITE_TESTCTRL_ISKEYWORD: 3789 if( nArg==3 ){ 3790 const char *opt = azArg[2]; 3791 rc = sqlite3_test_control(testctrl, opt); 3792 fprintf(p->out, "%d (0x%08x)\n", rc, rc); 3793 } else { 3794 fprintf(stderr,"Error: testctrl %s takes a single char * option\n", 3795 azArg[1]); 3796 } 3797 break; 3798 #endif 3799 3800 case SQLITE_TESTCTRL_IMPOSTER: 3801 if( nArg==5 ){ 3802 rc = sqlite3_test_control(testctrl, p->db, 3803 azArg[2], 3804 integerValue(azArg[3]), 3805 integerValue(azArg[4])); 3806 fprintf(p->out, "%d (0x%08x)\n", rc, rc); 3807 }else{ 3808 fprintf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n"); 3809 } 3810 break; 3811 3812 case SQLITE_TESTCTRL_BITVEC_TEST: 3813 case SQLITE_TESTCTRL_FAULT_INSTALL: 3814 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: 3815 case SQLITE_TESTCTRL_SCRATCHMALLOC: 3816 default: 3817 fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n", 3818 azArg[1]); 3819 break; 3820 } 3821 } 3822 }else 3823 3824 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){ 3825 open_db(p, 0); 3826 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0); 3827 }else 3828 3829 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){ 3830 if( nArg==2 ){ 3831 enableTimer = booleanValue(azArg[1]); 3832 if( enableTimer && !HAS_TIMER ){ 3833 fprintf(stderr, "Error: timer not available on this system.\n"); 3834 enableTimer = 0; 3835 } 3836 }else{ 3837 fprintf(stderr, "Usage: .timer on|off\n"); 3838 rc = 1; 3839 } 3840 }else 3841 3842 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){ 3843 open_db(p, 0); 3844 if( nArg!=2 ){ 3845 fprintf(stderr, "Usage: .trace FILE|off\n"); 3846 rc = 1; 3847 goto meta_command_exit; 3848 } 3849 output_file_close(p->traceOut); 3850 p->traceOut = output_file_open(azArg[1]); 3851 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) 3852 if( p->traceOut==0 ){ 3853 sqlite3_trace(p->db, 0, 0); 3854 }else{ 3855 sqlite3_trace(p->db, sql_trace_callback, p->traceOut); 3856 } 3857 #endif 3858 }else 3859 3860 #if SQLITE_USER_AUTHENTICATION 3861 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){ 3862 if( nArg<2 ){ 3863 fprintf(stderr, "Usage: .user SUBCOMMAND ...\n"); 3864 rc = 1; 3865 goto meta_command_exit; 3866 } 3867 open_db(p, 0); 3868 if( strcmp(azArg[1],"login")==0 ){ 3869 if( nArg!=4 ){ 3870 fprintf(stderr, "Usage: .user login USER PASSWORD\n"); 3871 rc = 1; 3872 goto meta_command_exit; 3873 } 3874 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3], 3875 (int)strlen(azArg[3])); 3876 if( rc ){ 3877 fprintf(stderr, "Authentication failed for user %s\n", azArg[2]); 3878 rc = 1; 3879 } 3880 }else if( strcmp(azArg[1],"add")==0 ){ 3881 if( nArg!=5 ){ 3882 fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n"); 3883 rc = 1; 3884 goto meta_command_exit; 3885 } 3886 rc = sqlite3_user_add(p->db, azArg[2], 3887 azArg[3], (int)strlen(azArg[3]), 3888 booleanValue(azArg[4])); 3889 if( rc ){ 3890 fprintf(stderr, "User-Add failed: %d\n", rc); 3891 rc = 1; 3892 } 3893 }else if( strcmp(azArg[1],"edit")==0 ){ 3894 if( nArg!=5 ){ 3895 fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n"); 3896 rc = 1; 3897 goto meta_command_exit; 3898 } 3899 rc = sqlite3_user_change(p->db, azArg[2], 3900 azArg[3], (int)strlen(azArg[3]), 3901 booleanValue(azArg[4])); 3902 if( rc ){ 3903 fprintf(stderr, "User-Edit failed: %d\n", rc); 3904 rc = 1; 3905 } 3906 }else if( strcmp(azArg[1],"delete")==0 ){ 3907 if( nArg!=3 ){ 3908 fprintf(stderr, "Usage: .user delete USER\n"); 3909 rc = 1; 3910 goto meta_command_exit; 3911 } 3912 rc = sqlite3_user_delete(p->db, azArg[2]); 3913 if( rc ){ 3914 fprintf(stderr, "User-Delete failed: %d\n", rc); 3915 rc = 1; 3916 } 3917 }else{ 3918 fprintf(stderr, "Usage: .user login|add|edit|delete ...\n"); 3919 rc = 1; 3920 goto meta_command_exit; 3921 } 3922 }else 3923 #endif /* SQLITE_USER_AUTHENTICATION */ 3924 3925 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){ 3926 fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/, 3927 sqlite3_libversion(), sqlite3_sourceid()); 3928 }else 3929 3930 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){ 3931 const char *zDbName = nArg==2 ? azArg[1] : "main"; 3932 char *zVfsName = 0; 3933 if( p->db ){ 3934 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName); 3935 if( zVfsName ){ 3936 fprintf(p->out, "%s\n", zVfsName); 3937 sqlite3_free(zVfsName); 3938 } 3939 } 3940 }else 3941 3942 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 3943 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){ 3944 extern int sqlite3WhereTrace; 3945 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff; 3946 }else 3947 #endif 3948 3949 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ 3950 int j; 3951 assert( nArg<=ArraySize(azArg) ); 3952 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){ 3953 p->colWidth[j-1] = (int)integerValue(azArg[j]); 3954 } 3955 }else 3956 3957 { 3958 fprintf(stderr, "Error: unknown command or invalid arguments: " 3959 " \"%s\". Enter \".help\" for help\n", azArg[0]); 3960 rc = 1; 3961 } 3962 3963 meta_command_exit: 3964 if( p->outCount ){ 3965 p->outCount--; 3966 if( p->outCount==0 ) output_reset(p); 3967 } 3968 return rc; 3969 } 3970 3971 /* 3972 ** Return TRUE if a semicolon occurs anywhere in the first N characters 3973 ** of string z[]. 3974 */ 3975 static int line_contains_semicolon(const char *z, int N){ 3976 int i; 3977 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; } 3978 return 0; 3979 } 3980 3981 /* 3982 ** Test to see if a line consists entirely of whitespace. 3983 */ 3984 static int _all_whitespace(const char *z){ 3985 for(; *z; z++){ 3986 if( IsSpace(z[0]) ) continue; 3987 if( *z=='/' && z[1]=='*' ){ 3988 z += 2; 3989 while( *z && (*z!='*' || z[1]!='/') ){ z++; } 3990 if( *z==0 ) return 0; 3991 z++; 3992 continue; 3993 } 3994 if( *z=='-' && z[1]=='-' ){ 3995 z += 2; 3996 while( *z && *z!='\n' ){ z++; } 3997 if( *z==0 ) return 1; 3998 continue; 3999 } 4000 return 0; 4001 } 4002 return 1; 4003 } 4004 4005 /* 4006 ** Return TRUE if the line typed in is an SQL command terminator other 4007 ** than a semi-colon. The SQL Server style "go" command is understood 4008 ** as is the Oracle "/". 4009 */ 4010 static int line_is_command_terminator(const char *zLine){ 4011 while( IsSpace(zLine[0]) ){ zLine++; }; 4012 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){ 4013 return 1; /* Oracle */ 4014 } 4015 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' 4016 && _all_whitespace(&zLine[2]) ){ 4017 return 1; /* SQL Server */ 4018 } 4019 return 0; 4020 } 4021 4022 /* 4023 ** Return true if zSql is a complete SQL statement. Return false if it 4024 ** ends in the middle of a string literal or C-style comment. 4025 */ 4026 static int line_is_complete(char *zSql, int nSql){ 4027 int rc; 4028 if( zSql==0 ) return 1; 4029 zSql[nSql] = ';'; 4030 zSql[nSql+1] = 0; 4031 rc = sqlite3_complete(zSql); 4032 zSql[nSql] = 0; 4033 return rc; 4034 } 4035 4036 /* 4037 ** Read input from *in and process it. If *in==0 then input 4038 ** is interactive - the user is typing it it. Otherwise, input 4039 ** is coming from a file or device. A prompt is issued and history 4040 ** is saved only if input is interactive. An interrupt signal will 4041 ** cause this routine to exit immediately, unless input is interactive. 4042 ** 4043 ** Return the number of errors. 4044 */ 4045 static int process_input(ShellState *p, FILE *in){ 4046 char *zLine = 0; /* A single input line */ 4047 char *zSql = 0; /* Accumulated SQL text */ 4048 int nLine; /* Length of current line */ 4049 int nSql = 0; /* Bytes of zSql[] used */ 4050 int nAlloc = 0; /* Allocated zSql[] space */ 4051 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */ 4052 char *zErrMsg; /* Error message returned */ 4053 int rc; /* Error code */ 4054 int errCnt = 0; /* Number of errors seen */ 4055 int lineno = 0; /* Current line number */ 4056 int startline = 0; /* Line number for start of current input */ 4057 4058 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){ 4059 fflush(p->out); 4060 zLine = one_input_line(in, zLine, nSql>0); 4061 if( zLine==0 ){ 4062 /* End of input */ 4063 if( stdin_is_interactive ) printf("\n"); 4064 break; 4065 } 4066 if( seenInterrupt ){ 4067 if( in!=0 ) break; 4068 seenInterrupt = 0; 4069 } 4070 lineno++; 4071 if( nSql==0 && _all_whitespace(zLine) ){ 4072 if( p->echoOn ) printf("%s\n", zLine); 4073 continue; 4074 } 4075 if( zLine && zLine[0]=='.' && nSql==0 ){ 4076 if( p->echoOn ) printf("%s\n", zLine); 4077 rc = do_meta_command(zLine, p); 4078 if( rc==2 ){ /* exit requested */ 4079 break; 4080 }else if( rc ){ 4081 errCnt++; 4082 } 4083 continue; 4084 } 4085 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){ 4086 memcpy(zLine,";",2); 4087 } 4088 nLine = strlen30(zLine); 4089 if( nSql+nLine+2>=nAlloc ){ 4090 nAlloc = nSql+nLine+100; 4091 zSql = realloc(zSql, nAlloc); 4092 if( zSql==0 ){ 4093 fprintf(stderr, "Error: out of memory\n"); 4094 exit(1); 4095 } 4096 } 4097 nSqlPrior = nSql; 4098 if( nSql==0 ){ 4099 int i; 4100 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){} 4101 assert( nAlloc>0 && zSql!=0 ); 4102 memcpy(zSql, zLine+i, nLine+1-i); 4103 startline = lineno; 4104 nSql = nLine-i; 4105 }else{ 4106 zSql[nSql++] = '\n'; 4107 memcpy(zSql+nSql, zLine, nLine+1); 4108 nSql += nLine; 4109 } 4110 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) 4111 && sqlite3_complete(zSql) ){ 4112 p->cnt = 0; 4113 open_db(p, 0); 4114 BEGIN_TIMER; 4115 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg); 4116 END_TIMER; 4117 if( rc || zErrMsg ){ 4118 char zPrefix[100]; 4119 if( in!=0 || !stdin_is_interactive ){ 4120 sqlite3_snprintf(sizeof(zPrefix), zPrefix, 4121 "Error: near line %d:", startline); 4122 }else{ 4123 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); 4124 } 4125 if( zErrMsg!=0 ){ 4126 fprintf(stderr, "%s %s\n", zPrefix, zErrMsg); 4127 sqlite3_free(zErrMsg); 4128 zErrMsg = 0; 4129 }else{ 4130 fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); 4131 } 4132 errCnt++; 4133 } 4134 nSql = 0; 4135 if( p->outCount ){ 4136 output_reset(p); 4137 p->outCount = 0; 4138 } 4139 }else if( nSql && _all_whitespace(zSql) ){ 4140 if( p->echoOn ) printf("%s\n", zSql); 4141 nSql = 0; 4142 } 4143 } 4144 if( nSql ){ 4145 if( !_all_whitespace(zSql) ){ 4146 fprintf(stderr, "Error: incomplete SQL: %s\n", zSql); 4147 errCnt++; 4148 } 4149 free(zSql); 4150 } 4151 free(zLine); 4152 return errCnt>0; 4153 } 4154 4155 /* 4156 ** Return a pathname which is the user's home directory. A 4157 ** 0 return indicates an error of some kind. 4158 */ 4159 static char *find_home_dir(void){ 4160 static char *home_dir = NULL; 4161 if( home_dir ) return home_dir; 4162 4163 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \ 4164 && !defined(__RTP__) && !defined(_WRS_KERNEL) 4165 { 4166 struct passwd *pwent; 4167 uid_t uid = getuid(); 4168 if( (pwent=getpwuid(uid)) != NULL) { 4169 home_dir = pwent->pw_dir; 4170 } 4171 } 4172 #endif 4173 4174 #if defined(_WIN32_WCE) 4175 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() 4176 */ 4177 home_dir = "/"; 4178 #else 4179 4180 #if defined(_WIN32) || defined(WIN32) 4181 if (!home_dir) { 4182 home_dir = getenv("USERPROFILE"); 4183 } 4184 #endif 4185 4186 if (!home_dir) { 4187 home_dir = getenv("HOME"); 4188 } 4189 4190 #if defined(_WIN32) || defined(WIN32) 4191 if (!home_dir) { 4192 char *zDrive, *zPath; 4193 int n; 4194 zDrive = getenv("HOMEDRIVE"); 4195 zPath = getenv("HOMEPATH"); 4196 if( zDrive && zPath ){ 4197 n = strlen30(zDrive) + strlen30(zPath) + 1; 4198 home_dir = malloc( n ); 4199 if( home_dir==0 ) return 0; 4200 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); 4201 return home_dir; 4202 } 4203 home_dir = "c:\\"; 4204 } 4205 #endif 4206 4207 #endif /* !_WIN32_WCE */ 4208 4209 if( home_dir ){ 4210 int n = strlen30(home_dir) + 1; 4211 char *z = malloc( n ); 4212 if( z ) memcpy(z, home_dir, n); 4213 home_dir = z; 4214 } 4215 4216 return home_dir; 4217 } 4218 4219 /* 4220 ** Read input from the file given by sqliterc_override. Or if that 4221 ** parameter is NULL, take input from ~/.sqliterc 4222 ** 4223 ** Returns the number of errors. 4224 */ 4225 static void process_sqliterc( 4226 ShellState *p, /* Configuration data */ 4227 const char *sqliterc_override /* Name of config file. NULL to use default */ 4228 ){ 4229 char *home_dir = NULL; 4230 const char *sqliterc = sqliterc_override; 4231 char *zBuf = 0; 4232 FILE *in = NULL; 4233 4234 if (sqliterc == NULL) { 4235 home_dir = find_home_dir(); 4236 if( home_dir==0 ){ 4237 fprintf(stderr, "-- warning: cannot find home directory;" 4238 " cannot read ~/.sqliterc\n"); 4239 return; 4240 } 4241 sqlite3_initialize(); 4242 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir); 4243 sqliterc = zBuf; 4244 } 4245 in = fopen(sqliterc,"rb"); 4246 if( in ){ 4247 if( stdin_is_interactive ){ 4248 fprintf(stderr,"-- Loading resources from %s\n",sqliterc); 4249 } 4250 process_input(p,in); 4251 fclose(in); 4252 } 4253 sqlite3_free(zBuf); 4254 } 4255 4256 /* 4257 ** Show available command line options 4258 */ 4259 static const char zOptions[] = 4260 " -ascii set output mode to 'ascii'\n" 4261 " -bail stop after hitting an error\n" 4262 " -batch force batch I/O\n" 4263 " -column set output mode to 'column'\n" 4264 " -cmd COMMAND run \"COMMAND\" before reading stdin\n" 4265 " -csv set output mode to 'csv'\n" 4266 " -echo print commands before execution\n" 4267 " -init FILENAME read/process named file\n" 4268 " -[no]header turn headers on or off\n" 4269 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 4270 " -heap SIZE Size of heap for memsys3 or memsys5\n" 4271 #endif 4272 " -help show this message\n" 4273 " -html set output mode to HTML\n" 4274 " -interactive force interactive I/O\n" 4275 " -line set output mode to 'line'\n" 4276 " -list set output mode to 'list'\n" 4277 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n" 4278 " -mmap N default mmap size set to N\n" 4279 #ifdef SQLITE_ENABLE_MULTIPLEX 4280 " -multiplex enable the multiplexor VFS\n" 4281 #endif 4282 " -newline SEP set output row separator. Default: '\\n'\n" 4283 " -nullvalue TEXT set text string for NULL values. Default ''\n" 4284 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n" 4285 " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n" 4286 " -separator SEP set output column separator. Default: '|'\n" 4287 " -stats print memory stats before each finalize\n" 4288 " -version show SQLite version\n" 4289 " -vfs NAME use NAME as the default VFS\n" 4290 #ifdef SQLITE_ENABLE_VFSTRACE 4291 " -vfstrace enable tracing of all VFS calls\n" 4292 #endif 4293 ; 4294 static void usage(int showDetail){ 4295 fprintf(stderr, 4296 "Usage: %s [OPTIONS] FILENAME [SQL]\n" 4297 "FILENAME is the name of an SQLite database. A new database is created\n" 4298 "if the file does not previously exist.\n", Argv0); 4299 if( showDetail ){ 4300 fprintf(stderr, "OPTIONS include:\n%s", zOptions); 4301 }else{ 4302 fprintf(stderr, "Use the -help option for additional information\n"); 4303 } 4304 exit(1); 4305 } 4306 4307 /* 4308 ** Initialize the state information in data 4309 */ 4310 static void main_init(ShellState *data) { 4311 memset(data, 0, sizeof(*data)); 4312 data->mode = MODE_List; 4313 memcpy(data->colSeparator,SEP_Column, 2); 4314 memcpy(data->rowSeparator,SEP_Row, 2); 4315 data->showHeader = 0; 4316 data->shellFlgs = SHFLG_Lookaside; 4317 sqlite3_config(SQLITE_CONFIG_URI, 1); 4318 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); 4319 sqlite3_config(SQLITE_CONFIG_MULTITHREAD); 4320 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); 4321 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); 4322 } 4323 4324 /* 4325 ** Output text to the console in a font that attracts extra attention. 4326 */ 4327 #ifdef _WIN32 4328 static void printBold(const char *zText){ 4329 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); 4330 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo; 4331 GetConsoleScreenBufferInfo(out, &defaultScreenInfo); 4332 SetConsoleTextAttribute(out, 4333 FOREGROUND_RED|FOREGROUND_INTENSITY 4334 ); 4335 printf("%s", zText); 4336 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes); 4337 } 4338 #else 4339 static void printBold(const char *zText){ 4340 printf("\033[1m%s\033[0m", zText); 4341 } 4342 #endif 4343 4344 /* 4345 ** Get the argument to an --option. Throw an error and die if no argument 4346 ** is available. 4347 */ 4348 static char *cmdline_option_value(int argc, char **argv, int i){ 4349 if( i==argc ){ 4350 fprintf(stderr, "%s: Error: missing argument to %s\n", 4351 argv[0], argv[argc-1]); 4352 exit(1); 4353 } 4354 return argv[i]; 4355 } 4356 4357 int SQLITE_CDECL main(int argc, char **argv){ 4358 char *zErrMsg = 0; 4359 ShellState data; 4360 const char *zInitFile = 0; 4361 int i; 4362 int rc = 0; 4363 int warnInmemoryDb = 0; 4364 int readStdin = 1; 4365 int nCmd = 0; 4366 char **azCmd = 0; 4367 4368 #if USE_SYSTEM_SQLITE+0!=1 4369 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){ 4370 fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n", 4371 sqlite3_sourceid(), SQLITE_SOURCE_ID); 4372 exit(1); 4373 } 4374 #endif 4375 setBinaryMode(stdin); 4376 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */ 4377 Argv0 = argv[0]; 4378 main_init(&data); 4379 stdin_is_interactive = isatty(0); 4380 4381 /* Make sure we have a valid signal handler early, before anything 4382 ** else is done. 4383 */ 4384 #ifdef SIGINT 4385 signal(SIGINT, interrupt_handler); 4386 #endif 4387 4388 #ifdef SQLITE_SHELL_DBNAME_PROC 4389 { 4390 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name 4391 ** of a C-function that will provide the name of the database file. Use 4392 ** this compile-time option to embed this shell program in larger 4393 ** applications. */ 4394 extern void SQLITE_SHELL_DBNAME_PROC(const char**); 4395 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename); 4396 warnInmemoryDb = 0; 4397 } 4398 #endif 4399 4400 /* Do an initial pass through the command-line argument to locate 4401 ** the name of the database file, the name of the initialization file, 4402 ** the size of the alternative malloc heap, 4403 ** and the first command to execute. 4404 */ 4405 for(i=1; i<argc; i++){ 4406 char *z; 4407 z = argv[i]; 4408 if( z[0]!='-' ){ 4409 if( data.zDbFilename==0 ){ 4410 data.zDbFilename = z; 4411 }else{ 4412 /* Excesss arguments are interpreted as SQL (or dot-commands) and 4413 ** mean that nothing is read from stdin */ 4414 readStdin = 0; 4415 nCmd++; 4416 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd); 4417 if( azCmd==0 ){ 4418 fprintf(stderr, "out of memory\n"); 4419 exit(1); 4420 } 4421 azCmd[nCmd-1] = z; 4422 } 4423 } 4424 if( z[1]=='-' ) z++; 4425 if( strcmp(z,"-separator")==0 4426 || strcmp(z,"-nullvalue")==0 4427 || strcmp(z,"-newline")==0 4428 || strcmp(z,"-cmd")==0 4429 ){ 4430 (void)cmdline_option_value(argc, argv, ++i); 4431 }else if( strcmp(z,"-init")==0 ){ 4432 zInitFile = cmdline_option_value(argc, argv, ++i); 4433 }else if( strcmp(z,"-batch")==0 ){ 4434 /* Need to check for batch mode here to so we can avoid printing 4435 ** informational messages (like from process_sqliterc) before 4436 ** we do the actual processing of arguments later in a second pass. 4437 */ 4438 stdin_is_interactive = 0; 4439 }else if( strcmp(z,"-heap")==0 ){ 4440 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 4441 const char *zSize; 4442 sqlite3_int64 szHeap; 4443 4444 zSize = cmdline_option_value(argc, argv, ++i); 4445 szHeap = integerValue(zSize); 4446 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000; 4447 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64); 4448 #endif 4449 }else if( strcmp(z,"-scratch")==0 ){ 4450 int n, sz; 4451 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 4452 if( sz>400000 ) sz = 400000; 4453 if( sz<2500 ) sz = 2500; 4454 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 4455 if( n>10 ) n = 10; 4456 if( n<1 ) n = 1; 4457 sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n); 4458 data.shellFlgs |= SHFLG_Scratch; 4459 }else if( strcmp(z,"-pagecache")==0 ){ 4460 int n, sz; 4461 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 4462 if( sz>70000 ) sz = 70000; 4463 if( sz<800 ) sz = 800; 4464 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 4465 if( n<10 ) n = 10; 4466 sqlite3_config(SQLITE_CONFIG_PAGECACHE, malloc(n*sz+1), sz, n); 4467 data.shellFlgs |= SHFLG_Pagecache; 4468 }else if( strcmp(z,"-lookaside")==0 ){ 4469 int n, sz; 4470 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 4471 if( sz<0 ) sz = 0; 4472 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 4473 if( n<0 ) n = 0; 4474 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n); 4475 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside; 4476 #ifdef SQLITE_ENABLE_VFSTRACE 4477 }else if( strcmp(z,"-vfstrace")==0 ){ 4478 extern int vfstrace_register( 4479 const char *zTraceName, 4480 const char *zOldVfsName, 4481 int (*xOut)(const char*,void*), 4482 void *pOutArg, 4483 int makeDefault 4484 ); 4485 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1); 4486 #endif 4487 #ifdef SQLITE_ENABLE_MULTIPLEX 4488 }else if( strcmp(z,"-multiplex")==0 ){ 4489 extern int sqlite3_multiple_initialize(const char*,int); 4490 sqlite3_multiplex_initialize(0, 1); 4491 #endif 4492 }else if( strcmp(z,"-mmap")==0 ){ 4493 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 4494 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz); 4495 }else if( strcmp(z,"-vfs")==0 ){ 4496 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i)); 4497 if( pVfs ){ 4498 sqlite3_vfs_register(pVfs, 1); 4499 }else{ 4500 fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]); 4501 exit(1); 4502 } 4503 } 4504 } 4505 if( data.zDbFilename==0 ){ 4506 #ifndef SQLITE_OMIT_MEMORYDB 4507 data.zDbFilename = ":memory:"; 4508 warnInmemoryDb = argc==1; 4509 #else 4510 fprintf(stderr,"%s: Error: no database filename specified\n", Argv0); 4511 return 1; 4512 #endif 4513 } 4514 data.out = stdout; 4515 4516 /* Go ahead and open the database file if it already exists. If the 4517 ** file does not exist, delay opening it. This prevents empty database 4518 ** files from being created if a user mistypes the database name argument 4519 ** to the sqlite command-line tool. 4520 */ 4521 if( access(data.zDbFilename, 0)==0 ){ 4522 open_db(&data, 0); 4523 } 4524 4525 /* Process the initialization file if there is one. If no -init option 4526 ** is given on the command line, look for a file named ~/.sqliterc and 4527 ** try to process it. 4528 */ 4529 process_sqliterc(&data,zInitFile); 4530 4531 /* Make a second pass through the command-line argument and set 4532 ** options. This second pass is delayed until after the initialization 4533 ** file is processed so that the command-line arguments will override 4534 ** settings in the initialization file. 4535 */ 4536 for(i=1; i<argc; i++){ 4537 char *z = argv[i]; 4538 if( z[0]!='-' ) continue; 4539 if( z[1]=='-' ){ z++; } 4540 if( strcmp(z,"-init")==0 ){ 4541 i++; 4542 }else if( strcmp(z,"-html")==0 ){ 4543 data.mode = MODE_Html; 4544 }else if( strcmp(z,"-list")==0 ){ 4545 data.mode = MODE_List; 4546 }else if( strcmp(z,"-line")==0 ){ 4547 data.mode = MODE_Line; 4548 }else if( strcmp(z,"-column")==0 ){ 4549 data.mode = MODE_Column; 4550 }else if( strcmp(z,"-csv")==0 ){ 4551 data.mode = MODE_Csv; 4552 memcpy(data.colSeparator,",",2); 4553 }else if( strcmp(z,"-ascii")==0 ){ 4554 data.mode = MODE_Ascii; 4555 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 4556 SEP_Unit); 4557 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 4558 SEP_Record); 4559 }else if( strcmp(z,"-separator")==0 ){ 4560 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 4561 "%s",cmdline_option_value(argc,argv,++i)); 4562 }else if( strcmp(z,"-newline")==0 ){ 4563 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 4564 "%s",cmdline_option_value(argc,argv,++i)); 4565 }else if( strcmp(z,"-nullvalue")==0 ){ 4566 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue, 4567 "%s",cmdline_option_value(argc,argv,++i)); 4568 }else if( strcmp(z,"-header")==0 ){ 4569 data.showHeader = 1; 4570 }else if( strcmp(z,"-noheader")==0 ){ 4571 data.showHeader = 0; 4572 }else if( strcmp(z,"-echo")==0 ){ 4573 data.echoOn = 1; 4574 }else if( strcmp(z,"-eqp")==0 ){ 4575 data.autoEQP = 1; 4576 }else if( strcmp(z,"-stats")==0 ){ 4577 data.statsOn = 1; 4578 }else if( strcmp(z,"-scanstats")==0 ){ 4579 data.scanstatsOn = 1; 4580 }else if( strcmp(z,"-bail")==0 ){ 4581 bail_on_error = 1; 4582 }else if( strcmp(z,"-version")==0 ){ 4583 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid()); 4584 return 0; 4585 }else if( strcmp(z,"-interactive")==0 ){ 4586 stdin_is_interactive = 1; 4587 }else if( strcmp(z,"-batch")==0 ){ 4588 stdin_is_interactive = 0; 4589 }else if( strcmp(z,"-heap")==0 ){ 4590 i++; 4591 }else if( strcmp(z,"-scratch")==0 ){ 4592 i+=2; 4593 }else if( strcmp(z,"-pagecache")==0 ){ 4594 i+=2; 4595 }else if( strcmp(z,"-lookaside")==0 ){ 4596 i+=2; 4597 }else if( strcmp(z,"-mmap")==0 ){ 4598 i++; 4599 }else if( strcmp(z,"-vfs")==0 ){ 4600 i++; 4601 #ifdef SQLITE_ENABLE_VFSTRACE 4602 }else if( strcmp(z,"-vfstrace")==0 ){ 4603 i++; 4604 #endif 4605 #ifdef SQLITE_ENABLE_MULTIPLEX 4606 }else if( strcmp(z,"-multiplex")==0 ){ 4607 i++; 4608 #endif 4609 }else if( strcmp(z,"-help")==0 ){ 4610 usage(1); 4611 }else if( strcmp(z,"-cmd")==0 ){ 4612 /* Run commands that follow -cmd first and separately from commands 4613 ** that simply appear on the command-line. This seems goofy. It would 4614 ** be better if all commands ran in the order that they appear. But 4615 ** we retain the goofy behavior for historical compatibility. */ 4616 if( i==argc-1 ) break; 4617 z = cmdline_option_value(argc,argv,++i); 4618 if( z[0]=='.' ){ 4619 rc = do_meta_command(z, &data); 4620 if( rc && bail_on_error ) return rc==2 ? 0 : rc; 4621 }else{ 4622 open_db(&data, 0); 4623 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg); 4624 if( zErrMsg!=0 ){ 4625 fprintf(stderr,"Error: %s\n", zErrMsg); 4626 if( bail_on_error ) return rc!=0 ? rc : 1; 4627 }else if( rc!=0 ){ 4628 fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z); 4629 if( bail_on_error ) return rc; 4630 } 4631 } 4632 }else{ 4633 fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z); 4634 fprintf(stderr,"Use -help for a list of options.\n"); 4635 return 1; 4636 } 4637 } 4638 4639 if( !readStdin ){ 4640 /* Run all arguments that do not begin with '-' as if they were separate 4641 ** command-line inputs, except for the argToSkip argument which contains 4642 ** the database filename. 4643 */ 4644 for(i=0; i<nCmd; i++){ 4645 if( azCmd[i][0]=='.' ){ 4646 rc = do_meta_command(azCmd[i], &data); 4647 if( rc ) return rc==2 ? 0 : rc; 4648 }else{ 4649 open_db(&data, 0); 4650 rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg); 4651 if( zErrMsg!=0 ){ 4652 fprintf(stderr,"Error: %s\n", zErrMsg); 4653 return rc!=0 ? rc : 1; 4654 }else if( rc!=0 ){ 4655 fprintf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]); 4656 return rc; 4657 } 4658 } 4659 } 4660 free(azCmd); 4661 }else{ 4662 /* Run commands received from standard input 4663 */ 4664 if( stdin_is_interactive ){ 4665 char *zHome; 4666 char *zHistory = 0; 4667 int nHistory; 4668 printf( 4669 "SQLite version %s %.19s\n" /*extra-version-info*/ 4670 "Enter \".help\" for usage hints.\n", 4671 sqlite3_libversion(), sqlite3_sourceid() 4672 ); 4673 if( warnInmemoryDb ){ 4674 printf("Connected to a "); 4675 printBold("transient in-memory database"); 4676 printf(".\nUse \".open FILENAME\" to reopen on a " 4677 "persistent database.\n"); 4678 } 4679 zHome = find_home_dir(); 4680 if( zHome ){ 4681 nHistory = strlen30(zHome) + 20; 4682 if( (zHistory = malloc(nHistory))!=0 ){ 4683 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome); 4684 } 4685 } 4686 if( zHistory ) shell_read_history(zHistory); 4687 rc = process_input(&data, 0); 4688 if( zHistory ){ 4689 shell_stifle_history(100); 4690 shell_write_history(zHistory); 4691 free(zHistory); 4692 } 4693 }else{ 4694 rc = process_input(&data, stdin); 4695 } 4696 } 4697 set_table_name(&data, 0); 4698 if( data.db ){ 4699 sqlite3_close(data.db); 4700 } 4701 sqlite3_free(data.zFreeOnClose); 4702 return rc; 4703 } 4704