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