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