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