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