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** Determine if we are dealing with WinRT, which provides only a subset of 22** the full Win32 API. 23*/ 24#if !defined(SQLITE_OS_WINRT) 25# define SQLITE_OS_WINRT 0 26#endif 27 28/* 29** Warning pragmas copied from msvc.h in the core. 30*/ 31#if defined(_MSC_VER) 32#pragma warning(disable : 4054) 33#pragma warning(disable : 4055) 34#pragma warning(disable : 4100) 35#pragma warning(disable : 4127) 36#pragma warning(disable : 4130) 37#pragma warning(disable : 4152) 38#pragma warning(disable : 4189) 39#pragma warning(disable : 4206) 40#pragma warning(disable : 4210) 41#pragma warning(disable : 4232) 42#pragma warning(disable : 4244) 43#pragma warning(disable : 4305) 44#pragma warning(disable : 4306) 45#pragma warning(disable : 4702) 46#pragma warning(disable : 4706) 47#endif /* defined(_MSC_VER) */ 48 49/* 50** No support for loadable extensions in VxWorks. 51*/ 52#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION 53# define SQLITE_OMIT_LOAD_EXTENSION 1 54#endif 55 56/* 57** Enable large-file support for fopen() and friends on unix. 58*/ 59#ifndef SQLITE_DISABLE_LFS 60# define _LARGE_FILE 1 61# ifndef _FILE_OFFSET_BITS 62# define _FILE_OFFSET_BITS 64 63# endif 64# define _LARGEFILE_SOURCE 1 65#endif 66 67#include <stdlib.h> 68#include <string.h> 69#include <stdio.h> 70#include <assert.h> 71#include "sqlite3.h" 72typedef sqlite3_int64 i64; 73typedef sqlite3_uint64 u64; 74typedef unsigned char u8; 75#if SQLITE_USER_AUTHENTICATION 76# include "sqlite3userauth.h" 77#endif 78#include <ctype.h> 79#include <stdarg.h> 80 81#if !defined(_WIN32) && !defined(WIN32) 82# include <signal.h> 83# if !defined(__RTP__) && !defined(_WRS_KERNEL) 84# include <pwd.h> 85# endif 86#endif 87#if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__) 88# include <unistd.h> 89# include <dirent.h> 90# define GETPID getpid 91# if defined(__MINGW32__) 92# define DIRENT dirent 93# ifndef S_ISLNK 94# define S_ISLNK(mode) (0) 95# endif 96# endif 97#else 98# define GETPID (int)GetCurrentProcessId 99#endif 100#include <sys/types.h> 101#include <sys/stat.h> 102 103#if HAVE_READLINE 104# include <readline/readline.h> 105# include <readline/history.h> 106#endif 107 108#if HAVE_EDITLINE 109# include <editline/readline.h> 110#endif 111 112#if HAVE_EDITLINE || HAVE_READLINE 113 114# define shell_add_history(X) add_history(X) 115# define shell_read_history(X) read_history(X) 116# define shell_write_history(X) write_history(X) 117# define shell_stifle_history(X) stifle_history(X) 118# define shell_readline(X) readline(X) 119 120#elif HAVE_LINENOISE 121 122# include "linenoise.h" 123# define shell_add_history(X) linenoiseHistoryAdd(X) 124# define shell_read_history(X) linenoiseHistoryLoad(X) 125# define shell_write_history(X) linenoiseHistorySave(X) 126# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X) 127# define shell_readline(X) linenoise(X) 128 129#else 130 131# define shell_read_history(X) 132# define shell_write_history(X) 133# define shell_stifle_history(X) 134 135# define SHELL_USE_LOCAL_GETLINE 1 136#endif 137 138 139#if defined(_WIN32) || defined(WIN32) 140# if SQLITE_OS_WINRT 141# define SQLITE_OMIT_POPEN 1 142# else 143# include <io.h> 144# include <fcntl.h> 145# define isatty(h) _isatty(h) 146# ifndef access 147# define access(f,m) _access((f),(m)) 148# endif 149# ifndef unlink 150# define unlink _unlink 151# endif 152# ifndef strdup 153# define strdup _strdup 154# endif 155# undef popen 156# define popen _popen 157# undef pclose 158# define pclose _pclose 159# endif 160#else 161 /* Make sure isatty() has a prototype. */ 162 extern int isatty(int); 163 164# if !defined(__RTP__) && !defined(_WRS_KERNEL) 165 /* popen and pclose are not C89 functions and so are 166 ** sometimes omitted from the <stdio.h> header */ 167 extern FILE *popen(const char*,const char*); 168 extern int pclose(FILE*); 169# else 170# define SQLITE_OMIT_POPEN 1 171# endif 172#endif 173 174#if defined(_WIN32_WCE) 175/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() 176 * thus we always assume that we have a console. That can be 177 * overridden with the -batch command line option. 178 */ 179#define isatty(x) 1 180#endif 181 182/* ctype macros that work with signed characters */ 183#define IsSpace(X) isspace((unsigned char)X) 184#define IsDigit(X) isdigit((unsigned char)X) 185#define ToLower(X) (char)tolower((unsigned char)X) 186 187#if defined(_WIN32) || defined(WIN32) 188#if SQLITE_OS_WINRT 189#include <intrin.h> 190#endif 191#include <windows.h> 192 193/* string conversion routines only needed on Win32 */ 194extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR); 195extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int); 196extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int); 197extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText); 198#endif 199 200/* On Windows, we normally run with output mode of TEXT so that \n characters 201** are automatically translated into \r\n. However, this behavior needs 202** to be disabled in some cases (ex: when generating CSV output and when 203** rendering quoted strings that contain \n characters). The following 204** routines take care of that. 205*/ 206#if (defined(_WIN32) || defined(WIN32)) && !SQLITE_OS_WINRT 207static void setBinaryMode(FILE *file, int isOutput){ 208 if( isOutput ) fflush(file); 209 _setmode(_fileno(file), _O_BINARY); 210} 211static void setTextMode(FILE *file, int isOutput){ 212 if( isOutput ) fflush(file); 213 _setmode(_fileno(file), _O_TEXT); 214} 215#else 216# define setBinaryMode(X,Y) 217# define setTextMode(X,Y) 218#endif 219 220 221/* True if the timer is enabled */ 222static int enableTimer = 0; 223 224/* Return the current wall-clock time */ 225static sqlite3_int64 timeOfDay(void){ 226 static sqlite3_vfs *clockVfs = 0; 227 sqlite3_int64 t; 228 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0); 229 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){ 230 clockVfs->xCurrentTimeInt64(clockVfs, &t); 231 }else{ 232 double r; 233 clockVfs->xCurrentTime(clockVfs, &r); 234 t = (sqlite3_int64)(r*86400000.0); 235 } 236 return t; 237} 238 239#if !defined(_WIN32) && !defined(WIN32) && !defined(__minux) 240#include <sys/time.h> 241#include <sys/resource.h> 242 243/* VxWorks does not support getrusage() as far as we can determine */ 244#if defined(_WRS_KERNEL) || defined(__RTP__) 245struct rusage { 246 struct timeval ru_utime; /* user CPU time used */ 247 struct timeval ru_stime; /* system CPU time used */ 248}; 249#define getrusage(A,B) memset(B,0,sizeof(*B)) 250#endif 251 252/* Saved resource information for the beginning of an operation */ 253static struct rusage sBegin; /* CPU time at start */ 254static sqlite3_int64 iBegin; /* Wall-clock time at start */ 255 256/* 257** Begin timing an operation 258*/ 259static void beginTimer(void){ 260 if( enableTimer ){ 261 getrusage(RUSAGE_SELF, &sBegin); 262 iBegin = timeOfDay(); 263 } 264} 265 266/* Return the difference of two time_structs in seconds */ 267static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ 268 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + 269 (double)(pEnd->tv_sec - pStart->tv_sec); 270} 271 272/* 273** Print the timing results. 274*/ 275static void endTimer(void){ 276 if( enableTimer ){ 277 sqlite3_int64 iEnd = timeOfDay(); 278 struct rusage sEnd; 279 getrusage(RUSAGE_SELF, &sEnd); 280 printf("Run Time: real %.3f user %f sys %f\n", 281 (iEnd - iBegin)*0.001, 282 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), 283 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); 284 } 285} 286 287#define BEGIN_TIMER beginTimer() 288#define END_TIMER endTimer() 289#define HAS_TIMER 1 290 291#elif (defined(_WIN32) || defined(WIN32)) 292 293/* Saved resource information for the beginning of an operation */ 294static HANDLE hProcess; 295static FILETIME ftKernelBegin; 296static FILETIME ftUserBegin; 297static sqlite3_int64 ftWallBegin; 298typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, 299 LPFILETIME, LPFILETIME); 300static GETPROCTIMES getProcessTimesAddr = NULL; 301 302/* 303** Check to see if we have timer support. Return 1 if necessary 304** support found (or found previously). 305*/ 306static int hasTimer(void){ 307 if( getProcessTimesAddr ){ 308 return 1; 309 } else { 310#if !SQLITE_OS_WINRT 311 /* GetProcessTimes() isn't supported in WIN95 and some other Windows 312 ** versions. See if the version we are running on has it, and if it 313 ** does, save off a pointer to it and the current process handle. 314 */ 315 hProcess = GetCurrentProcess(); 316 if( hProcess ){ 317 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); 318 if( NULL != hinstLib ){ 319 getProcessTimesAddr = 320 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); 321 if( NULL != getProcessTimesAddr ){ 322 return 1; 323 } 324 FreeLibrary(hinstLib); 325 } 326 } 327#endif 328 } 329 return 0; 330} 331 332/* 333** Begin timing an operation 334*/ 335static void beginTimer(void){ 336 if( enableTimer && getProcessTimesAddr ){ 337 FILETIME ftCreation, ftExit; 338 getProcessTimesAddr(hProcess,&ftCreation,&ftExit, 339 &ftKernelBegin,&ftUserBegin); 340 ftWallBegin = timeOfDay(); 341 } 342} 343 344/* Return the difference of two FILETIME structs in seconds */ 345static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ 346 sqlite_int64 i64Start = *((sqlite_int64 *) pStart); 347 sqlite_int64 i64End = *((sqlite_int64 *) pEnd); 348 return (double) ((i64End - i64Start) / 10000000.0); 349} 350 351/* 352** Print the timing results. 353*/ 354static void endTimer(void){ 355 if( enableTimer && getProcessTimesAddr){ 356 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; 357 sqlite3_int64 ftWallEnd = timeOfDay(); 358 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd); 359 printf("Run Time: real %.3f user %f sys %f\n", 360 (ftWallEnd - ftWallBegin)*0.001, 361 timeDiff(&ftUserBegin, &ftUserEnd), 362 timeDiff(&ftKernelBegin, &ftKernelEnd)); 363 } 364} 365 366#define BEGIN_TIMER beginTimer() 367#define END_TIMER endTimer() 368#define HAS_TIMER hasTimer() 369 370#else 371#define BEGIN_TIMER 372#define END_TIMER 373#define HAS_TIMER 0 374#endif 375 376/* 377** Used to prevent warnings about unused parameters 378*/ 379#define UNUSED_PARAMETER(x) (void)(x) 380 381/* 382** Number of elements in an array 383*/ 384#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) 385 386/* 387** If the following flag is set, then command execution stops 388** at an error if we are not interactive. 389*/ 390static int bail_on_error = 0; 391 392/* 393** Threat stdin as an interactive input if the following variable 394** is true. Otherwise, assume stdin is connected to a file or pipe. 395*/ 396static int stdin_is_interactive = 1; 397 398/* 399** On Windows systems we have to know if standard output is a console 400** in order to translate UTF-8 into MBCS. The following variable is 401** true if translation is required. 402*/ 403static int stdout_is_console = 1; 404 405/* 406** The following is the open SQLite database. We make a pointer 407** to this database a static variable so that it can be accessed 408** by the SIGINT handler to interrupt database processing. 409*/ 410static sqlite3 *globalDb = 0; 411 412/* 413** True if an interrupt (Control-C) has been received. 414*/ 415static volatile int seenInterrupt = 0; 416 417#ifdef SQLITE_DEBUG 418/* 419** Out-of-memory simulator variables 420*/ 421static unsigned int oomCounter = 0; /* Simulate OOM when equals 1 */ 422static unsigned int oomRepeat = 0; /* Number of OOMs in a row */ 423static void*(*defaultMalloc)(int) = 0; /* The low-level malloc routine */ 424#endif /* SQLITE_DEBUG */ 425 426/* 427** This is the name of our program. It is set in main(), used 428** in a number of other places, mostly for error messages. 429*/ 430static char *Argv0; 431 432/* 433** Prompt strings. Initialized in main. Settable with 434** .prompt main continue 435*/ 436static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ 437static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ 438 439/* 440** Render output like fprintf(). Except, if the output is going to the 441** console and if this is running on a Windows machine, translate the 442** output from UTF-8 into MBCS. 443*/ 444#if defined(_WIN32) || defined(WIN32) 445void utf8_printf(FILE *out, const char *zFormat, ...){ 446 va_list ap; 447 va_start(ap, zFormat); 448 if( stdout_is_console && (out==stdout || out==stderr) ){ 449 char *z1 = sqlite3_vmprintf(zFormat, ap); 450 char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0); 451 sqlite3_free(z1); 452 fputs(z2, out); 453 sqlite3_free(z2); 454 }else{ 455 vfprintf(out, zFormat, ap); 456 } 457 va_end(ap); 458} 459#elif !defined(utf8_printf) 460# define utf8_printf fprintf 461#endif 462 463/* 464** Render output like fprintf(). This should not be used on anything that 465** includes string formatting (e.g. "%s"). 466*/ 467#if !defined(raw_printf) 468# define raw_printf fprintf 469#endif 470 471/* Indicate out-of-memory and exit. */ 472static void shell_out_of_memory(void){ 473 raw_printf(stderr,"Error: out of memory\n"); 474 exit(1); 475} 476 477#ifdef SQLITE_DEBUG 478/* This routine is called when a simulated OOM occurs. It is broken 479** out as a separate routine to make it easy to set a breakpoint on 480** the OOM 481*/ 482void shellOomFault(void){ 483 if( oomRepeat>0 ){ 484 oomRepeat--; 485 }else{ 486 oomCounter--; 487 } 488} 489#endif /* SQLITE_DEBUG */ 490 491#ifdef SQLITE_DEBUG 492/* This routine is a replacement malloc() that is used to simulate 493** Out-Of-Memory (OOM) errors for testing purposes. 494*/ 495static void *oomMalloc(int nByte){ 496 if( oomCounter ){ 497 if( oomCounter==1 ){ 498 shellOomFault(); 499 return 0; 500 }else{ 501 oomCounter--; 502 } 503 } 504 return defaultMalloc(nByte); 505} 506#endif /* SQLITE_DEBUG */ 507 508#ifdef SQLITE_DEBUG 509/* Register the OOM simulator. This must occur before any memory 510** allocations */ 511static void registerOomSimulator(void){ 512 sqlite3_mem_methods mem; 513 sqlite3_config(SQLITE_CONFIG_GETMALLOC, &mem); 514 defaultMalloc = mem.xMalloc; 515 mem.xMalloc = oomMalloc; 516 sqlite3_config(SQLITE_CONFIG_MALLOC, &mem); 517} 518#endif 519 520/* 521** Write I/O traces to the following stream. 522*/ 523#ifdef SQLITE_ENABLE_IOTRACE 524static FILE *iotrace = 0; 525#endif 526 527/* 528** This routine works like printf in that its first argument is a 529** format string and subsequent arguments are values to be substituted 530** in place of % fields. The result of formatting this string 531** is written to iotrace. 532*/ 533#ifdef SQLITE_ENABLE_IOTRACE 534static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){ 535 va_list ap; 536 char *z; 537 if( iotrace==0 ) return; 538 va_start(ap, zFormat); 539 z = sqlite3_vmprintf(zFormat, ap); 540 va_end(ap); 541 utf8_printf(iotrace, "%s", z); 542 sqlite3_free(z); 543} 544#endif 545 546/* 547** Output string zUtf to stream pOut as w characters. If w is negative, 548** then right-justify the text. W is the width in UTF-8 characters, not 549** in bytes. This is different from the %*.*s specification in printf 550** since with %*.*s the width is measured in bytes, not characters. 551*/ 552static void utf8_width_print(FILE *pOut, int w, const char *zUtf){ 553 int i; 554 int n; 555 int aw = w<0 ? -w : w; 556 for(i=n=0; zUtf[i]; i++){ 557 if( (zUtf[i]&0xc0)!=0x80 ){ 558 n++; 559 if( n==aw ){ 560 do{ i++; }while( (zUtf[i]&0xc0)==0x80 ); 561 break; 562 } 563 } 564 } 565 if( n>=aw ){ 566 utf8_printf(pOut, "%.*s", i, zUtf); 567 }else if( w<0 ){ 568 utf8_printf(pOut, "%*s%s", aw-n, "", zUtf); 569 }else{ 570 utf8_printf(pOut, "%s%*s", zUtf, aw-n, ""); 571 } 572} 573 574 575/* 576** Determines if a string is a number of not. 577*/ 578static int isNumber(const char *z, int *realnum){ 579 if( *z=='-' || *z=='+' ) z++; 580 if( !IsDigit(*z) ){ 581 return 0; 582 } 583 z++; 584 if( realnum ) *realnum = 0; 585 while( IsDigit(*z) ){ z++; } 586 if( *z=='.' ){ 587 z++; 588 if( !IsDigit(*z) ) return 0; 589 while( IsDigit(*z) ){ z++; } 590 if( realnum ) *realnum = 1; 591 } 592 if( *z=='e' || *z=='E' ){ 593 z++; 594 if( *z=='+' || *z=='-' ) z++; 595 if( !IsDigit(*z) ) return 0; 596 while( IsDigit(*z) ){ z++; } 597 if( realnum ) *realnum = 1; 598 } 599 return *z==0; 600} 601 602/* 603** Compute a string length that is limited to what can be stored in 604** lower 30 bits of a 32-bit signed integer. 605*/ 606static int strlen30(const char *z){ 607 const char *z2 = z; 608 while( *z2 ){ z2++; } 609 return 0x3fffffff & (int)(z2 - z); 610} 611 612/* 613** Return the length of a string in characters. Multibyte UTF8 characters 614** count as a single character. 615*/ 616static int strlenChar(const char *z){ 617 int n = 0; 618 while( *z ){ 619 if( (0xc0&*(z++))!=0x80 ) n++; 620 } 621 return n; 622} 623 624/* 625** Return true if zFile does not exist or if it is not an ordinary file. 626*/ 627#ifdef _WIN32 628# define notNormalFile(X) 0 629#else 630static int notNormalFile(const char *zFile){ 631 struct stat x; 632 int rc; 633 memset(&x, 0, sizeof(x)); 634 rc = stat(zFile, &x); 635 return rc || !S_ISREG(x.st_mode); 636} 637#endif 638 639/* 640** This routine reads a line of text from FILE in, stores 641** the text in memory obtained from malloc() and returns a pointer 642** to the text. NULL is returned at end of file, or if malloc() 643** fails. 644** 645** If zLine is not NULL then it is a malloced buffer returned from 646** a previous call to this routine that may be reused. 647*/ 648static char *local_getline(char *zLine, FILE *in){ 649 int nLine = zLine==0 ? 0 : 100; 650 int n = 0; 651 652 while( 1 ){ 653 if( n+100>nLine ){ 654 nLine = nLine*2 + 100; 655 zLine = realloc(zLine, nLine); 656 if( zLine==0 ) shell_out_of_memory(); 657 } 658 if( fgets(&zLine[n], nLine - n, in)==0 ){ 659 if( n==0 ){ 660 free(zLine); 661 return 0; 662 } 663 zLine[n] = 0; 664 break; 665 } 666 while( zLine[n] ) n++; 667 if( n>0 && zLine[n-1]=='\n' ){ 668 n--; 669 if( n>0 && zLine[n-1]=='\r' ) n--; 670 zLine[n] = 0; 671 break; 672 } 673 } 674#if defined(_WIN32) || defined(WIN32) 675 /* For interactive input on Windows systems, translate the 676 ** multi-byte characterset characters into UTF-8. */ 677 if( stdin_is_interactive && in==stdin ){ 678 char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0); 679 if( zTrans ){ 680 int nTrans = strlen30(zTrans)+1; 681 if( nTrans>nLine ){ 682 zLine = realloc(zLine, nTrans); 683 if( zLine==0 ) shell_out_of_memory(); 684 } 685 memcpy(zLine, zTrans, nTrans); 686 sqlite3_free(zTrans); 687 } 688 } 689#endif /* defined(_WIN32) || defined(WIN32) */ 690 return zLine; 691} 692 693/* 694** Retrieve a single line of input text. 695** 696** If in==0 then read from standard input and prompt before each line. 697** If isContinuation is true, then a continuation prompt is appropriate. 698** If isContinuation is zero, then the main prompt should be used. 699** 700** If zPrior is not NULL then it is a buffer from a prior call to this 701** routine that can be reused. 702** 703** The result is stored in space obtained from malloc() and must either 704** be freed by the caller or else passed back into this routine via the 705** zPrior argument for reuse. 706*/ 707static char *one_input_line(FILE *in, char *zPrior, int isContinuation){ 708 char *zPrompt; 709 char *zResult; 710 if( in!=0 ){ 711 zResult = local_getline(zPrior, in); 712 }else{ 713 zPrompt = isContinuation ? continuePrompt : mainPrompt; 714#if SHELL_USE_LOCAL_GETLINE 715 printf("%s", zPrompt); 716 fflush(stdout); 717 zResult = local_getline(zPrior, stdin); 718#else 719 free(zPrior); 720 zResult = shell_readline(zPrompt); 721 if( zResult && *zResult ) shell_add_history(zResult); 722#endif 723 } 724 return zResult; 725} 726 727 728/* 729** Return the value of a hexadecimal digit. Return -1 if the input 730** is not a hex digit. 731*/ 732static int hexDigitValue(char c){ 733 if( c>='0' && c<='9' ) return c - '0'; 734 if( c>='a' && c<='f' ) return c - 'a' + 10; 735 if( c>='A' && c<='F' ) return c - 'A' + 10; 736 return -1; 737} 738 739/* 740** Interpret zArg as an integer value, possibly with suffixes. 741*/ 742static sqlite3_int64 integerValue(const char *zArg){ 743 sqlite3_int64 v = 0; 744 static const struct { char *zSuffix; int iMult; } aMult[] = { 745 { "KiB", 1024 }, 746 { "MiB", 1024*1024 }, 747 { "GiB", 1024*1024*1024 }, 748 { "KB", 1000 }, 749 { "MB", 1000000 }, 750 { "GB", 1000000000 }, 751 { "K", 1000 }, 752 { "M", 1000000 }, 753 { "G", 1000000000 }, 754 }; 755 int i; 756 int isNeg = 0; 757 if( zArg[0]=='-' ){ 758 isNeg = 1; 759 zArg++; 760 }else if( zArg[0]=='+' ){ 761 zArg++; 762 } 763 if( zArg[0]=='0' && zArg[1]=='x' ){ 764 int x; 765 zArg += 2; 766 while( (x = hexDigitValue(zArg[0]))>=0 ){ 767 v = (v<<4) + x; 768 zArg++; 769 } 770 }else{ 771 while( IsDigit(zArg[0]) ){ 772 v = v*10 + zArg[0] - '0'; 773 zArg++; 774 } 775 } 776 for(i=0; i<ArraySize(aMult); i++){ 777 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){ 778 v *= aMult[i].iMult; 779 break; 780 } 781 } 782 return isNeg? -v : v; 783} 784 785/* 786** A variable length string to which one can append text. 787*/ 788typedef struct ShellText ShellText; 789struct ShellText { 790 char *z; 791 int n; 792 int nAlloc; 793}; 794 795/* 796** Initialize and destroy a ShellText object 797*/ 798static void initText(ShellText *p){ 799 memset(p, 0, sizeof(*p)); 800} 801static void freeText(ShellText *p){ 802 free(p->z); 803 initText(p); 804} 805 806/* zIn is either a pointer to a NULL-terminated string in memory obtained 807** from malloc(), or a NULL pointer. The string pointed to by zAppend is 808** added to zIn, and the result returned in memory obtained from malloc(). 809** zIn, if it was not NULL, is freed. 810** 811** If the third argument, quote, is not '\0', then it is used as a 812** quote character for zAppend. 813*/ 814static void appendText(ShellText *p, char const *zAppend, char quote){ 815 int len; 816 int i; 817 int nAppend = strlen30(zAppend); 818 819 len = nAppend+p->n+1; 820 if( quote ){ 821 len += 2; 822 for(i=0; i<nAppend; i++){ 823 if( zAppend[i]==quote ) len++; 824 } 825 } 826 827 if( p->n+len>=p->nAlloc ){ 828 p->nAlloc = p->nAlloc*2 + len + 20; 829 p->z = realloc(p->z, p->nAlloc); 830 if( p->z==0 ) shell_out_of_memory(); 831 } 832 833 if( quote ){ 834 char *zCsr = p->z+p->n; 835 *zCsr++ = quote; 836 for(i=0; i<nAppend; i++){ 837 *zCsr++ = zAppend[i]; 838 if( zAppend[i]==quote ) *zCsr++ = quote; 839 } 840 *zCsr++ = quote; 841 p->n = (int)(zCsr - p->z); 842 *zCsr = '\0'; 843 }else{ 844 memcpy(p->z+p->n, zAppend, nAppend); 845 p->n += nAppend; 846 p->z[p->n] = '\0'; 847 } 848} 849 850/* 851** Attempt to determine if identifier zName needs to be quoted, either 852** because it contains non-alphanumeric characters, or because it is an 853** SQLite keyword. Be conservative in this estimate: When in doubt assume 854** that quoting is required. 855** 856** Return '"' if quoting is required. Return 0 if no quoting is required. 857*/ 858static char quoteChar(const char *zName){ 859 int i; 860 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"'; 861 for(i=0; zName[i]; i++){ 862 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"'; 863 } 864 return sqlite3_keyword_check(zName, i) ? '"' : 0; 865} 866 867/* 868** Construct a fake object name and column list to describe the structure 869** of the view, virtual table, or table valued function zSchema.zName. 870*/ 871static char *shellFakeSchema( 872 sqlite3 *db, /* The database connection containing the vtab */ 873 const char *zSchema, /* Schema of the database holding the vtab */ 874 const char *zName /* The name of the virtual table */ 875){ 876 sqlite3_stmt *pStmt = 0; 877 char *zSql; 878 ShellText s; 879 char cQuote; 880 char *zDiv = "("; 881 int nRow = 0; 882 883 zSql = sqlite3_mprintf("PRAGMA \"%w\".table_info=%Q;", 884 zSchema ? zSchema : "main", zName); 885 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 886 sqlite3_free(zSql); 887 initText(&s); 888 if( zSchema ){ 889 cQuote = quoteChar(zSchema); 890 if( cQuote && sqlite3_stricmp(zSchema,"temp")==0 ) cQuote = 0; 891 appendText(&s, zSchema, cQuote); 892 appendText(&s, ".", 0); 893 } 894 cQuote = quoteChar(zName); 895 appendText(&s, zName, cQuote); 896 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 897 const char *zCol = (const char*)sqlite3_column_text(pStmt, 1); 898 nRow++; 899 appendText(&s, zDiv, 0); 900 zDiv = ","; 901 cQuote = quoteChar(zCol); 902 appendText(&s, zCol, cQuote); 903 } 904 appendText(&s, ")", 0); 905 sqlite3_finalize(pStmt); 906 if( nRow==0 ){ 907 freeText(&s); 908 s.z = 0; 909 } 910 return s.z; 911} 912 913/* 914** SQL function: shell_module_schema(X) 915** 916** Return a fake schema for the table-valued function or eponymous virtual 917** table X. 918*/ 919static void shellModuleSchema( 920 sqlite3_context *pCtx, 921 int nVal, 922 sqlite3_value **apVal 923){ 924 const char *zName = (const char*)sqlite3_value_text(apVal[0]); 925 char *zFake = shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName); 926 UNUSED_PARAMETER(nVal); 927 if( zFake ){ 928 sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake), 929 -1, sqlite3_free); 930 free(zFake); 931 } 932} 933 934/* 935** SQL function: shell_add_schema(S,X) 936** 937** Add the schema name X to the CREATE statement in S and return the result. 938** Examples: 939** 940** CREATE TABLE t1(x) -> CREATE TABLE xyz.t1(x); 941** 942** Also works on 943** 944** CREATE INDEX 945** CREATE UNIQUE INDEX 946** CREATE VIEW 947** CREATE TRIGGER 948** CREATE VIRTUAL TABLE 949** 950** This UDF is used by the .schema command to insert the schema name of 951** attached databases into the middle of the sqlite_schema.sql field. 952*/ 953static void shellAddSchemaName( 954 sqlite3_context *pCtx, 955 int nVal, 956 sqlite3_value **apVal 957){ 958 static const char *aPrefix[] = { 959 "TABLE", 960 "INDEX", 961 "UNIQUE INDEX", 962 "VIEW", 963 "TRIGGER", 964 "VIRTUAL TABLE" 965 }; 966 int i = 0; 967 const char *zIn = (const char*)sqlite3_value_text(apVal[0]); 968 const char *zSchema = (const char*)sqlite3_value_text(apVal[1]); 969 const char *zName = (const char*)sqlite3_value_text(apVal[2]); 970 sqlite3 *db = sqlite3_context_db_handle(pCtx); 971 UNUSED_PARAMETER(nVal); 972 if( zIn!=0 && strncmp(zIn, "CREATE ", 7)==0 ){ 973 for(i=0; i<(int)(sizeof(aPrefix)/sizeof(aPrefix[0])); i++){ 974 int n = strlen30(aPrefix[i]); 975 if( strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){ 976 char *z = 0; 977 char *zFake = 0; 978 if( zSchema ){ 979 char cQuote = quoteChar(zSchema); 980 if( cQuote && sqlite3_stricmp(zSchema,"temp")!=0 ){ 981 z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8); 982 }else{ 983 z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8); 984 } 985 } 986 if( zName 987 && aPrefix[i][0]=='V' 988 && (zFake = shellFakeSchema(db, zSchema, zName))!=0 989 ){ 990 if( z==0 ){ 991 z = sqlite3_mprintf("%s\n/* %s */", zIn, zFake); 992 }else{ 993 z = sqlite3_mprintf("%z\n/* %s */", z, zFake); 994 } 995 free(zFake); 996 } 997 if( z ){ 998 sqlite3_result_text(pCtx, z, -1, sqlite3_free); 999 return; 1000 } 1001 } 1002 } 1003 } 1004 sqlite3_result_value(pCtx, apVal[0]); 1005} 1006 1007/* 1008** The source code for several run-time loadable extensions is inserted 1009** below by the ../tool/mkshellc.tcl script. Before processing that included 1010** code, we need to override some macros to make the included program code 1011** work here in the middle of this regular program. 1012*/ 1013#define SQLITE_EXTENSION_INIT1 1014#define SQLITE_EXTENSION_INIT2(X) (void)(X) 1015 1016#if defined(_WIN32) && defined(_MSC_VER) 1017INCLUDE test_windirent.h 1018INCLUDE test_windirent.c 1019#define dirent DIRENT 1020#endif 1021INCLUDE ../ext/misc/shathree.c 1022INCLUDE ../ext/misc/fileio.c 1023INCLUDE ../ext/misc/completion.c 1024INCLUDE ../ext/misc/appendvfs.c 1025INCLUDE ../ext/misc/memtrace.c 1026INCLUDE ../ext/misc/uint.c 1027INCLUDE ../ext/misc/decimal.c 1028INCLUDE ../ext/misc/ieee754.c 1029INCLUDE ../ext/misc/series.c 1030#ifdef SQLITE_HAVE_ZLIB 1031INCLUDE ../ext/misc/zipfile.c 1032INCLUDE ../ext/misc/sqlar.c 1033#endif 1034INCLUDE ../ext/expert/sqlite3expert.h 1035INCLUDE ../ext/expert/sqlite3expert.c 1036 1037#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 1038INCLUDE ../ext/misc/dbdata.c 1039#endif 1040 1041#if defined(SQLITE_ENABLE_SESSION) 1042/* 1043** State information for a single open session 1044*/ 1045typedef struct OpenSession OpenSession; 1046struct OpenSession { 1047 char *zName; /* Symbolic name for this session */ 1048 int nFilter; /* Number of xFilter rejection GLOB patterns */ 1049 char **azFilter; /* Array of xFilter rejection GLOB patterns */ 1050 sqlite3_session *p; /* The open session */ 1051}; 1052#endif 1053 1054typedef struct ExpertInfo ExpertInfo; 1055struct ExpertInfo { 1056 sqlite3expert *pExpert; 1057 int bVerbose; 1058}; 1059 1060/* A single line in the EQP output */ 1061typedef struct EQPGraphRow EQPGraphRow; 1062struct EQPGraphRow { 1063 int iEqpId; /* ID for this row */ 1064 int iParentId; /* ID of the parent row */ 1065 EQPGraphRow *pNext; /* Next row in sequence */ 1066 char zText[1]; /* Text to display for this row */ 1067}; 1068 1069/* All EQP output is collected into an instance of the following */ 1070typedef struct EQPGraph EQPGraph; 1071struct EQPGraph { 1072 EQPGraphRow *pRow; /* Linked list of all rows of the EQP output */ 1073 EQPGraphRow *pLast; /* Last element of the pRow list */ 1074 char zPrefix[100]; /* Graph prefix */ 1075}; 1076 1077/* 1078** State information about the database connection is contained in an 1079** instance of the following structure. 1080*/ 1081typedef struct ShellState ShellState; 1082struct ShellState { 1083 sqlite3 *db; /* The database */ 1084 u8 autoExplain; /* Automatically turn on .explain mode */ 1085 u8 autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */ 1086 u8 autoEQPtest; /* autoEQP is in test mode */ 1087 u8 autoEQPtrace; /* autoEQP is in trace mode */ 1088 u8 statsOn; /* True to display memory stats before each finalize */ 1089 u8 scanstatsOn; /* True to display scan stats before each finalize */ 1090 u8 openMode; /* SHELL_OPEN_NORMAL, _APPENDVFS, or _ZIPFILE */ 1091 u8 doXdgOpen; /* Invoke start/open/xdg-open in output_reset() */ 1092 u8 nEqpLevel; /* Depth of the EQP output graph */ 1093 u8 eTraceType; /* SHELL_TRACE_* value for type of trace */ 1094 unsigned mEqpLines; /* Mask of veritical lines in the EQP output graph */ 1095 int outCount; /* Revert to stdout when reaching zero */ 1096 int cnt; /* Number of records displayed so far */ 1097 int lineno; /* Line number of last line read from in */ 1098 int openFlags; /* Additional flags to open. (SQLITE_OPEN_NOFOLLOW) */ 1099 FILE *in; /* Read commands from this stream */ 1100 FILE *out; /* Write results here */ 1101 FILE *traceOut; /* Output for sqlite3_trace() */ 1102 int nErr; /* Number of errors seen */ 1103 int mode; /* An output mode setting */ 1104 int modePrior; /* Saved mode */ 1105 int cMode; /* temporary output mode for the current query */ 1106 int normalMode; /* Output mode before ".explain on" */ 1107 int writableSchema; /* True if PRAGMA writable_schema=ON */ 1108 int showHeader; /* True to show column names in List or Column mode */ 1109 int nCheck; /* Number of ".check" commands run */ 1110 unsigned nProgress; /* Number of progress callbacks encountered */ 1111 unsigned mxProgress; /* Maximum progress callbacks before failing */ 1112 unsigned flgProgress; /* Flags for the progress callback */ 1113 unsigned shellFlgs; /* Various flags */ 1114 unsigned priorShFlgs; /* Saved copy of flags */ 1115 sqlite3_int64 szMax; /* --maxsize argument to .open */ 1116 char *zDestTable; /* Name of destination table when MODE_Insert */ 1117 char *zTempFile; /* Temporary file that might need deleting */ 1118 char zTestcase[30]; /* Name of current test case */ 1119 char colSeparator[20]; /* Column separator character for several modes */ 1120 char rowSeparator[20]; /* Row separator character for MODE_Ascii */ 1121 char colSepPrior[20]; /* Saved column separator */ 1122 char rowSepPrior[20]; /* Saved row separator */ 1123 int *colWidth; /* Requested width of each column in columnar modes */ 1124 int *actualWidth; /* Actual width of each column */ 1125 int nWidth; /* Number of slots in colWidth[] and actualWidth[] */ 1126 char nullValue[20]; /* The text to print when a NULL comes back from 1127 ** the database */ 1128 char outfile[FILENAME_MAX]; /* Filename for *out */ 1129 const char *zDbFilename; /* name of the database file */ 1130 char *zFreeOnClose; /* Filename to free when closing */ 1131 const char *zVfs; /* Name of VFS to use */ 1132 sqlite3_stmt *pStmt; /* Current statement if any. */ 1133 FILE *pLog; /* Write log output here */ 1134 int *aiIndent; /* Array of indents used in MODE_Explain */ 1135 int nIndent; /* Size of array aiIndent[] */ 1136 int iIndent; /* Index of current op in aiIndent[] */ 1137 EQPGraph sGraph; /* Information for the graphical EXPLAIN QUERY PLAN */ 1138#if defined(SQLITE_ENABLE_SESSION) 1139 int nSession; /* Number of active sessions */ 1140 OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */ 1141#endif 1142 ExpertInfo expert; /* Valid if previous command was ".expert OPT..." */ 1143}; 1144 1145 1146/* Allowed values for ShellState.autoEQP 1147*/ 1148#define AUTOEQP_off 0 /* Automatic EXPLAIN QUERY PLAN is off */ 1149#define AUTOEQP_on 1 /* Automatic EQP is on */ 1150#define AUTOEQP_trigger 2 /* On and also show plans for triggers */ 1151#define AUTOEQP_full 3 /* Show full EXPLAIN */ 1152 1153/* Allowed values for ShellState.openMode 1154*/ 1155#define SHELL_OPEN_UNSPEC 0 /* No open-mode specified */ 1156#define SHELL_OPEN_NORMAL 1 /* Normal database file */ 1157#define SHELL_OPEN_APPENDVFS 2 /* Use appendvfs */ 1158#define SHELL_OPEN_ZIPFILE 3 /* Use the zipfile virtual table */ 1159#define SHELL_OPEN_READONLY 4 /* Open a normal database read-only */ 1160#define SHELL_OPEN_DESERIALIZE 5 /* Open using sqlite3_deserialize() */ 1161#define SHELL_OPEN_HEXDB 6 /* Use "dbtotxt" output as data source */ 1162 1163/* Allowed values for ShellState.eTraceType 1164*/ 1165#define SHELL_TRACE_PLAIN 0 /* Show input SQL text */ 1166#define SHELL_TRACE_EXPANDED 1 /* Show expanded SQL text */ 1167#define SHELL_TRACE_NORMALIZED 2 /* Show normalized SQL text */ 1168 1169/* Bits in the ShellState.flgProgress variable */ 1170#define SHELL_PROGRESS_QUIET 0x01 /* Omit announcing every progress callback */ 1171#define SHELL_PROGRESS_RESET 0x02 /* Reset the count when the progres 1172 ** callback limit is reached, and for each 1173 ** top-level SQL statement */ 1174#define SHELL_PROGRESS_ONCE 0x04 /* Cancel the --limit after firing once */ 1175 1176/* 1177** These are the allowed shellFlgs values 1178*/ 1179#define SHFLG_Pagecache 0x00000001 /* The --pagecache option is used */ 1180#define SHFLG_Lookaside 0x00000002 /* Lookaside memory is used */ 1181#define SHFLG_Backslash 0x00000004 /* The --backslash option is used */ 1182#define SHFLG_PreserveRowid 0x00000008 /* .dump preserves rowid values */ 1183#define SHFLG_Newlines 0x00000010 /* .dump --newline flag */ 1184#define SHFLG_CountChanges 0x00000020 /* .changes setting */ 1185#define SHFLG_Echo 0x00000040 /* .echo or --echo setting */ 1186#define SHFLG_HeaderSet 0x00000080 /* .header has been used */ 1187#define SHFLG_DumpDataOnly 0x00000100 /* .dump show data only */ 1188#define SHFLG_DumpNoSys 0x00000200 /* .dump omits system tables */ 1189 1190/* 1191** Macros for testing and setting shellFlgs 1192*/ 1193#define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0) 1194#define ShellSetFlag(P,X) ((P)->shellFlgs|=(X)) 1195#define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X))) 1196 1197/* 1198** These are the allowed modes. 1199*/ 1200#define MODE_Line 0 /* One column per line. Blank line between records */ 1201#define MODE_Column 1 /* One record per line in neat columns */ 1202#define MODE_List 2 /* One record per line with a separator */ 1203#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ 1204#define MODE_Html 4 /* Generate an XHTML table */ 1205#define MODE_Insert 5 /* Generate SQL "insert" statements */ 1206#define MODE_Quote 6 /* Quote values as for SQL */ 1207#define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */ 1208#define MODE_Csv 8 /* Quote strings, numbers are plain */ 1209#define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */ 1210#define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */ 1211#define MODE_Pretty 11 /* Pretty-print schemas */ 1212#define MODE_EQP 12 /* Converts EXPLAIN QUERY PLAN output into a graph */ 1213#define MODE_Json 13 /* Output JSON */ 1214#define MODE_Markdown 14 /* Markdown formatting */ 1215#define MODE_Table 15 /* MySQL-style table formatting */ 1216#define MODE_Box 16 /* Unicode box-drawing characters */ 1217 1218static const char *modeDescr[] = { 1219 "line", 1220 "column", 1221 "list", 1222 "semi", 1223 "html", 1224 "insert", 1225 "quote", 1226 "tcl", 1227 "csv", 1228 "explain", 1229 "ascii", 1230 "prettyprint", 1231 "eqp", 1232 "json", 1233 "markdown", 1234 "table", 1235 "box" 1236}; 1237 1238/* 1239** These are the column/row/line separators used by the various 1240** import/export modes. 1241*/ 1242#define SEP_Column "|" 1243#define SEP_Row "\n" 1244#define SEP_Tab "\t" 1245#define SEP_Space " " 1246#define SEP_Comma "," 1247#define SEP_CrLf "\r\n" 1248#define SEP_Unit "\x1F" 1249#define SEP_Record "\x1E" 1250 1251/* 1252** A callback for the sqlite3_log() interface. 1253*/ 1254static void shellLog(void *pArg, int iErrCode, const char *zMsg){ 1255 ShellState *p = (ShellState*)pArg; 1256 if( p->pLog==0 ) return; 1257 utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg); 1258 fflush(p->pLog); 1259} 1260 1261/* 1262** SQL function: shell_putsnl(X) 1263** 1264** Write the text X to the screen (or whatever output is being directed) 1265** adding a newline at the end, and then return X. 1266*/ 1267static void shellPutsFunc( 1268 sqlite3_context *pCtx, 1269 int nVal, 1270 sqlite3_value **apVal 1271){ 1272 ShellState *p = (ShellState*)sqlite3_user_data(pCtx); 1273 (void)nVal; 1274 utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0])); 1275 sqlite3_result_value(pCtx, apVal[0]); 1276} 1277 1278/* 1279** SQL function: edit(VALUE) 1280** edit(VALUE,EDITOR) 1281** 1282** These steps: 1283** 1284** (1) Write VALUE into a temporary file. 1285** (2) Run program EDITOR on that temporary file. 1286** (3) Read the temporary file back and return its content as the result. 1287** (4) Delete the temporary file 1288** 1289** If the EDITOR argument is omitted, use the value in the VISUAL 1290** environment variable. If still there is no EDITOR, through an error. 1291** 1292** Also throw an error if the EDITOR program returns a non-zero exit code. 1293*/ 1294#ifndef SQLITE_NOHAVE_SYSTEM 1295static void editFunc( 1296 sqlite3_context *context, 1297 int argc, 1298 sqlite3_value **argv 1299){ 1300 const char *zEditor; 1301 char *zTempFile = 0; 1302 sqlite3 *db; 1303 char *zCmd = 0; 1304 int bBin; 1305 int rc; 1306 int hasCRNL = 0; 1307 FILE *f = 0; 1308 sqlite3_int64 sz; 1309 sqlite3_int64 x; 1310 unsigned char *p = 0; 1311 1312 if( argc==2 ){ 1313 zEditor = (const char*)sqlite3_value_text(argv[1]); 1314 }else{ 1315 zEditor = getenv("VISUAL"); 1316 } 1317 if( zEditor==0 ){ 1318 sqlite3_result_error(context, "no editor for edit()", -1); 1319 return; 1320 } 1321 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1322 sqlite3_result_error(context, "NULL input to edit()", -1); 1323 return; 1324 } 1325 db = sqlite3_context_db_handle(context); 1326 zTempFile = 0; 1327 sqlite3_file_control(db, 0, SQLITE_FCNTL_TEMPFILENAME, &zTempFile); 1328 if( zTempFile==0 ){ 1329 sqlite3_uint64 r = 0; 1330 sqlite3_randomness(sizeof(r), &r); 1331 zTempFile = sqlite3_mprintf("temp%llx", r); 1332 if( zTempFile==0 ){ 1333 sqlite3_result_error_nomem(context); 1334 return; 1335 } 1336 } 1337 bBin = sqlite3_value_type(argv[0])==SQLITE_BLOB; 1338 /* When writing the file to be edited, do \n to \r\n conversions on systems 1339 ** that want \r\n line endings */ 1340 f = fopen(zTempFile, bBin ? "wb" : "w"); 1341 if( f==0 ){ 1342 sqlite3_result_error(context, "edit() cannot open temp file", -1); 1343 goto edit_func_end; 1344 } 1345 sz = sqlite3_value_bytes(argv[0]); 1346 if( bBin ){ 1347 x = fwrite(sqlite3_value_blob(argv[0]), 1, (size_t)sz, f); 1348 }else{ 1349 const char *z = (const char*)sqlite3_value_text(argv[0]); 1350 /* Remember whether or not the value originally contained \r\n */ 1351 if( z && strstr(z,"\r\n")!=0 ) hasCRNL = 1; 1352 x = fwrite(sqlite3_value_text(argv[0]), 1, (size_t)sz, f); 1353 } 1354 fclose(f); 1355 f = 0; 1356 if( x!=sz ){ 1357 sqlite3_result_error(context, "edit() could not write the whole file", -1); 1358 goto edit_func_end; 1359 } 1360 zCmd = sqlite3_mprintf("%s \"%s\"", zEditor, zTempFile); 1361 if( zCmd==0 ){ 1362 sqlite3_result_error_nomem(context); 1363 goto edit_func_end; 1364 } 1365 rc = system(zCmd); 1366 sqlite3_free(zCmd); 1367 if( rc ){ 1368 sqlite3_result_error(context, "EDITOR returned non-zero", -1); 1369 goto edit_func_end; 1370 } 1371 f = fopen(zTempFile, "rb"); 1372 if( f==0 ){ 1373 sqlite3_result_error(context, 1374 "edit() cannot reopen temp file after edit", -1); 1375 goto edit_func_end; 1376 } 1377 fseek(f, 0, SEEK_END); 1378 sz = ftell(f); 1379 rewind(f); 1380 p = sqlite3_malloc64( sz+1 ); 1381 if( p==0 ){ 1382 sqlite3_result_error_nomem(context); 1383 goto edit_func_end; 1384 } 1385 x = fread(p, 1, (size_t)sz, f); 1386 fclose(f); 1387 f = 0; 1388 if( x!=sz ){ 1389 sqlite3_result_error(context, "could not read back the whole file", -1); 1390 goto edit_func_end; 1391 } 1392 if( bBin ){ 1393 sqlite3_result_blob64(context, p, sz, sqlite3_free); 1394 }else{ 1395 sqlite3_int64 i, j; 1396 if( hasCRNL ){ 1397 /* If the original contains \r\n then do no conversions back to \n */ 1398 j = sz; 1399 }else{ 1400 /* If the file did not originally contain \r\n then convert any new 1401 ** \r\n back into \n */ 1402 for(i=j=0; i<sz; i++){ 1403 if( p[i]=='\r' && p[i+1]=='\n' ) i++; 1404 p[j++] = p[i]; 1405 } 1406 sz = j; 1407 p[sz] = 0; 1408 } 1409 sqlite3_result_text64(context, (const char*)p, sz, 1410 sqlite3_free, SQLITE_UTF8); 1411 } 1412 p = 0; 1413 1414edit_func_end: 1415 if( f ) fclose(f); 1416 unlink(zTempFile); 1417 sqlite3_free(zTempFile); 1418 sqlite3_free(p); 1419} 1420#endif /* SQLITE_NOHAVE_SYSTEM */ 1421 1422/* 1423** Save or restore the current output mode 1424*/ 1425static void outputModePush(ShellState *p){ 1426 p->modePrior = p->mode; 1427 p->priorShFlgs = p->shellFlgs; 1428 memcpy(p->colSepPrior, p->colSeparator, sizeof(p->colSeparator)); 1429 memcpy(p->rowSepPrior, p->rowSeparator, sizeof(p->rowSeparator)); 1430} 1431static void outputModePop(ShellState *p){ 1432 p->mode = p->modePrior; 1433 p->shellFlgs = p->priorShFlgs; 1434 memcpy(p->colSeparator, p->colSepPrior, sizeof(p->colSeparator)); 1435 memcpy(p->rowSeparator, p->rowSepPrior, sizeof(p->rowSeparator)); 1436} 1437 1438/* 1439** Output the given string as a hex-encoded blob (eg. X'1234' ) 1440*/ 1441static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ 1442 int i; 1443 char *zBlob = (char *)pBlob; 1444 raw_printf(out,"X'"); 1445 for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); } 1446 raw_printf(out,"'"); 1447} 1448 1449/* 1450** Find a string that is not found anywhere in z[]. Return a pointer 1451** to that string. 1452** 1453** Try to use zA and zB first. If both of those are already found in z[] 1454** then make up some string and store it in the buffer zBuf. 1455*/ 1456static const char *unused_string( 1457 const char *z, /* Result must not appear anywhere in z */ 1458 const char *zA, const char *zB, /* Try these first */ 1459 char *zBuf /* Space to store a generated string */ 1460){ 1461 unsigned i = 0; 1462 if( strstr(z, zA)==0 ) return zA; 1463 if( strstr(z, zB)==0 ) return zB; 1464 do{ 1465 sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++); 1466 }while( strstr(z,zBuf)!=0 ); 1467 return zBuf; 1468} 1469 1470/* 1471** Output the given string as a quoted string using SQL quoting conventions. 1472** 1473** See also: output_quoted_escaped_string() 1474*/ 1475static void output_quoted_string(FILE *out, const char *z){ 1476 int i; 1477 char c; 1478 setBinaryMode(out, 1); 1479 for(i=0; (c = z[i])!=0 && c!='\''; i++){} 1480 if( c==0 ){ 1481 utf8_printf(out,"'%s'",z); 1482 }else{ 1483 raw_printf(out, "'"); 1484 while( *z ){ 1485 for(i=0; (c = z[i])!=0 && c!='\''; i++){} 1486 if( c=='\'' ) i++; 1487 if( i ){ 1488 utf8_printf(out, "%.*s", i, z); 1489 z += i; 1490 } 1491 if( c=='\'' ){ 1492 raw_printf(out, "'"); 1493 continue; 1494 } 1495 if( c==0 ){ 1496 break; 1497 } 1498 z++; 1499 } 1500 raw_printf(out, "'"); 1501 } 1502 setTextMode(out, 1); 1503} 1504 1505/* 1506** Output the given string as a quoted string using SQL quoting conventions. 1507** Additionallly , escape the "\n" and "\r" characters so that they do not 1508** get corrupted by end-of-line translation facilities in some operating 1509** systems. 1510** 1511** This is like output_quoted_string() but with the addition of the \r\n 1512** escape mechanism. 1513*/ 1514static void output_quoted_escaped_string(FILE *out, const char *z){ 1515 int i; 1516 char c; 1517 setBinaryMode(out, 1); 1518 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){} 1519 if( c==0 ){ 1520 utf8_printf(out,"'%s'",z); 1521 }else{ 1522 const char *zNL = 0; 1523 const char *zCR = 0; 1524 int nNL = 0; 1525 int nCR = 0; 1526 char zBuf1[20], zBuf2[20]; 1527 for(i=0; z[i]; i++){ 1528 if( z[i]=='\n' ) nNL++; 1529 if( z[i]=='\r' ) nCR++; 1530 } 1531 if( nNL ){ 1532 raw_printf(out, "replace("); 1533 zNL = unused_string(z, "\\n", "\\012", zBuf1); 1534 } 1535 if( nCR ){ 1536 raw_printf(out, "replace("); 1537 zCR = unused_string(z, "\\r", "\\015", zBuf2); 1538 } 1539 raw_printf(out, "'"); 1540 while( *z ){ 1541 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){} 1542 if( c=='\'' ) i++; 1543 if( i ){ 1544 utf8_printf(out, "%.*s", i, z); 1545 z += i; 1546 } 1547 if( c=='\'' ){ 1548 raw_printf(out, "'"); 1549 continue; 1550 } 1551 if( c==0 ){ 1552 break; 1553 } 1554 z++; 1555 if( c=='\n' ){ 1556 raw_printf(out, "%s", zNL); 1557 continue; 1558 } 1559 raw_printf(out, "%s", zCR); 1560 } 1561 raw_printf(out, "'"); 1562 if( nCR ){ 1563 raw_printf(out, ",'%s',char(13))", zCR); 1564 } 1565 if( nNL ){ 1566 raw_printf(out, ",'%s',char(10))", zNL); 1567 } 1568 } 1569 setTextMode(out, 1); 1570} 1571 1572/* 1573** Output the given string as a quoted according to C or TCL quoting rules. 1574*/ 1575static void output_c_string(FILE *out, const char *z){ 1576 unsigned int c; 1577 fputc('"', out); 1578 while( (c = *(z++))!=0 ){ 1579 if( c=='\\' ){ 1580 fputc(c, out); 1581 fputc(c, out); 1582 }else if( c=='"' ){ 1583 fputc('\\', out); 1584 fputc('"', out); 1585 }else if( c=='\t' ){ 1586 fputc('\\', out); 1587 fputc('t', out); 1588 }else if( c=='\n' ){ 1589 fputc('\\', out); 1590 fputc('n', out); 1591 }else if( c=='\r' ){ 1592 fputc('\\', out); 1593 fputc('r', out); 1594 }else if( !isprint(c&0xff) ){ 1595 raw_printf(out, "\\%03o", c&0xff); 1596 }else{ 1597 fputc(c, out); 1598 } 1599 } 1600 fputc('"', out); 1601} 1602 1603/* 1604** Output the given string as a quoted according to JSON quoting rules. 1605*/ 1606static void output_json_string(FILE *out, const char *z, int n){ 1607 unsigned int c; 1608 if( n<0 ) n = (int)strlen(z); 1609 fputc('"', out); 1610 while( n-- ){ 1611 c = *(z++); 1612 if( c=='\\' || c=='"' ){ 1613 fputc('\\', out); 1614 fputc(c, out); 1615 }else if( c<=0x1f ){ 1616 fputc('\\', out); 1617 if( c=='\b' ){ 1618 fputc('b', out); 1619 }else if( c=='\f' ){ 1620 fputc('f', out); 1621 }else if( c=='\n' ){ 1622 fputc('n', out); 1623 }else if( c=='\r' ){ 1624 fputc('r', out); 1625 }else if( c=='\t' ){ 1626 fputc('t', out); 1627 }else{ 1628 raw_printf(out, "u%04x",c); 1629 } 1630 }else{ 1631 fputc(c, out); 1632 } 1633 } 1634 fputc('"', out); 1635} 1636 1637/* 1638** Output the given string with characters that are special to 1639** HTML escaped. 1640*/ 1641static void output_html_string(FILE *out, const char *z){ 1642 int i; 1643 if( z==0 ) z = ""; 1644 while( *z ){ 1645 for(i=0; z[i] 1646 && z[i]!='<' 1647 && z[i]!='&' 1648 && z[i]!='>' 1649 && z[i]!='\"' 1650 && z[i]!='\''; 1651 i++){} 1652 if( i>0 ){ 1653 utf8_printf(out,"%.*s",i,z); 1654 } 1655 if( z[i]=='<' ){ 1656 raw_printf(out,"<"); 1657 }else if( z[i]=='&' ){ 1658 raw_printf(out,"&"); 1659 }else if( z[i]=='>' ){ 1660 raw_printf(out,">"); 1661 }else if( z[i]=='\"' ){ 1662 raw_printf(out,"""); 1663 }else if( z[i]=='\'' ){ 1664 raw_printf(out,"'"); 1665 }else{ 1666 break; 1667 } 1668 z += i + 1; 1669 } 1670} 1671 1672/* 1673** If a field contains any character identified by a 1 in the following 1674** array, then the string must be quoted for CSV. 1675*/ 1676static const char needCsvQuote[] = { 1677 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1678 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1679 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1680 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1681 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1682 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1683 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1684 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1685 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1686 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1687 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1688 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1689 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1690 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1691 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1692 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1693}; 1694 1695/* 1696** Output a single term of CSV. Actually, p->colSeparator is used for 1697** the separator, which may or may not be a comma. p->nullValue is 1698** the null value. Strings are quoted if necessary. The separator 1699** is only issued if bSep is true. 1700*/ 1701static void output_csv(ShellState *p, const char *z, int bSep){ 1702 FILE *out = p->out; 1703 if( z==0 ){ 1704 utf8_printf(out,"%s",p->nullValue); 1705 }else{ 1706 int i; 1707 int nSep = strlen30(p->colSeparator); 1708 for(i=0; z[i]; i++){ 1709 if( needCsvQuote[((unsigned char*)z)[i]] 1710 || (z[i]==p->colSeparator[0] && 1711 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){ 1712 i = 0; 1713 break; 1714 } 1715 } 1716 if( i==0 ){ 1717 char *zQuoted = sqlite3_mprintf("\"%w\"", z); 1718 utf8_printf(out, "%s", zQuoted); 1719 sqlite3_free(zQuoted); 1720 }else{ 1721 utf8_printf(out, "%s", z); 1722 } 1723 } 1724 if( bSep ){ 1725 utf8_printf(p->out, "%s", p->colSeparator); 1726 } 1727} 1728 1729/* 1730** This routine runs when the user presses Ctrl-C 1731*/ 1732static void interrupt_handler(int NotUsed){ 1733 UNUSED_PARAMETER(NotUsed); 1734 seenInterrupt++; 1735 if( seenInterrupt>2 ) exit(1); 1736 if( globalDb ) sqlite3_interrupt(globalDb); 1737} 1738 1739#if (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 1740/* 1741** This routine runs for console events (e.g. Ctrl-C) on Win32 1742*/ 1743static BOOL WINAPI ConsoleCtrlHandler( 1744 DWORD dwCtrlType /* One of the CTRL_*_EVENT constants */ 1745){ 1746 if( dwCtrlType==CTRL_C_EVENT ){ 1747 interrupt_handler(0); 1748 return TRUE; 1749 } 1750 return FALSE; 1751} 1752#endif 1753 1754#ifndef SQLITE_OMIT_AUTHORIZATION 1755/* 1756** When the ".auth ON" is set, the following authorizer callback is 1757** invoked. It always returns SQLITE_OK. 1758*/ 1759static int shellAuth( 1760 void *pClientData, 1761 int op, 1762 const char *zA1, 1763 const char *zA2, 1764 const char *zA3, 1765 const char *zA4 1766){ 1767 ShellState *p = (ShellState*)pClientData; 1768 static const char *azAction[] = { 0, 1769 "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX", 1770 "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW", 1771 "CREATE_TRIGGER", "CREATE_VIEW", "DELETE", 1772 "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX", 1773 "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW", 1774 "DROP_TRIGGER", "DROP_VIEW", "INSERT", 1775 "PRAGMA", "READ", "SELECT", 1776 "TRANSACTION", "UPDATE", "ATTACH", 1777 "DETACH", "ALTER_TABLE", "REINDEX", 1778 "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE", 1779 "FUNCTION", "SAVEPOINT", "RECURSIVE" 1780 }; 1781 int i; 1782 const char *az[4]; 1783 az[0] = zA1; 1784 az[1] = zA2; 1785 az[2] = zA3; 1786 az[3] = zA4; 1787 utf8_printf(p->out, "authorizer: %s", azAction[op]); 1788 for(i=0; i<4; i++){ 1789 raw_printf(p->out, " "); 1790 if( az[i] ){ 1791 output_c_string(p->out, az[i]); 1792 }else{ 1793 raw_printf(p->out, "NULL"); 1794 } 1795 } 1796 raw_printf(p->out, "\n"); 1797 return SQLITE_OK; 1798} 1799#endif 1800 1801/* 1802** Print a schema statement. Part of MODE_Semi and MODE_Pretty output. 1803** 1804** This routine converts some CREATE TABLE statements for shadow tables 1805** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements. 1806*/ 1807static void printSchemaLine(FILE *out, const char *z, const char *zTail){ 1808 if( z==0 ) return; 1809 if( zTail==0 ) return; 1810 if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){ 1811 utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail); 1812 }else{ 1813 utf8_printf(out, "%s%s", z, zTail); 1814 } 1815} 1816static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){ 1817 char c = z[n]; 1818 z[n] = 0; 1819 printSchemaLine(out, z, zTail); 1820 z[n] = c; 1821} 1822 1823/* 1824** Return true if string z[] has nothing but whitespace and comments to the 1825** end of the first line. 1826*/ 1827static int wsToEol(const char *z){ 1828 int i; 1829 for(i=0; z[i]; i++){ 1830 if( z[i]=='\n' ) return 1; 1831 if( IsSpace(z[i]) ) continue; 1832 if( z[i]=='-' && z[i+1]=='-' ) return 1; 1833 return 0; 1834 } 1835 return 1; 1836} 1837 1838/* 1839** Add a new entry to the EXPLAIN QUERY PLAN data 1840*/ 1841static void eqp_append(ShellState *p, int iEqpId, int p2, const char *zText){ 1842 EQPGraphRow *pNew; 1843 int nText = strlen30(zText); 1844 if( p->autoEQPtest ){ 1845 utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText); 1846 } 1847 pNew = sqlite3_malloc64( sizeof(*pNew) + nText ); 1848 if( pNew==0 ) shell_out_of_memory(); 1849 pNew->iEqpId = iEqpId; 1850 pNew->iParentId = p2; 1851 memcpy(pNew->zText, zText, nText+1); 1852 pNew->pNext = 0; 1853 if( p->sGraph.pLast ){ 1854 p->sGraph.pLast->pNext = pNew; 1855 }else{ 1856 p->sGraph.pRow = pNew; 1857 } 1858 p->sGraph.pLast = pNew; 1859} 1860 1861/* 1862** Free and reset the EXPLAIN QUERY PLAN data that has been collected 1863** in p->sGraph. 1864*/ 1865static void eqp_reset(ShellState *p){ 1866 EQPGraphRow *pRow, *pNext; 1867 for(pRow = p->sGraph.pRow; pRow; pRow = pNext){ 1868 pNext = pRow->pNext; 1869 sqlite3_free(pRow); 1870 } 1871 memset(&p->sGraph, 0, sizeof(p->sGraph)); 1872} 1873 1874/* Return the next EXPLAIN QUERY PLAN line with iEqpId that occurs after 1875** pOld, or return the first such line if pOld is NULL 1876*/ 1877static EQPGraphRow *eqp_next_row(ShellState *p, int iEqpId, EQPGraphRow *pOld){ 1878 EQPGraphRow *pRow = pOld ? pOld->pNext : p->sGraph.pRow; 1879 while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext; 1880 return pRow; 1881} 1882 1883/* Render a single level of the graph that has iEqpId as its parent. Called 1884** recursively to render sublevels. 1885*/ 1886static void eqp_render_level(ShellState *p, int iEqpId){ 1887 EQPGraphRow *pRow, *pNext; 1888 int n = strlen30(p->sGraph.zPrefix); 1889 char *z; 1890 for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){ 1891 pNext = eqp_next_row(p, iEqpId, pRow); 1892 z = pRow->zText; 1893 utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix, 1894 pNext ? "|--" : "`--", z); 1895 if( n<(int)sizeof(p->sGraph.zPrefix)-7 ){ 1896 memcpy(&p->sGraph.zPrefix[n], pNext ? "| " : " ", 4); 1897 eqp_render_level(p, pRow->iEqpId); 1898 p->sGraph.zPrefix[n] = 0; 1899 } 1900 } 1901} 1902 1903/* 1904** Display and reset the EXPLAIN QUERY PLAN data 1905*/ 1906static void eqp_render(ShellState *p){ 1907 EQPGraphRow *pRow = p->sGraph.pRow; 1908 if( pRow ){ 1909 if( pRow->zText[0]=='-' ){ 1910 if( pRow->pNext==0 ){ 1911 eqp_reset(p); 1912 return; 1913 } 1914 utf8_printf(p->out, "%s\n", pRow->zText+3); 1915 p->sGraph.pRow = pRow->pNext; 1916 sqlite3_free(pRow); 1917 }else{ 1918 utf8_printf(p->out, "QUERY PLAN\n"); 1919 } 1920 p->sGraph.zPrefix[0] = 0; 1921 eqp_render_level(p, 0); 1922 eqp_reset(p); 1923 } 1924} 1925 1926#ifndef SQLITE_OMIT_PROGRESS_CALLBACK 1927/* 1928** Progress handler callback. 1929*/ 1930static int progress_handler(void *pClientData) { 1931 ShellState *p = (ShellState*)pClientData; 1932 p->nProgress++; 1933 if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){ 1934 raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress); 1935 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 1936 if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0; 1937 return 1; 1938 } 1939 if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){ 1940 raw_printf(p->out, "Progress %u\n", p->nProgress); 1941 } 1942 return 0; 1943} 1944#endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 1945 1946/* 1947** Print N dashes 1948*/ 1949static void print_dashes(FILE *out, int N){ 1950 const char zDash[] = "--------------------------------------------------"; 1951 const int nDash = sizeof(zDash) - 1; 1952 while( N>nDash ){ 1953 fputs(zDash, out); 1954 N -= nDash; 1955 } 1956 raw_printf(out, "%.*s", N, zDash); 1957} 1958 1959/* 1960** Print a markdown or table-style row separator using ascii-art 1961*/ 1962static void print_row_separator( 1963 ShellState *p, 1964 int nArg, 1965 const char *zSep 1966){ 1967 int i; 1968 if( nArg>0 ){ 1969 fputs(zSep, p->out); 1970 print_dashes(p->out, p->actualWidth[0]+2); 1971 for(i=1; i<nArg; i++){ 1972 fputs(zSep, p->out); 1973 print_dashes(p->out, p->actualWidth[i]+2); 1974 } 1975 fputs(zSep, p->out); 1976 } 1977 fputs("\n", p->out); 1978} 1979 1980/* 1981** This is the callback routine that the shell 1982** invokes for each row of a query result. 1983*/ 1984static int shell_callback( 1985 void *pArg, 1986 int nArg, /* Number of result columns */ 1987 char **azArg, /* Text of each result column */ 1988 char **azCol, /* Column names */ 1989 int *aiType /* Column types. Might be NULL */ 1990){ 1991 int i; 1992 ShellState *p = (ShellState*)pArg; 1993 1994 if( azArg==0 ) return 0; 1995 switch( p->cMode ){ 1996 case MODE_Line: { 1997 int w = 5; 1998 if( azArg==0 ) break; 1999 for(i=0; i<nArg; i++){ 2000 int len = strlen30(azCol[i] ? azCol[i] : ""); 2001 if( len>w ) w = len; 2002 } 2003 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator); 2004 for(i=0; i<nArg; i++){ 2005 utf8_printf(p->out,"%*s = %s%s", w, azCol[i], 2006 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator); 2007 } 2008 break; 2009 } 2010 case MODE_Explain: { 2011 static const int aExplainWidth[] = {4, 13, 4, 4, 4, 13, 2, 13}; 2012 if( nArg>ArraySize(aExplainWidth) ){ 2013 nArg = ArraySize(aExplainWidth); 2014 } 2015 if( p->cnt++==0 ){ 2016 for(i=0; i<nArg; i++){ 2017 int w = aExplainWidth[i]; 2018 utf8_width_print(p->out, w, azCol[i]); 2019 fputs(i==nArg-1 ? "\n" : " ", p->out); 2020 } 2021 for(i=0; i<nArg; i++){ 2022 int w = aExplainWidth[i]; 2023 print_dashes(p->out, w); 2024 fputs(i==nArg-1 ? "\n" : " ", p->out); 2025 } 2026 } 2027 if( azArg==0 ) break; 2028 for(i=0; i<nArg; i++){ 2029 int w = aExplainWidth[i]; 2030 if( azArg[i] && strlenChar(azArg[i])>w ){ 2031 w = strlenChar(azArg[i]); 2032 } 2033 if( i==1 && p->aiIndent && p->pStmt ){ 2034 if( p->iIndent<p->nIndent ){ 2035 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], ""); 2036 } 2037 p->iIndent++; 2038 } 2039 utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue); 2040 fputs(i==nArg-1 ? "\n" : " ", p->out); 2041 } 2042 break; 2043 } 2044 case MODE_Semi: { /* .schema and .fullschema output */ 2045 printSchemaLine(p->out, azArg[0], ";\n"); 2046 break; 2047 } 2048 case MODE_Pretty: { /* .schema and .fullschema with --indent */ 2049 char *z; 2050 int j; 2051 int nParen = 0; 2052 char cEnd = 0; 2053 char c; 2054 int nLine = 0; 2055 assert( nArg==1 ); 2056 if( azArg[0]==0 ) break; 2057 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0 2058 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0 2059 ){ 2060 utf8_printf(p->out, "%s;\n", azArg[0]); 2061 break; 2062 } 2063 z = sqlite3_mprintf("%s", azArg[0]); 2064 j = 0; 2065 for(i=0; IsSpace(z[i]); i++){} 2066 for(; (c = z[i])!=0; i++){ 2067 if( IsSpace(c) ){ 2068 if( z[j-1]=='\r' ) z[j-1] = '\n'; 2069 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue; 2070 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){ 2071 j--; 2072 } 2073 z[j++] = c; 2074 } 2075 while( j>0 && IsSpace(z[j-1]) ){ j--; } 2076 z[j] = 0; 2077 if( strlen30(z)>=79 ){ 2078 for(i=j=0; (c = z[i])!=0; i++){ /* Copy from z[i] back to z[j] */ 2079 if( c==cEnd ){ 2080 cEnd = 0; 2081 }else if( c=='"' || c=='\'' || c=='`' ){ 2082 cEnd = c; 2083 }else if( c=='[' ){ 2084 cEnd = ']'; 2085 }else if( c=='-' && z[i+1]=='-' ){ 2086 cEnd = '\n'; 2087 }else if( c=='(' ){ 2088 nParen++; 2089 }else if( c==')' ){ 2090 nParen--; 2091 if( nLine>0 && nParen==0 && j>0 ){ 2092 printSchemaLineN(p->out, z, j, "\n"); 2093 j = 0; 2094 } 2095 } 2096 z[j++] = c; 2097 if( nParen==1 && cEnd==0 2098 && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1))) 2099 ){ 2100 if( c=='\n' ) j--; 2101 printSchemaLineN(p->out, z, j, "\n "); 2102 j = 0; 2103 nLine++; 2104 while( IsSpace(z[i+1]) ){ i++; } 2105 } 2106 } 2107 z[j] = 0; 2108 } 2109 printSchemaLine(p->out, z, ";\n"); 2110 sqlite3_free(z); 2111 break; 2112 } 2113 case MODE_List: { 2114 if( p->cnt++==0 && p->showHeader ){ 2115 for(i=0; i<nArg; i++){ 2116 utf8_printf(p->out,"%s%s",azCol[i], 2117 i==nArg-1 ? p->rowSeparator : p->colSeparator); 2118 } 2119 } 2120 if( azArg==0 ) break; 2121 for(i=0; i<nArg; i++){ 2122 char *z = azArg[i]; 2123 if( z==0 ) z = p->nullValue; 2124 utf8_printf(p->out, "%s", z); 2125 if( i<nArg-1 ){ 2126 utf8_printf(p->out, "%s", p->colSeparator); 2127 }else{ 2128 utf8_printf(p->out, "%s", p->rowSeparator); 2129 } 2130 } 2131 break; 2132 } 2133 case MODE_Html: { 2134 if( p->cnt++==0 && p->showHeader ){ 2135 raw_printf(p->out,"<TR>"); 2136 for(i=0; i<nArg; i++){ 2137 raw_printf(p->out,"<TH>"); 2138 output_html_string(p->out, azCol[i]); 2139 raw_printf(p->out,"</TH>\n"); 2140 } 2141 raw_printf(p->out,"</TR>\n"); 2142 } 2143 if( azArg==0 ) break; 2144 raw_printf(p->out,"<TR>"); 2145 for(i=0; i<nArg; i++){ 2146 raw_printf(p->out,"<TD>"); 2147 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 2148 raw_printf(p->out,"</TD>\n"); 2149 } 2150 raw_printf(p->out,"</TR>\n"); 2151 break; 2152 } 2153 case MODE_Tcl: { 2154 if( p->cnt++==0 && p->showHeader ){ 2155 for(i=0; i<nArg; i++){ 2156 output_c_string(p->out,azCol[i] ? azCol[i] : ""); 2157 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 2158 } 2159 utf8_printf(p->out, "%s", p->rowSeparator); 2160 } 2161 if( azArg==0 ) break; 2162 for(i=0; i<nArg; i++){ 2163 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 2164 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 2165 } 2166 utf8_printf(p->out, "%s", p->rowSeparator); 2167 break; 2168 } 2169 case MODE_Csv: { 2170 setBinaryMode(p->out, 1); 2171 if( p->cnt++==0 && p->showHeader ){ 2172 for(i=0; i<nArg; i++){ 2173 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1); 2174 } 2175 utf8_printf(p->out, "%s", p->rowSeparator); 2176 } 2177 if( nArg>0 ){ 2178 for(i=0; i<nArg; i++){ 2179 output_csv(p, azArg[i], i<nArg-1); 2180 } 2181 utf8_printf(p->out, "%s", p->rowSeparator); 2182 } 2183 setTextMode(p->out, 1); 2184 break; 2185 } 2186 case MODE_Insert: { 2187 if( azArg==0 ) break; 2188 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable); 2189 if( p->showHeader ){ 2190 raw_printf(p->out,"("); 2191 for(i=0; i<nArg; i++){ 2192 if( i>0 ) raw_printf(p->out, ","); 2193 if( quoteChar(azCol[i]) ){ 2194 char *z = sqlite3_mprintf("\"%w\"", azCol[i]); 2195 utf8_printf(p->out, "%s", z); 2196 sqlite3_free(z); 2197 }else{ 2198 raw_printf(p->out, "%s", azCol[i]); 2199 } 2200 } 2201 raw_printf(p->out,")"); 2202 } 2203 p->cnt++; 2204 for(i=0; i<nArg; i++){ 2205 raw_printf(p->out, i>0 ? "," : " VALUES("); 2206 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 2207 utf8_printf(p->out,"NULL"); 2208 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 2209 if( ShellHasFlag(p, SHFLG_Newlines) ){ 2210 output_quoted_string(p->out, azArg[i]); 2211 }else{ 2212 output_quoted_escaped_string(p->out, azArg[i]); 2213 } 2214 }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 2215 utf8_printf(p->out,"%s", azArg[i]); 2216 }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 2217 char z[50]; 2218 double r = sqlite3_column_double(p->pStmt, i); 2219 sqlite3_uint64 ur; 2220 memcpy(&ur,&r,sizeof(r)); 2221 if( ur==0x7ff0000000000000LL ){ 2222 raw_printf(p->out, "1e999"); 2223 }else if( ur==0xfff0000000000000LL ){ 2224 raw_printf(p->out, "-1e999"); 2225 }else{ 2226 sqlite3_snprintf(50,z,"%!.20g", r); 2227 raw_printf(p->out, "%s", z); 2228 } 2229 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 2230 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 2231 int nBlob = sqlite3_column_bytes(p->pStmt, i); 2232 output_hex_blob(p->out, pBlob, nBlob); 2233 }else if( isNumber(azArg[i], 0) ){ 2234 utf8_printf(p->out,"%s", azArg[i]); 2235 }else if( ShellHasFlag(p, SHFLG_Newlines) ){ 2236 output_quoted_string(p->out, azArg[i]); 2237 }else{ 2238 output_quoted_escaped_string(p->out, azArg[i]); 2239 } 2240 } 2241 raw_printf(p->out,");\n"); 2242 break; 2243 } 2244 case MODE_Json: { 2245 if( azArg==0 ) break; 2246 if( p->cnt==0 ){ 2247 fputs("[{", p->out); 2248 }else{ 2249 fputs(",\n{", p->out); 2250 } 2251 p->cnt++; 2252 for(i=0; i<nArg; i++){ 2253 output_json_string(p->out, azCol[i], -1); 2254 putc(':', p->out); 2255 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 2256 fputs("null",p->out); 2257 }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 2258 char z[50]; 2259 double r = sqlite3_column_double(p->pStmt, i); 2260 sqlite3_uint64 ur; 2261 memcpy(&ur,&r,sizeof(r)); 2262 if( ur==0x7ff0000000000000LL ){ 2263 raw_printf(p->out, "1e999"); 2264 }else if( ur==0xfff0000000000000LL ){ 2265 raw_printf(p->out, "-1e999"); 2266 }else{ 2267 sqlite3_snprintf(50,z,"%!.20g", r); 2268 raw_printf(p->out, "%s", z); 2269 } 2270 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 2271 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 2272 int nBlob = sqlite3_column_bytes(p->pStmt, i); 2273 output_json_string(p->out, pBlob, nBlob); 2274 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 2275 output_json_string(p->out, azArg[i], -1); 2276 }else{ 2277 utf8_printf(p->out,"%s", azArg[i]); 2278 } 2279 if( i<nArg-1 ){ 2280 putc(',', p->out); 2281 } 2282 } 2283 putc('}', p->out); 2284 break; 2285 } 2286 case MODE_Quote: { 2287 if( azArg==0 ) break; 2288 if( p->cnt==0 && p->showHeader ){ 2289 for(i=0; i<nArg; i++){ 2290 if( i>0 ) fputs(p->colSeparator, p->out); 2291 output_quoted_string(p->out, azCol[i]); 2292 } 2293 fputs(p->rowSeparator, p->out); 2294 } 2295 p->cnt++; 2296 for(i=0; i<nArg; i++){ 2297 if( i>0 ) fputs(p->colSeparator, p->out); 2298 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 2299 utf8_printf(p->out,"NULL"); 2300 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 2301 output_quoted_string(p->out, azArg[i]); 2302 }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 2303 utf8_printf(p->out,"%s", azArg[i]); 2304 }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 2305 char z[50]; 2306 double r = sqlite3_column_double(p->pStmt, i); 2307 sqlite3_snprintf(50,z,"%!.20g", r); 2308 raw_printf(p->out, "%s", z); 2309 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 2310 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 2311 int nBlob = sqlite3_column_bytes(p->pStmt, i); 2312 output_hex_blob(p->out, pBlob, nBlob); 2313 }else if( isNumber(azArg[i], 0) ){ 2314 utf8_printf(p->out,"%s", azArg[i]); 2315 }else{ 2316 output_quoted_string(p->out, azArg[i]); 2317 } 2318 } 2319 fputs(p->rowSeparator, p->out); 2320 break; 2321 } 2322 case MODE_Ascii: { 2323 if( p->cnt++==0 && p->showHeader ){ 2324 for(i=0; i<nArg; i++){ 2325 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 2326 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : ""); 2327 } 2328 utf8_printf(p->out, "%s", p->rowSeparator); 2329 } 2330 if( azArg==0 ) break; 2331 for(i=0; i<nArg; i++){ 2332 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 2333 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue); 2334 } 2335 utf8_printf(p->out, "%s", p->rowSeparator); 2336 break; 2337 } 2338 case MODE_EQP: { 2339 eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]); 2340 break; 2341 } 2342 } 2343 return 0; 2344} 2345 2346/* 2347** This is the callback routine that the SQLite library 2348** invokes for each row of a query result. 2349*/ 2350static int callback(void *pArg, int nArg, char **azArg, char **azCol){ 2351 /* since we don't have type info, call the shell_callback with a NULL value */ 2352 return shell_callback(pArg, nArg, azArg, azCol, NULL); 2353} 2354 2355/* 2356** This is the callback routine from sqlite3_exec() that appends all 2357** output onto the end of a ShellText object. 2358*/ 2359static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){ 2360 ShellText *p = (ShellText*)pArg; 2361 int i; 2362 UNUSED_PARAMETER(az); 2363 if( azArg==0 ) return 0; 2364 if( p->n ) appendText(p, "|", 0); 2365 for(i=0; i<nArg; i++){ 2366 if( i ) appendText(p, ",", 0); 2367 if( azArg[i] ) appendText(p, azArg[i], 0); 2368 } 2369 return 0; 2370} 2371 2372/* 2373** Generate an appropriate SELFTEST table in the main database. 2374*/ 2375static void createSelftestTable(ShellState *p){ 2376 char *zErrMsg = 0; 2377 sqlite3_exec(p->db, 2378 "SAVEPOINT selftest_init;\n" 2379 "CREATE TABLE IF NOT EXISTS selftest(\n" 2380 " tno INTEGER PRIMARY KEY,\n" /* Test number */ 2381 " op TEXT,\n" /* Operator: memo run */ 2382 " cmd TEXT,\n" /* Command text */ 2383 " ans TEXT\n" /* Desired answer */ 2384 ");" 2385 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n" 2386 "INSERT INTO [_shell$self](rowid,op,cmd)\n" 2387 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n" 2388 " 'memo','Tests generated by --init');\n" 2389 "INSERT INTO [_shell$self]\n" 2390 " SELECT 'run',\n" 2391 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql " 2392 "FROM sqlite_schema ORDER BY 2'',224))',\n" 2393 " hex(sha3_query('SELECT type,name,tbl_name,sql " 2394 "FROM sqlite_schema ORDER BY 2',224));\n" 2395 "INSERT INTO [_shell$self]\n" 2396 " SELECT 'run'," 2397 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||" 2398 " printf('%w',name) || '\" NOT INDEXED'',224))',\n" 2399 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n" 2400 " FROM (\n" 2401 " SELECT name FROM sqlite_schema\n" 2402 " WHERE type='table'\n" 2403 " AND name<>'selftest'\n" 2404 " AND coalesce(rootpage,0)>0\n" 2405 " )\n" 2406 " ORDER BY name;\n" 2407 "INSERT INTO [_shell$self]\n" 2408 " VALUES('run','PRAGMA integrity_check','ok');\n" 2409 "INSERT INTO selftest(tno,op,cmd,ans)" 2410 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n" 2411 "DROP TABLE [_shell$self];" 2412 ,0,0,&zErrMsg); 2413 if( zErrMsg ){ 2414 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg); 2415 sqlite3_free(zErrMsg); 2416 } 2417 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0); 2418} 2419 2420 2421/* 2422** Set the destination table field of the ShellState structure to 2423** the name of the table given. Escape any quote characters in the 2424** table name. 2425*/ 2426static void set_table_name(ShellState *p, const char *zName){ 2427 int i, n; 2428 char cQuote; 2429 char *z; 2430 2431 if( p->zDestTable ){ 2432 free(p->zDestTable); 2433 p->zDestTable = 0; 2434 } 2435 if( zName==0 ) return; 2436 cQuote = quoteChar(zName); 2437 n = strlen30(zName); 2438 if( cQuote ) n += n+2; 2439 z = p->zDestTable = malloc( n+1 ); 2440 if( z==0 ) shell_out_of_memory(); 2441 n = 0; 2442 if( cQuote ) z[n++] = cQuote; 2443 for(i=0; zName[i]; i++){ 2444 z[n++] = zName[i]; 2445 if( zName[i]==cQuote ) z[n++] = cQuote; 2446 } 2447 if( cQuote ) z[n++] = cQuote; 2448 z[n] = 0; 2449} 2450 2451 2452/* 2453** Execute a query statement that will generate SQL output. Print 2454** the result columns, comma-separated, on a line and then add a 2455** semicolon terminator to the end of that line. 2456** 2457** If the number of columns is 1 and that column contains text "--" 2458** then write the semicolon on a separate line. That way, if a 2459** "--" comment occurs at the end of the statement, the comment 2460** won't consume the semicolon terminator. 2461*/ 2462static int run_table_dump_query( 2463 ShellState *p, /* Query context */ 2464 const char *zSelect /* SELECT statement to extract content */ 2465){ 2466 sqlite3_stmt *pSelect; 2467 int rc; 2468 int nResult; 2469 int i; 2470 const char *z; 2471 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0); 2472 if( rc!=SQLITE_OK || !pSelect ){ 2473 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 2474 sqlite3_errmsg(p->db)); 2475 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 2476 return rc; 2477 } 2478 rc = sqlite3_step(pSelect); 2479 nResult = sqlite3_column_count(pSelect); 2480 while( rc==SQLITE_ROW ){ 2481 z = (const char*)sqlite3_column_text(pSelect, 0); 2482 utf8_printf(p->out, "%s", z); 2483 for(i=1; i<nResult; i++){ 2484 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i)); 2485 } 2486 if( z==0 ) z = ""; 2487 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++; 2488 if( z[0] ){ 2489 raw_printf(p->out, "\n;\n"); 2490 }else{ 2491 raw_printf(p->out, ";\n"); 2492 } 2493 rc = sqlite3_step(pSelect); 2494 } 2495 rc = sqlite3_finalize(pSelect); 2496 if( rc!=SQLITE_OK ){ 2497 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 2498 sqlite3_errmsg(p->db)); 2499 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 2500 } 2501 return rc; 2502} 2503 2504/* 2505** Allocate space and save off current error string. 2506*/ 2507static char *save_err_msg( 2508 sqlite3 *db /* Database to query */ 2509){ 2510 int nErrMsg = 1+strlen30(sqlite3_errmsg(db)); 2511 char *zErrMsg = sqlite3_malloc64(nErrMsg); 2512 if( zErrMsg ){ 2513 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg); 2514 } 2515 return zErrMsg; 2516} 2517 2518#ifdef __linux__ 2519/* 2520** Attempt to display I/O stats on Linux using /proc/PID/io 2521*/ 2522static void displayLinuxIoStats(FILE *out){ 2523 FILE *in; 2524 char z[200]; 2525 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid()); 2526 in = fopen(z, "rb"); 2527 if( in==0 ) return; 2528 while( fgets(z, sizeof(z), in)!=0 ){ 2529 static const struct { 2530 const char *zPattern; 2531 const char *zDesc; 2532 } aTrans[] = { 2533 { "rchar: ", "Bytes received by read():" }, 2534 { "wchar: ", "Bytes sent to write():" }, 2535 { "syscr: ", "Read() system calls:" }, 2536 { "syscw: ", "Write() system calls:" }, 2537 { "read_bytes: ", "Bytes read from storage:" }, 2538 { "write_bytes: ", "Bytes written to storage:" }, 2539 { "cancelled_write_bytes: ", "Cancelled write bytes:" }, 2540 }; 2541 int i; 2542 for(i=0; i<ArraySize(aTrans); i++){ 2543 int n = strlen30(aTrans[i].zPattern); 2544 if( strncmp(aTrans[i].zPattern, z, n)==0 ){ 2545 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]); 2546 break; 2547 } 2548 } 2549 } 2550 fclose(in); 2551} 2552#endif 2553 2554/* 2555** Display a single line of status using 64-bit values. 2556*/ 2557static void displayStatLine( 2558 ShellState *p, /* The shell context */ 2559 char *zLabel, /* Label for this one line */ 2560 char *zFormat, /* Format for the result */ 2561 int iStatusCtrl, /* Which status to display */ 2562 int bReset /* True to reset the stats */ 2563){ 2564 sqlite3_int64 iCur = -1; 2565 sqlite3_int64 iHiwtr = -1; 2566 int i, nPercent; 2567 char zLine[200]; 2568 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset); 2569 for(i=0, nPercent=0; zFormat[i]; i++){ 2570 if( zFormat[i]=='%' ) nPercent++; 2571 } 2572 if( nPercent>1 ){ 2573 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr); 2574 }else{ 2575 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr); 2576 } 2577 raw_printf(p->out, "%-36s %s\n", zLabel, zLine); 2578} 2579 2580/* 2581** Display memory stats. 2582*/ 2583static int display_stats( 2584 sqlite3 *db, /* Database to query */ 2585 ShellState *pArg, /* Pointer to ShellState */ 2586 int bReset /* True to reset the stats */ 2587){ 2588 int iCur; 2589 int iHiwtr; 2590 FILE *out; 2591 if( pArg==0 || pArg->out==0 ) return 0; 2592 out = pArg->out; 2593 2594 if( pArg->pStmt && (pArg->statsOn & 2) ){ 2595 int nCol, i, x; 2596 sqlite3_stmt *pStmt = pArg->pStmt; 2597 char z[100]; 2598 nCol = sqlite3_column_count(pStmt); 2599 raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol); 2600 for(i=0; i<nCol; i++){ 2601 sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x); 2602 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i)); 2603#ifndef SQLITE_OMIT_DECLTYPE 2604 sqlite3_snprintf(30, z+x, "declared type:"); 2605 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i)); 2606#endif 2607#ifdef SQLITE_ENABLE_COLUMN_METADATA 2608 sqlite3_snprintf(30, z+x, "database name:"); 2609 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i)); 2610 sqlite3_snprintf(30, z+x, "table name:"); 2611 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i)); 2612 sqlite3_snprintf(30, z+x, "origin name:"); 2613 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i)); 2614#endif 2615 } 2616 } 2617 2618 displayStatLine(pArg, "Memory Used:", 2619 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset); 2620 displayStatLine(pArg, "Number of Outstanding Allocations:", 2621 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset); 2622 if( pArg->shellFlgs & SHFLG_Pagecache ){ 2623 displayStatLine(pArg, "Number of Pcache Pages Used:", 2624 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset); 2625 } 2626 displayStatLine(pArg, "Number of Pcache Overflow Bytes:", 2627 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset); 2628 displayStatLine(pArg, "Largest Allocation:", 2629 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset); 2630 displayStatLine(pArg, "Largest Pcache Allocation:", 2631 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset); 2632#ifdef YYTRACKMAXSTACKDEPTH 2633 displayStatLine(pArg, "Deepest Parser Stack:", 2634 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset); 2635#endif 2636 2637 if( db ){ 2638 if( pArg->shellFlgs & SHFLG_Lookaside ){ 2639 iHiwtr = iCur = -1; 2640 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, 2641 &iCur, &iHiwtr, bReset); 2642 raw_printf(pArg->out, 2643 "Lookaside Slots Used: %d (max %d)\n", 2644 iCur, iHiwtr); 2645 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, 2646 &iCur, &iHiwtr, bReset); 2647 raw_printf(pArg->out, "Successful lookaside attempts: %d\n", 2648 iHiwtr); 2649 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, 2650 &iCur, &iHiwtr, bReset); 2651 raw_printf(pArg->out, "Lookaside failures due to size: %d\n", 2652 iHiwtr); 2653 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, 2654 &iCur, &iHiwtr, bReset); 2655 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n", 2656 iHiwtr); 2657 } 2658 iHiwtr = iCur = -1; 2659 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset); 2660 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n", 2661 iCur); 2662 iHiwtr = iCur = -1; 2663 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1); 2664 raw_printf(pArg->out, "Page cache hits: %d\n", iCur); 2665 iHiwtr = iCur = -1; 2666 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1); 2667 raw_printf(pArg->out, "Page cache misses: %d\n", iCur); 2668 iHiwtr = iCur = -1; 2669 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1); 2670 raw_printf(pArg->out, "Page cache writes: %d\n", iCur); 2671 iHiwtr = iCur = -1; 2672 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1); 2673 raw_printf(pArg->out, "Page cache spills: %d\n", iCur); 2674 iHiwtr = iCur = -1; 2675 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset); 2676 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n", 2677 iCur); 2678 iHiwtr = iCur = -1; 2679 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset); 2680 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", 2681 iCur); 2682 } 2683 2684 if( pArg->pStmt ){ 2685 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, 2686 bReset); 2687 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur); 2688 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset); 2689 raw_printf(pArg->out, "Sort Operations: %d\n", iCur); 2690 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset); 2691 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur); 2692 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset); 2693 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur); 2694 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset); 2695 raw_printf(pArg->out, "Reprepare operations: %d\n", iCur); 2696 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset); 2697 raw_printf(pArg->out, "Number of times run: %d\n", iCur); 2698 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset); 2699 raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur); 2700 } 2701 2702#ifdef __linux__ 2703 displayLinuxIoStats(pArg->out); 2704#endif 2705 2706 /* Do not remove this machine readable comment: extra-stats-output-here */ 2707 2708 return 0; 2709} 2710 2711/* 2712** Display scan stats. 2713*/ 2714static void display_scanstats( 2715 sqlite3 *db, /* Database to query */ 2716 ShellState *pArg /* Pointer to ShellState */ 2717){ 2718#ifndef SQLITE_ENABLE_STMT_SCANSTATUS 2719 UNUSED_PARAMETER(db); 2720 UNUSED_PARAMETER(pArg); 2721#else 2722 int i, k, n, mx; 2723 raw_printf(pArg->out, "-------- scanstats --------\n"); 2724 mx = 0; 2725 for(k=0; k<=mx; k++){ 2726 double rEstLoop = 1.0; 2727 for(i=n=0; 1; i++){ 2728 sqlite3_stmt *p = pArg->pStmt; 2729 sqlite3_int64 nLoop, nVisit; 2730 double rEst; 2731 int iSid; 2732 const char *zExplain; 2733 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){ 2734 break; 2735 } 2736 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid); 2737 if( iSid>mx ) mx = iSid; 2738 if( iSid!=k ) continue; 2739 if( n==0 ){ 2740 rEstLoop = (double)nLoop; 2741 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k); 2742 } 2743 n++; 2744 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit); 2745 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst); 2746 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain); 2747 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain); 2748 rEstLoop *= rEst; 2749 raw_printf(pArg->out, 2750 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n", 2751 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst 2752 ); 2753 } 2754 } 2755 raw_printf(pArg->out, "---------------------------\n"); 2756#endif 2757} 2758 2759/* 2760** Parameter azArray points to a zero-terminated array of strings. zStr 2761** points to a single nul-terminated string. Return non-zero if zStr 2762** is equal, according to strcmp(), to any of the strings in the array. 2763** Otherwise, return zero. 2764*/ 2765static int str_in_array(const char *zStr, const char **azArray){ 2766 int i; 2767 for(i=0; azArray[i]; i++){ 2768 if( 0==strcmp(zStr, azArray[i]) ) return 1; 2769 } 2770 return 0; 2771} 2772 2773/* 2774** If compiled statement pSql appears to be an EXPLAIN statement, allocate 2775** and populate the ShellState.aiIndent[] array with the number of 2776** spaces each opcode should be indented before it is output. 2777** 2778** The indenting rules are: 2779** 2780** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent 2781** all opcodes that occur between the p2 jump destination and the opcode 2782** itself by 2 spaces. 2783** 2784** * For each "Goto", if the jump destination is earlier in the program 2785** and ends on one of: 2786** Yield SeekGt SeekLt RowSetRead Rewind 2787** or if the P1 parameter is one instead of zero, 2788** then indent all opcodes between the earlier instruction 2789** and "Goto" by 2 spaces. 2790*/ 2791static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){ 2792 const char *zSql; /* The text of the SQL statement */ 2793 const char *z; /* Used to check if this is an EXPLAIN */ 2794 int *abYield = 0; /* True if op is an OP_Yield */ 2795 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */ 2796 int iOp; /* Index of operation in p->aiIndent[] */ 2797 2798 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 }; 2799 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead", 2800 "Rewind", 0 }; 2801 const char *azGoto[] = { "Goto", 0 }; 2802 2803 /* Try to figure out if this is really an EXPLAIN statement. If this 2804 ** cannot be verified, return early. */ 2805 if( sqlite3_column_count(pSql)!=8 ){ 2806 p->cMode = p->mode; 2807 return; 2808 } 2809 zSql = sqlite3_sql(pSql); 2810 if( zSql==0 ) return; 2811 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++); 2812 if( sqlite3_strnicmp(z, "explain", 7) ){ 2813 p->cMode = p->mode; 2814 return; 2815 } 2816 2817 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){ 2818 int i; 2819 int iAddr = sqlite3_column_int(pSql, 0); 2820 const char *zOp = (const char*)sqlite3_column_text(pSql, 1); 2821 2822 /* Set p2 to the P2 field of the current opcode. Then, assuming that 2823 ** p2 is an instruction address, set variable p2op to the index of that 2824 ** instruction in the aiIndent[] array. p2 and p2op may be different if 2825 ** the current instruction is part of a sub-program generated by an 2826 ** SQL trigger or foreign key. */ 2827 int p2 = sqlite3_column_int(pSql, 3); 2828 int p2op = (p2 + (iOp-iAddr)); 2829 2830 /* Grow the p->aiIndent array as required */ 2831 if( iOp>=nAlloc ){ 2832 if( iOp==0 ){ 2833 /* Do further verfication that this is explain output. Abort if 2834 ** it is not */ 2835 static const char *explainCols[] = { 2836 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" }; 2837 int jj; 2838 for(jj=0; jj<ArraySize(explainCols); jj++){ 2839 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){ 2840 p->cMode = p->mode; 2841 sqlite3_reset(pSql); 2842 return; 2843 } 2844 } 2845 } 2846 nAlloc += 100; 2847 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int)); 2848 if( p->aiIndent==0 ) shell_out_of_memory(); 2849 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int)); 2850 if( abYield==0 ) shell_out_of_memory(); 2851 } 2852 abYield[iOp] = str_in_array(zOp, azYield); 2853 p->aiIndent[iOp] = 0; 2854 p->nIndent = iOp+1; 2855 2856 if( str_in_array(zOp, azNext) ){ 2857 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 2858 } 2859 if( str_in_array(zOp, azGoto) && p2op<p->nIndent 2860 && (abYield[p2op] || sqlite3_column_int(pSql, 2)) 2861 ){ 2862 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 2863 } 2864 } 2865 2866 p->iIndent = 0; 2867 sqlite3_free(abYield); 2868 sqlite3_reset(pSql); 2869} 2870 2871/* 2872** Free the array allocated by explain_data_prepare(). 2873*/ 2874static void explain_data_delete(ShellState *p){ 2875 sqlite3_free(p->aiIndent); 2876 p->aiIndent = 0; 2877 p->nIndent = 0; 2878 p->iIndent = 0; 2879} 2880 2881/* 2882** Disable and restore .wheretrace and .selecttrace settings. 2883*/ 2884#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 2885extern unsigned int sqlite3_unsupported_selecttrace; 2886static int savedSelectTrace; 2887#endif 2888#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 2889extern int sqlite3WhereTrace; 2890static int savedWhereTrace; 2891#endif 2892static void disable_debug_trace_modes(void){ 2893#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 2894 savedSelectTrace = sqlite3_unsupported_selecttrace; 2895 sqlite3_unsupported_selecttrace = 0; 2896#endif 2897#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 2898 savedWhereTrace = sqlite3WhereTrace; 2899 sqlite3WhereTrace = 0; 2900#endif 2901} 2902static void restore_debug_trace_modes(void){ 2903#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 2904 sqlite3_unsupported_selecttrace = savedSelectTrace; 2905#endif 2906#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 2907 sqlite3WhereTrace = savedWhereTrace; 2908#endif 2909} 2910 2911/* Create the TEMP table used to store parameter bindings */ 2912static void bind_table_init(ShellState *p){ 2913 int wrSchema = 0; 2914 int defensiveMode = 0; 2915 sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, -1, &defensiveMode); 2916 sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 0, 0); 2917 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema); 2918 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0); 2919 sqlite3_exec(p->db, 2920 "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n" 2921 " key TEXT PRIMARY KEY,\n" 2922 " value ANY\n" 2923 ") WITHOUT ROWID;", 2924 0, 0, 0); 2925 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0); 2926 sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, defensiveMode, 0); 2927} 2928 2929/* 2930** Bind parameters on a prepared statement. 2931** 2932** Parameter bindings are taken from a TEMP table of the form: 2933** 2934** CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value) 2935** WITHOUT ROWID; 2936** 2937** No bindings occur if this table does not exist. The name of the table 2938** begins with "sqlite_" so that it will not collide with ordinary application 2939** tables. The table must be in the TEMP schema. 2940*/ 2941static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){ 2942 int nVar; 2943 int i; 2944 int rc; 2945 sqlite3_stmt *pQ = 0; 2946 2947 nVar = sqlite3_bind_parameter_count(pStmt); 2948 if( nVar==0 ) return; /* Nothing to do */ 2949 if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters", 2950 "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){ 2951 return; /* Parameter table does not exist */ 2952 } 2953 rc = sqlite3_prepare_v2(pArg->db, 2954 "SELECT value FROM temp.sqlite_parameters" 2955 " WHERE key=?1", -1, &pQ, 0); 2956 if( rc || pQ==0 ) return; 2957 for(i=1; i<=nVar; i++){ 2958 char zNum[30]; 2959 const char *zVar = sqlite3_bind_parameter_name(pStmt, i); 2960 if( zVar==0 ){ 2961 sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i); 2962 zVar = zNum; 2963 } 2964 sqlite3_bind_text(pQ, 1, zVar, -1, SQLITE_STATIC); 2965 if( sqlite3_step(pQ)==SQLITE_ROW ){ 2966 sqlite3_bind_value(pStmt, i, sqlite3_column_value(pQ, 0)); 2967 }else{ 2968 sqlite3_bind_null(pStmt, i); 2969 } 2970 sqlite3_reset(pQ); 2971 } 2972 sqlite3_finalize(pQ); 2973} 2974 2975/* 2976** UTF8 box-drawing characters. Imagine box lines like this: 2977** 2978** 1 2979** | 2980** 4 --+-- 2 2981** | 2982** 3 2983** 2984** Each box characters has between 2 and 4 of the lines leading from 2985** the center. The characters are here identified by the numbers of 2986** their corresponding lines. 2987*/ 2988#define BOX_24 "\342\224\200" /* U+2500 --- */ 2989#define BOX_13 "\342\224\202" /* U+2502 | */ 2990#define BOX_23 "\342\224\214" /* U+250c ,- */ 2991#define BOX_34 "\342\224\220" /* U+2510 -, */ 2992#define BOX_12 "\342\224\224" /* U+2514 '- */ 2993#define BOX_14 "\342\224\230" /* U+2518 -' */ 2994#define BOX_123 "\342\224\234" /* U+251c |- */ 2995#define BOX_134 "\342\224\244" /* U+2524 -| */ 2996#define BOX_234 "\342\224\254" /* U+252c -,- */ 2997#define BOX_124 "\342\224\264" /* U+2534 -'- */ 2998#define BOX_1234 "\342\224\274" /* U+253c -|- */ 2999 3000/* Draw horizontal line N characters long using unicode box 3001** characters 3002*/ 3003static void print_box_line(FILE *out, int N){ 3004 const char zDash[] = 3005 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 3006 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24; 3007 const int nDash = sizeof(zDash) - 1; 3008 N *= 3; 3009 while( N>nDash ){ 3010 utf8_printf(out, zDash); 3011 N -= nDash; 3012 } 3013 utf8_printf(out, "%.*s", N, zDash); 3014} 3015 3016/* 3017** Draw a horizontal separator for a MODE_Box table. 3018*/ 3019static void print_box_row_separator( 3020 ShellState *p, 3021 int nArg, 3022 const char *zSep1, 3023 const char *zSep2, 3024 const char *zSep3 3025){ 3026 int i; 3027 if( nArg>0 ){ 3028 utf8_printf(p->out, "%s", zSep1); 3029 print_box_line(p->out, p->actualWidth[0]+2); 3030 for(i=1; i<nArg; i++){ 3031 utf8_printf(p->out, "%s", zSep2); 3032 print_box_line(p->out, p->actualWidth[i]+2); 3033 } 3034 utf8_printf(p->out, "%s", zSep3); 3035 } 3036 fputs("\n", p->out); 3037} 3038 3039 3040 3041/* 3042** Run a prepared statement and output the result in one of the 3043** table-oriented formats: MODE_Column, MODE_Markdown, MODE_Table, 3044** or MODE_Box. 3045** 3046** This is different from ordinary exec_prepared_stmt() in that 3047** it has to run the entire query and gather the results into memory 3048** first, in order to determine column widths, before providing 3049** any output. 3050*/ 3051static void exec_prepared_stmt_columnar( 3052 ShellState *p, /* Pointer to ShellState */ 3053 sqlite3_stmt *pStmt /* Statment to run */ 3054){ 3055 sqlite3_int64 nRow = 0; 3056 int nColumn = 0; 3057 char **azData = 0; 3058 sqlite3_int64 nAlloc = 0; 3059 const char *z; 3060 int rc; 3061 sqlite3_int64 i, nData; 3062 int j, nTotal, w, n; 3063 const char *colSep = 0; 3064 const char *rowSep = 0; 3065 3066 rc = sqlite3_step(pStmt); 3067 if( rc!=SQLITE_ROW ) return; 3068 nColumn = sqlite3_column_count(pStmt); 3069 nAlloc = nColumn*4; 3070 azData = sqlite3_malloc64( nAlloc*sizeof(char*) ); 3071 if( azData==0 ) shell_out_of_memory(); 3072 for(i=0; i<nColumn; i++){ 3073 azData[i] = strdup(sqlite3_column_name(pStmt,i)); 3074 } 3075 do{ 3076 if( (nRow+2)*nColumn >= nAlloc ){ 3077 nAlloc *= 2; 3078 azData = sqlite3_realloc64(azData, nAlloc*sizeof(char*)); 3079 if( azData==0 ) shell_out_of_memory(); 3080 } 3081 nRow++; 3082 for(i=0; i<nColumn; i++){ 3083 z = (const char*)sqlite3_column_text(pStmt,i); 3084 azData[nRow*nColumn + i] = z ? strdup(z) : 0; 3085 } 3086 }while( (rc = sqlite3_step(pStmt))==SQLITE_ROW ); 3087 if( nColumn>p->nWidth ){ 3088 p->colWidth = realloc(p->colWidth, nColumn*2*sizeof(int)); 3089 if( p->colWidth==0 ) shell_out_of_memory(); 3090 for(i=p->nWidth; i<nColumn; i++) p->colWidth[i] = 0; 3091 p->nWidth = nColumn; 3092 p->actualWidth = &p->colWidth[nColumn]; 3093 } 3094 memset(p->actualWidth, 0, nColumn*sizeof(int)); 3095 for(i=0; i<nColumn; i++){ 3096 w = p->colWidth[i]; 3097 if( w<0 ) w = -w; 3098 p->actualWidth[i] = w; 3099 } 3100 nTotal = nColumn*(nRow+1); 3101 for(i=0; i<nTotal; i++){ 3102 z = azData[i]; 3103 if( z==0 ) z = p->nullValue; 3104 n = strlenChar(z); 3105 j = i%nColumn; 3106 if( n>p->actualWidth[j] ) p->actualWidth[j] = n; 3107 } 3108 if( seenInterrupt ) goto columnar_end; 3109 switch( p->cMode ){ 3110 case MODE_Column: { 3111 colSep = " "; 3112 rowSep = "\n"; 3113 if( p->showHeader ){ 3114 for(i=0; i<nColumn; i++){ 3115 w = p->actualWidth[i]; 3116 if( p->colWidth[i]<0 ) w = -w; 3117 utf8_width_print(p->out, w, azData[i]); 3118 fputs(i==nColumn-1?"\n":" ", p->out); 3119 } 3120 for(i=0; i<nColumn; i++){ 3121 print_dashes(p->out, p->actualWidth[i]); 3122 fputs(i==nColumn-1?"\n":" ", p->out); 3123 } 3124 } 3125 break; 3126 } 3127 case MODE_Table: { 3128 colSep = " | "; 3129 rowSep = " |\n"; 3130 print_row_separator(p, nColumn, "+"); 3131 fputs("| ", p->out); 3132 for(i=0; i<nColumn; i++){ 3133 w = p->actualWidth[i]; 3134 n = strlenChar(azData[i]); 3135 utf8_printf(p->out, "%*s%s%*s", (w-n)/2, "", azData[i], (w-n+1)/2, ""); 3136 fputs(i==nColumn-1?" |\n":" | ", p->out); 3137 } 3138 print_row_separator(p, nColumn, "+"); 3139 break; 3140 } 3141 case MODE_Markdown: { 3142 colSep = " | "; 3143 rowSep = " |\n"; 3144 fputs("| ", p->out); 3145 for(i=0; i<nColumn; i++){ 3146 w = p->actualWidth[i]; 3147 n = strlenChar(azData[i]); 3148 utf8_printf(p->out, "%*s%s%*s", (w-n)/2, "", azData[i], (w-n+1)/2, ""); 3149 fputs(i==nColumn-1?" |\n":" | ", p->out); 3150 } 3151 print_row_separator(p, nColumn, "|"); 3152 break; 3153 } 3154 case MODE_Box: { 3155 colSep = " " BOX_13 " "; 3156 rowSep = " " BOX_13 "\n"; 3157 print_box_row_separator(p, nColumn, BOX_23, BOX_234, BOX_34); 3158 utf8_printf(p->out, BOX_13 " "); 3159 for(i=0; i<nColumn; i++){ 3160 w = p->actualWidth[i]; 3161 n = strlenChar(azData[i]); 3162 utf8_printf(p->out, "%*s%s%*s%s", 3163 (w-n)/2, "", azData[i], (w-n+1)/2, "", 3164 i==nColumn-1?" "BOX_13"\n":" "BOX_13" "); 3165 } 3166 print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134); 3167 break; 3168 } 3169 } 3170 for(i=nColumn, j=0; i<nTotal; i++, j++){ 3171 if( j==0 && p->cMode!=MODE_Column ){ 3172 utf8_printf(p->out, "%s", p->cMode==MODE_Box?BOX_13" ":"| "); 3173 } 3174 z = azData[i]; 3175 if( z==0 ) z = p->nullValue; 3176 w = p->actualWidth[j]; 3177 if( p->colWidth[j]<0 ) w = -w; 3178 utf8_width_print(p->out, w, z); 3179 if( j==nColumn-1 ){ 3180 utf8_printf(p->out, "%s", rowSep); 3181 j = -1; 3182 if( seenInterrupt ) goto columnar_end; 3183 }else{ 3184 utf8_printf(p->out, "%s", colSep); 3185 } 3186 } 3187 if( p->cMode==MODE_Table ){ 3188 print_row_separator(p, nColumn, "+"); 3189 }else if( p->cMode==MODE_Box ){ 3190 print_box_row_separator(p, nColumn, BOX_12, BOX_124, BOX_14); 3191 } 3192columnar_end: 3193 if( seenInterrupt ){ 3194 utf8_printf(p->out, "Interrupt\n"); 3195 } 3196 nData = (nRow+1)*nColumn; 3197 for(i=0; i<nData; i++) free(azData[i]); 3198 sqlite3_free(azData); 3199} 3200 3201/* 3202** Run a prepared statement 3203*/ 3204static void exec_prepared_stmt( 3205 ShellState *pArg, /* Pointer to ShellState */ 3206 sqlite3_stmt *pStmt /* Statment to run */ 3207){ 3208 int rc; 3209 3210 if( pArg->cMode==MODE_Column 3211 || pArg->cMode==MODE_Table 3212 || pArg->cMode==MODE_Box 3213 || pArg->cMode==MODE_Markdown 3214 ){ 3215 exec_prepared_stmt_columnar(pArg, pStmt); 3216 return; 3217 } 3218 3219 /* perform the first step. this will tell us if we 3220 ** have a result set or not and how wide it is. 3221 */ 3222 rc = sqlite3_step(pStmt); 3223 /* if we have a result set... */ 3224 if( SQLITE_ROW == rc ){ 3225 /* allocate space for col name ptr, value ptr, and type */ 3226 int nCol = sqlite3_column_count(pStmt); 3227 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1); 3228 if( !pData ){ 3229 rc = SQLITE_NOMEM; 3230 }else{ 3231 char **azCols = (char **)pData; /* Names of result columns */ 3232 char **azVals = &azCols[nCol]; /* Results */ 3233 int *aiTypes = (int *)&azVals[nCol]; /* Result types */ 3234 int i, x; 3235 assert(sizeof(int) <= sizeof(char *)); 3236 /* save off ptrs to column names */ 3237 for(i=0; i<nCol; i++){ 3238 azCols[i] = (char *)sqlite3_column_name(pStmt, i); 3239 } 3240 do{ 3241 /* extract the data and data types */ 3242 for(i=0; i<nCol; i++){ 3243 aiTypes[i] = x = sqlite3_column_type(pStmt, i); 3244 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){ 3245 azVals[i] = ""; 3246 }else{ 3247 azVals[i] = (char*)sqlite3_column_text(pStmt, i); 3248 } 3249 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){ 3250 rc = SQLITE_NOMEM; 3251 break; /* from for */ 3252 } 3253 } /* end for */ 3254 3255 /* if data and types extracted successfully... */ 3256 if( SQLITE_ROW == rc ){ 3257 /* call the supplied callback with the result row data */ 3258 if( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){ 3259 rc = SQLITE_ABORT; 3260 }else{ 3261 rc = sqlite3_step(pStmt); 3262 } 3263 } 3264 } while( SQLITE_ROW == rc ); 3265 sqlite3_free(pData); 3266 if( pArg->cMode==MODE_Json ){ 3267 fputs("]\n", pArg->out); 3268 } 3269 } 3270 } 3271} 3272 3273#ifndef SQLITE_OMIT_VIRTUALTABLE 3274/* 3275** This function is called to process SQL if the previous shell command 3276** was ".expert". It passes the SQL in the second argument directly to 3277** the sqlite3expert object. 3278** 3279** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 3280** code. In this case, (*pzErr) may be set to point to a buffer containing 3281** an English language error message. It is the responsibility of the 3282** caller to eventually free this buffer using sqlite3_free(). 3283*/ 3284static int expertHandleSQL( 3285 ShellState *pState, 3286 const char *zSql, 3287 char **pzErr 3288){ 3289 assert( pState->expert.pExpert ); 3290 assert( pzErr==0 || *pzErr==0 ); 3291 return sqlite3_expert_sql(pState->expert.pExpert, zSql, pzErr); 3292} 3293 3294/* 3295** This function is called either to silently clean up the object 3296** created by the ".expert" command (if bCancel==1), or to generate a 3297** report from it and then clean it up (if bCancel==0). 3298** 3299** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 3300** code. In this case, (*pzErr) may be set to point to a buffer containing 3301** an English language error message. It is the responsibility of the 3302** caller to eventually free this buffer using sqlite3_free(). 3303*/ 3304static int expertFinish( 3305 ShellState *pState, 3306 int bCancel, 3307 char **pzErr 3308){ 3309 int rc = SQLITE_OK; 3310 sqlite3expert *p = pState->expert.pExpert; 3311 assert( p ); 3312 assert( bCancel || pzErr==0 || *pzErr==0 ); 3313 if( bCancel==0 ){ 3314 FILE *out = pState->out; 3315 int bVerbose = pState->expert.bVerbose; 3316 3317 rc = sqlite3_expert_analyze(p, pzErr); 3318 if( rc==SQLITE_OK ){ 3319 int nQuery = sqlite3_expert_count(p); 3320 int i; 3321 3322 if( bVerbose ){ 3323 const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES); 3324 raw_printf(out, "-- Candidates -----------------------------\n"); 3325 raw_printf(out, "%s\n", zCand); 3326 } 3327 for(i=0; i<nQuery; i++){ 3328 const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL); 3329 const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES); 3330 const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN); 3331 if( zIdx==0 ) zIdx = "(no new indexes)\n"; 3332 if( bVerbose ){ 3333 raw_printf(out, "-- Query %d --------------------------------\n",i+1); 3334 raw_printf(out, "%s\n\n", zSql); 3335 } 3336 raw_printf(out, "%s\n", zIdx); 3337 raw_printf(out, "%s\n", zEQP); 3338 } 3339 } 3340 } 3341 sqlite3_expert_destroy(p); 3342 pState->expert.pExpert = 0; 3343 return rc; 3344} 3345 3346/* 3347** Implementation of ".expert" dot command. 3348*/ 3349static int expertDotCommand( 3350 ShellState *pState, /* Current shell tool state */ 3351 char **azArg, /* Array of arguments passed to dot command */ 3352 int nArg /* Number of entries in azArg[] */ 3353){ 3354 int rc = SQLITE_OK; 3355 char *zErr = 0; 3356 int i; 3357 int iSample = 0; 3358 3359 assert( pState->expert.pExpert==0 ); 3360 memset(&pState->expert, 0, sizeof(ExpertInfo)); 3361 3362 for(i=1; rc==SQLITE_OK && i<nArg; i++){ 3363 char *z = azArg[i]; 3364 int n; 3365 if( z[0]=='-' && z[1]=='-' ) z++; 3366 n = strlen30(z); 3367 if( n>=2 && 0==strncmp(z, "-verbose", n) ){ 3368 pState->expert.bVerbose = 1; 3369 } 3370 else if( n>=2 && 0==strncmp(z, "-sample", n) ){ 3371 if( i==(nArg-1) ){ 3372 raw_printf(stderr, "option requires an argument: %s\n", z); 3373 rc = SQLITE_ERROR; 3374 }else{ 3375 iSample = (int)integerValue(azArg[++i]); 3376 if( iSample<0 || iSample>100 ){ 3377 raw_printf(stderr, "value out of range: %s\n", azArg[i]); 3378 rc = SQLITE_ERROR; 3379 } 3380 } 3381 } 3382 else{ 3383 raw_printf(stderr, "unknown option: %s\n", z); 3384 rc = SQLITE_ERROR; 3385 } 3386 } 3387 3388 if( rc==SQLITE_OK ){ 3389 pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr); 3390 if( pState->expert.pExpert==0 ){ 3391 raw_printf(stderr, "sqlite3_expert_new: %s\n", zErr); 3392 rc = SQLITE_ERROR; 3393 }else{ 3394 sqlite3_expert_config( 3395 pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample 3396 ); 3397 } 3398 } 3399 3400 return rc; 3401} 3402#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ 3403 3404/* 3405** Execute a statement or set of statements. Print 3406** any result rows/columns depending on the current mode 3407** set via the supplied callback. 3408** 3409** This is very similar to SQLite's built-in sqlite3_exec() 3410** function except it takes a slightly different callback 3411** and callback data argument. 3412*/ 3413static int shell_exec( 3414 ShellState *pArg, /* Pointer to ShellState */ 3415 const char *zSql, /* SQL to be evaluated */ 3416 char **pzErrMsg /* Error msg written here */ 3417){ 3418 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */ 3419 int rc = SQLITE_OK; /* Return Code */ 3420 int rc2; 3421 const char *zLeftover; /* Tail of unprocessed SQL */ 3422 sqlite3 *db = pArg->db; 3423 3424 if( pzErrMsg ){ 3425 *pzErrMsg = NULL; 3426 } 3427 3428#ifndef SQLITE_OMIT_VIRTUALTABLE 3429 if( pArg->expert.pExpert ){ 3430 rc = expertHandleSQL(pArg, zSql, pzErrMsg); 3431 return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg); 3432 } 3433#endif 3434 3435 while( zSql[0] && (SQLITE_OK == rc) ){ 3436 static const char *zStmtSql; 3437 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); 3438 if( SQLITE_OK != rc ){ 3439 if( pzErrMsg ){ 3440 *pzErrMsg = save_err_msg(db); 3441 } 3442 }else{ 3443 if( !pStmt ){ 3444 /* this happens for a comment or white-space */ 3445 zSql = zLeftover; 3446 while( IsSpace(zSql[0]) ) zSql++; 3447 continue; 3448 } 3449 zStmtSql = sqlite3_sql(pStmt); 3450 if( zStmtSql==0 ) zStmtSql = ""; 3451 while( IsSpace(zStmtSql[0]) ) zStmtSql++; 3452 3453 /* save off the prepared statment handle and reset row count */ 3454 if( pArg ){ 3455 pArg->pStmt = pStmt; 3456 pArg->cnt = 0; 3457 } 3458 3459 /* echo the sql statement if echo on */ 3460 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){ 3461 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql); 3462 } 3463 3464 /* Show the EXPLAIN QUERY PLAN if .eqp is on */ 3465 if( pArg && pArg->autoEQP && sqlite3_stmt_isexplain(pStmt)==0 ){ 3466 sqlite3_stmt *pExplain; 3467 char *zEQP; 3468 int triggerEQP = 0; 3469 disable_debug_trace_modes(); 3470 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP); 3471 if( pArg->autoEQP>=AUTOEQP_trigger ){ 3472 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0); 3473 } 3474 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql); 3475 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 3476 if( rc==SQLITE_OK ){ 3477 while( sqlite3_step(pExplain)==SQLITE_ROW ){ 3478 const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3); 3479 int iEqpId = sqlite3_column_int(pExplain, 0); 3480 int iParentId = sqlite3_column_int(pExplain, 1); 3481 if( zEQPLine==0 ) zEQPLine = ""; 3482 if( zEQPLine[0]=='-' ) eqp_render(pArg); 3483 eqp_append(pArg, iEqpId, iParentId, zEQPLine); 3484 } 3485 eqp_render(pArg); 3486 } 3487 sqlite3_finalize(pExplain); 3488 sqlite3_free(zEQP); 3489 if( pArg->autoEQP>=AUTOEQP_full ){ 3490 /* Also do an EXPLAIN for ".eqp full" mode */ 3491 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql); 3492 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 3493 if( rc==SQLITE_OK ){ 3494 pArg->cMode = MODE_Explain; 3495 explain_data_prepare(pArg, pExplain); 3496 exec_prepared_stmt(pArg, pExplain); 3497 explain_data_delete(pArg); 3498 } 3499 sqlite3_finalize(pExplain); 3500 sqlite3_free(zEQP); 3501 } 3502 if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){ 3503 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0); 3504 /* Reprepare pStmt before reactiving trace modes */ 3505 sqlite3_finalize(pStmt); 3506 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 3507 if( pArg ) pArg->pStmt = pStmt; 3508 } 3509 restore_debug_trace_modes(); 3510 } 3511 3512 if( pArg ){ 3513 pArg->cMode = pArg->mode; 3514 if( pArg->autoExplain ){ 3515 if( sqlite3_stmt_isexplain(pStmt)==1 ){ 3516 pArg->cMode = MODE_Explain; 3517 } 3518 if( sqlite3_stmt_isexplain(pStmt)==2 ){ 3519 pArg->cMode = MODE_EQP; 3520 } 3521 } 3522 3523 /* If the shell is currently in ".explain" mode, gather the extra 3524 ** data required to add indents to the output.*/ 3525 if( pArg->cMode==MODE_Explain ){ 3526 explain_data_prepare(pArg, pStmt); 3527 } 3528 } 3529 3530 bind_prepared_stmt(pArg, pStmt); 3531 exec_prepared_stmt(pArg, pStmt); 3532 explain_data_delete(pArg); 3533 eqp_render(pArg); 3534 3535 /* print usage stats if stats on */ 3536 if( pArg && pArg->statsOn ){ 3537 display_stats(db, pArg, 0); 3538 } 3539 3540 /* print loop-counters if required */ 3541 if( pArg && pArg->scanstatsOn ){ 3542 display_scanstats(db, pArg); 3543 } 3544 3545 /* Finalize the statement just executed. If this fails, save a 3546 ** copy of the error message. Otherwise, set zSql to point to the 3547 ** next statement to execute. */ 3548 rc2 = sqlite3_finalize(pStmt); 3549 if( rc!=SQLITE_NOMEM ) rc = rc2; 3550 if( rc==SQLITE_OK ){ 3551 zSql = zLeftover; 3552 while( IsSpace(zSql[0]) ) zSql++; 3553 }else if( pzErrMsg ){ 3554 *pzErrMsg = save_err_msg(db); 3555 } 3556 3557 /* clear saved stmt handle */ 3558 if( pArg ){ 3559 pArg->pStmt = NULL; 3560 } 3561 } 3562 } /* end while */ 3563 3564 return rc; 3565} 3566 3567/* 3568** Release memory previously allocated by tableColumnList(). 3569*/ 3570static void freeColumnList(char **azCol){ 3571 int i; 3572 for(i=1; azCol[i]; i++){ 3573 sqlite3_free(azCol[i]); 3574 } 3575 /* azCol[0] is a static string */ 3576 sqlite3_free(azCol); 3577} 3578 3579/* 3580** Return a list of pointers to strings which are the names of all 3581** columns in table zTab. The memory to hold the names is dynamically 3582** allocated and must be released by the caller using a subsequent call 3583** to freeColumnList(). 3584** 3585** The azCol[0] entry is usually NULL. However, if zTab contains a rowid 3586** value that needs to be preserved, then azCol[0] is filled in with the 3587** name of the rowid column. 3588** 3589** The first regular column in the table is azCol[1]. The list is terminated 3590** by an entry with azCol[i]==0. 3591*/ 3592static char **tableColumnList(ShellState *p, const char *zTab){ 3593 char **azCol = 0; 3594 sqlite3_stmt *pStmt; 3595 char *zSql; 3596 int nCol = 0; 3597 int nAlloc = 0; 3598 int nPK = 0; /* Number of PRIMARY KEY columns seen */ 3599 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */ 3600 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid); 3601 int rc; 3602 3603 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab); 3604 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 3605 sqlite3_free(zSql); 3606 if( rc ) return 0; 3607 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 3608 if( nCol>=nAlloc-2 ){ 3609 nAlloc = nAlloc*2 + nCol + 10; 3610 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0])); 3611 if( azCol==0 ) shell_out_of_memory(); 3612 } 3613 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1)); 3614 if( sqlite3_column_int(pStmt, 5) ){ 3615 nPK++; 3616 if( nPK==1 3617 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2), 3618 "INTEGER")==0 3619 ){ 3620 isIPK = 1; 3621 }else{ 3622 isIPK = 0; 3623 } 3624 } 3625 } 3626 sqlite3_finalize(pStmt); 3627 if( azCol==0 ) return 0; 3628 azCol[0] = 0; 3629 azCol[nCol+1] = 0; 3630 3631 /* The decision of whether or not a rowid really needs to be preserved 3632 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table 3633 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve 3634 ** rowids on tables where the rowid is inaccessible because there are other 3635 ** columns in the table named "rowid", "_rowid_", and "oid". 3636 */ 3637 if( preserveRowid && isIPK ){ 3638 /* If a single PRIMARY KEY column with type INTEGER was seen, then it 3639 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID 3640 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are 3641 ** ROWID aliases. To distinguish these cases, check to see if 3642 ** there is a "pk" entry in "PRAGMA index_list". There will be 3643 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID. 3644 */ 3645 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)" 3646 " WHERE origin='pk'", zTab); 3647 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 3648 sqlite3_free(zSql); 3649 if( rc ){ 3650 freeColumnList(azCol); 3651 return 0; 3652 } 3653 rc = sqlite3_step(pStmt); 3654 sqlite3_finalize(pStmt); 3655 preserveRowid = rc==SQLITE_ROW; 3656 } 3657 if( preserveRowid ){ 3658 /* Only preserve the rowid if we can find a name to use for the 3659 ** rowid */ 3660 static char *azRowid[] = { "rowid", "_rowid_", "oid" }; 3661 int i, j; 3662 for(j=0; j<3; j++){ 3663 for(i=1; i<=nCol; i++){ 3664 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break; 3665 } 3666 if( i>nCol ){ 3667 /* At this point, we know that azRowid[j] is not the name of any 3668 ** ordinary column in the table. Verify that azRowid[j] is a valid 3669 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID 3670 ** tables will fail this last check */ 3671 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0); 3672 if( rc==SQLITE_OK ) azCol[0] = azRowid[j]; 3673 break; 3674 } 3675 } 3676 } 3677 return azCol; 3678} 3679 3680/* 3681** Toggle the reverse_unordered_selects setting. 3682*/ 3683static void toggleSelectOrder(sqlite3 *db){ 3684 sqlite3_stmt *pStmt = 0; 3685 int iSetting = 0; 3686 char zStmt[100]; 3687 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0); 3688 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 3689 iSetting = sqlite3_column_int(pStmt, 0); 3690 } 3691 sqlite3_finalize(pStmt); 3692 sqlite3_snprintf(sizeof(zStmt), zStmt, 3693 "PRAGMA reverse_unordered_selects(%d)", !iSetting); 3694 sqlite3_exec(db, zStmt, 0, 0, 0); 3695} 3696 3697/* 3698** This is a different callback routine used for dumping the database. 3699** Each row received by this callback consists of a table name, 3700** the table type ("index" or "table") and SQL to create the table. 3701** This routine should print text sufficient to recreate the table. 3702*/ 3703static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){ 3704 int rc; 3705 const char *zTable; 3706 const char *zType; 3707 const char *zSql; 3708 ShellState *p = (ShellState *)pArg; 3709 int dataOnly; 3710 int noSys; 3711 3712 UNUSED_PARAMETER(azNotUsed); 3713 if( nArg!=3 || azArg==0 ) return 0; 3714 zTable = azArg[0]; 3715 zType = azArg[1]; 3716 zSql = azArg[2]; 3717 dataOnly = (p->shellFlgs & SHFLG_DumpDataOnly)!=0; 3718 noSys = (p->shellFlgs & SHFLG_DumpNoSys)!=0; 3719 3720 if( strcmp(zTable, "sqlite_sequence")==0 && !noSys ){ 3721 if( !dataOnly ) raw_printf(p->out, "DELETE FROM sqlite_sequence;\n"); 3722 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 && !noSys ){ 3723 if( !dataOnly ) raw_printf(p->out, "ANALYZE sqlite_schema;\n"); 3724 }else if( strncmp(zTable, "sqlite_", 7)==0 ){ 3725 return 0; 3726 }else if( dataOnly ){ 3727 /* no-op */ 3728 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ 3729 char *zIns; 3730 if( !p->writableSchema ){ 3731 raw_printf(p->out, "PRAGMA writable_schema=ON;\n"); 3732 p->writableSchema = 1; 3733 } 3734 zIns = sqlite3_mprintf( 3735 "INSERT INTO sqlite_schema(type,name,tbl_name,rootpage,sql)" 3736 "VALUES('table','%q','%q',0,'%q');", 3737 zTable, zTable, zSql); 3738 utf8_printf(p->out, "%s\n", zIns); 3739 sqlite3_free(zIns); 3740 return 0; 3741 }else{ 3742 printSchemaLine(p->out, zSql, ";\n"); 3743 } 3744 3745 if( strcmp(zType, "table")==0 ){ 3746 ShellText sSelect; 3747 ShellText sTable; 3748 char **azCol; 3749 int i; 3750 char *savedDestTable; 3751 int savedMode; 3752 3753 azCol = tableColumnList(p, zTable); 3754 if( azCol==0 ){ 3755 p->nErr++; 3756 return 0; 3757 } 3758 3759 /* Always quote the table name, even if it appears to be pure ascii, 3760 ** in case it is a keyword. Ex: INSERT INTO "table" ... */ 3761 initText(&sTable); 3762 appendText(&sTable, zTable, quoteChar(zTable)); 3763 /* If preserving the rowid, add a column list after the table name. 3764 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)" 3765 ** instead of the usual "INSERT INTO tab VALUES(...)". 3766 */ 3767 if( azCol[0] ){ 3768 appendText(&sTable, "(", 0); 3769 appendText(&sTable, azCol[0], 0); 3770 for(i=1; azCol[i]; i++){ 3771 appendText(&sTable, ",", 0); 3772 appendText(&sTable, azCol[i], quoteChar(azCol[i])); 3773 } 3774 appendText(&sTable, ")", 0); 3775 } 3776 3777 /* Build an appropriate SELECT statement */ 3778 initText(&sSelect); 3779 appendText(&sSelect, "SELECT ", 0); 3780 if( azCol[0] ){ 3781 appendText(&sSelect, azCol[0], 0); 3782 appendText(&sSelect, ",", 0); 3783 } 3784 for(i=1; azCol[i]; i++){ 3785 appendText(&sSelect, azCol[i], quoteChar(azCol[i])); 3786 if( azCol[i+1] ){ 3787 appendText(&sSelect, ",", 0); 3788 } 3789 } 3790 freeColumnList(azCol); 3791 appendText(&sSelect, " FROM ", 0); 3792 appendText(&sSelect, zTable, quoteChar(zTable)); 3793 3794 savedDestTable = p->zDestTable; 3795 savedMode = p->mode; 3796 p->zDestTable = sTable.z; 3797 p->mode = p->cMode = MODE_Insert; 3798 rc = shell_exec(p, sSelect.z, 0); 3799 if( (rc&0xff)==SQLITE_CORRUPT ){ 3800 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 3801 toggleSelectOrder(p->db); 3802 shell_exec(p, sSelect.z, 0); 3803 toggleSelectOrder(p->db); 3804 } 3805 p->zDestTable = savedDestTable; 3806 p->mode = savedMode; 3807 freeText(&sTable); 3808 freeText(&sSelect); 3809 if( rc ) p->nErr++; 3810 } 3811 return 0; 3812} 3813 3814/* 3815** Run zQuery. Use dump_callback() as the callback routine so that 3816** the contents of the query are output as SQL statements. 3817** 3818** If we get a SQLITE_CORRUPT error, rerun the query after appending 3819** "ORDER BY rowid DESC" to the end. 3820*/ 3821static int run_schema_dump_query( 3822 ShellState *p, 3823 const char *zQuery 3824){ 3825 int rc; 3826 char *zErr = 0; 3827 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr); 3828 if( rc==SQLITE_CORRUPT ){ 3829 char *zQ2; 3830 int len = strlen30(zQuery); 3831 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 3832 if( zErr ){ 3833 utf8_printf(p->out, "/****** %s ******/\n", zErr); 3834 sqlite3_free(zErr); 3835 zErr = 0; 3836 } 3837 zQ2 = malloc( len+100 ); 3838 if( zQ2==0 ) return rc; 3839 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery); 3840 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr); 3841 if( rc ){ 3842 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr); 3843 }else{ 3844 rc = SQLITE_CORRUPT; 3845 } 3846 sqlite3_free(zErr); 3847 free(zQ2); 3848 } 3849 return rc; 3850} 3851 3852/* 3853** Text of help messages. 3854** 3855** The help text for each individual command begins with a line that starts 3856** with ".". Subsequent lines are supplimental information. 3857** 3858** There must be two or more spaces between the end of the command and the 3859** start of the description of what that command does. 3860*/ 3861static const char *(azHelp[]) = { 3862#if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 3863 ".archive ... Manage SQL archives", 3864 " Each command must have exactly one of the following options:", 3865 " -c, --create Create a new archive", 3866 " -u, --update Add or update files with changed mtime", 3867 " -i, --insert Like -u but always add even if unchanged", 3868 " -t, --list List contents of archive", 3869 " -x, --extract Extract files from archive", 3870 " Optional arguments:", 3871 " -v, --verbose Print each filename as it is processed", 3872 " -f FILE, --file FILE Use archive FILE (default is current db)", 3873 " -a FILE, --append FILE Open FILE using the apndvfs VFS", 3874 " -C DIR, --directory DIR Read/extract files from directory DIR", 3875 " -n, --dryrun Show the SQL that would have occurred", 3876 " Examples:", 3877 " .ar -cf ARCHIVE foo bar # Create ARCHIVE from files foo and bar", 3878 " .ar -tf ARCHIVE # List members of ARCHIVE", 3879 " .ar -xvf ARCHIVE # Verbosely extract files from ARCHIVE", 3880 " See also:", 3881 " http://sqlite.org/cli.html#sqlar_archive_support", 3882#endif 3883#ifndef SQLITE_OMIT_AUTHORIZATION 3884 ".auth ON|OFF Show authorizer callbacks", 3885#endif 3886 ".backup ?DB? FILE Backup DB (default \"main\") to FILE", 3887 " --append Use the appendvfs", 3888 " --async Write to FILE without journal and fsync()", 3889 ".bail on|off Stop after hitting an error. Default OFF", 3890 ".binary on|off Turn binary output on or off. Default OFF", 3891 ".cd DIRECTORY Change the working directory to DIRECTORY", 3892 ".changes on|off Show number of rows changed by SQL", 3893 ".check GLOB Fail if output since .testcase does not match", 3894 ".clone NEWDB Clone data into NEWDB from the existing database", 3895 ".databases List names and files of attached databases", 3896 ".dbconfig ?op? ?val? List or change sqlite3_db_config() options", 3897 ".dbinfo ?DB? Show status information about the database", 3898 ".dump ?TABLE? Render database content as SQL", 3899 " Options:", 3900 " --data-only Output only INSERT statements", 3901 " --newlines Allow unescaped newline characters in output", 3902 " --nosys Omit system tables (ex: \"sqlite_stat1\")", 3903 " --preserve-rowids Include ROWID values in the output", 3904 " TABLE is a LIKE pattern for the tables to dump", 3905 " Additional LIKE patterns can be given in subsequent arguments", 3906 ".echo on|off Turn command echo on or off", 3907 ".eqp on|off|full|... Enable or disable automatic EXPLAIN QUERY PLAN", 3908 " Other Modes:", 3909#ifdef SQLITE_DEBUG 3910 " test Show raw EXPLAIN QUERY PLAN output", 3911 " trace Like \"full\" but enable \"PRAGMA vdbe_trace\"", 3912#endif 3913 " trigger Like \"full\" but also show trigger bytecode", 3914 ".excel Display the output of next command in spreadsheet", 3915 " --bom Put a UTF8 byte-order mark on intermediate file", 3916 ".exit ?CODE? Exit this program with return-code CODE", 3917 ".expert EXPERIMENTAL. Suggest indexes for queries", 3918 ".explain ?on|off|auto? Change the EXPLAIN formatting mode. Default: auto", 3919 ".filectrl CMD ... Run various sqlite3_file_control() operations", 3920 " --schema SCHEMA Use SCHEMA instead of \"main\"", 3921 " --help Show CMD details", 3922 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables", 3923 ".headers on|off Turn display of headers on or off", 3924 ".help ?-all? ?PATTERN? Show help text for PATTERN", 3925 ".import FILE TABLE Import data from FILE into TABLE", 3926 " Options:", 3927 " --ascii Use \\037 and \\036 as column and row separators", 3928 " --csv Use , and \\n as column and row separators", 3929 " --skip N Skip the first N rows of input", 3930 " -v \"Verbose\" - increase auxiliary output", 3931 " Notes:", 3932 " * If TABLE does not exist, it is created. The first row of input", 3933 " determines the column names.", 3934 " * If neither --csv or --ascii are used, the input mode is derived", 3935 " from the \".mode\" output mode", 3936 " * If FILE begins with \"|\" then it is a command that generates the", 3937 " input text.", 3938#ifndef SQLITE_OMIT_TEST_CONTROL 3939 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX", 3940#endif 3941 ".indexes ?TABLE? Show names of indexes", 3942 " If TABLE is specified, only show indexes for", 3943 " tables matching TABLE using the LIKE operator.", 3944#ifdef SQLITE_ENABLE_IOTRACE 3945 ".iotrace FILE Enable I/O diagnostic logging to FILE", 3946#endif 3947 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT", 3948 ".lint OPTIONS Report potential schema issues.", 3949 " Options:", 3950 " fkey-indexes Find missing foreign key indexes", 3951#ifndef SQLITE_OMIT_LOAD_EXTENSION 3952 ".load FILE ?ENTRY? Load an extension library", 3953#endif 3954 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout", 3955 ".mode MODE ?TABLE? Set output mode", 3956 " MODE is one of:", 3957 " ascii Columns/rows delimited by 0x1F and 0x1E", 3958 " box Tables using unicode box-drawing characters", 3959 " csv Comma-separated values", 3960 " column Output in columns. (See .width)", 3961 " html HTML <table> code", 3962 " insert SQL insert statements for TABLE", 3963 " json Results in a JSON array", 3964 " line One value per line", 3965 " list Values delimited by \"|\"", 3966 " markdown Markdown table format", 3967 " quote Escape answers as for SQL", 3968 " table ASCII-art table", 3969 " tabs Tab-separated values", 3970 " tcl TCL list elements", 3971 ".nullvalue STRING Use STRING in place of NULL values", 3972 ".once ?OPTIONS? ?FILE? Output for the next SQL command only to FILE", 3973 " If FILE begins with '|' then open as a pipe", 3974 " --bom Put a UTF8 byte-order mark at the beginning", 3975 " -e Send output to the system text editor", 3976 " -x Send output as CSV to a spreadsheet (same as \".excel\")", 3977#ifdef SQLITE_DEBUG 3978 ".oom ?--repeat M? ?N? Simulate an OOM error on the N-th allocation", 3979#endif 3980 ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE", 3981 " Options:", 3982 " --append Use appendvfs to append database to the end of FILE", 3983#ifdef SQLITE_ENABLE_DESERIALIZE 3984 " --deserialize Load into memory useing sqlite3_deserialize()", 3985 " --hexdb Load the output of \"dbtotxt\" as an in-memory db", 3986 " --maxsize N Maximum size for --hexdb or --deserialized database", 3987#endif 3988 " --new Initialize FILE to an empty database", 3989 " --nofollow Do not follow symbolic links", 3990 " --readonly Open FILE readonly", 3991 " --zip FILE is a ZIP archive", 3992 ".output ?FILE? Send output to FILE or stdout if FILE is omitted", 3993 " If FILE begins with '|' then open it as a pipe.", 3994 " Options:", 3995 " --bom Prefix output with a UTF8 byte-order mark", 3996 " -e Send output to the system text editor", 3997 " -x Send output as CSV to a spreadsheet", 3998 ".parameter CMD ... Manage SQL parameter bindings", 3999 " clear Erase all bindings", 4000 " init Initialize the TEMP table that holds bindings", 4001 " list List the current parameter bindings", 4002 " set PARAMETER VALUE Given SQL parameter PARAMETER a value of VALUE", 4003 " PARAMETER should start with one of: $ : @ ?", 4004 " unset PARAMETER Remove PARAMETER from the binding table", 4005 ".print STRING... Print literal STRING", 4006#ifndef SQLITE_OMIT_PROGRESS_CALLBACK 4007 ".progress N Invoke progress handler after every N opcodes", 4008 " --limit N Interrupt after N progress callbacks", 4009 " --once Do no more than one progress interrupt", 4010 " --quiet|-q No output except at interrupts", 4011 " --reset Reset the count for each input and interrupt", 4012#endif 4013 ".prompt MAIN CONTINUE Replace the standard prompts", 4014 ".quit Exit this program", 4015 ".read FILE Read input from FILE", 4016#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 4017 ".recover Recover as much data as possible from corrupt db.", 4018 " --freelist-corrupt Assume the freelist is corrupt", 4019 " --recovery-db NAME Store recovery metadata in database file NAME", 4020 " --lost-and-found TABLE Alternative name for the lost-and-found table", 4021 " --no-rowids Do not attempt to recover rowid values", 4022 " that are not also INTEGER PRIMARY KEYs", 4023#endif 4024 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE", 4025 ".save FILE Write in-memory database into FILE", 4026 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off", 4027 ".schema ?PATTERN? Show the CREATE statements matching PATTERN", 4028 " Options:", 4029 " --indent Try to pretty-print the schema", 4030 " --nosys Omit objects whose names start with \"sqlite_\"", 4031 ".selftest ?OPTIONS? Run tests defined in the SELFTEST table", 4032 " Options:", 4033 " --init Create a new SELFTEST table", 4034 " -v Verbose output", 4035 ".separator COL ?ROW? Change the column and row separators", 4036#if defined(SQLITE_ENABLE_SESSION) 4037 ".session ?NAME? CMD ... Create or control sessions", 4038 " Subcommands:", 4039 " attach TABLE Attach TABLE", 4040 " changeset FILE Write a changeset into FILE", 4041 " close Close one session", 4042 " enable ?BOOLEAN? Set or query the enable bit", 4043 " filter GLOB... Reject tables matching GLOBs", 4044 " indirect ?BOOLEAN? Mark or query the indirect status", 4045 " isempty Query whether the session is empty", 4046 " list List currently open session names", 4047 " open DB NAME Open a new session on DB", 4048 " patchset FILE Write a patchset into FILE", 4049 " If ?NAME? is omitted, the first defined session is used.", 4050#endif 4051 ".sha3sum ... Compute a SHA3 hash of database content", 4052 " Options:", 4053 " --schema Also hash the sqlite_schema table", 4054 " --sha3-224 Use the sha3-224 algorithm", 4055 " --sha3-256 Use the sha3-256 algorithm (default)", 4056 " --sha3-384 Use the sha3-384 algorithm", 4057 " --sha3-512 Use the sha3-512 algorithm", 4058 " Any other argument is a LIKE pattern for tables to hash", 4059#ifndef SQLITE_NOHAVE_SYSTEM 4060 ".shell CMD ARGS... Run CMD ARGS... in a system shell", 4061#endif 4062 ".show Show the current values for various settings", 4063 ".stats ?on|off? Show stats or turn stats on or off", 4064#ifndef SQLITE_NOHAVE_SYSTEM 4065 ".system CMD ARGS... Run CMD ARGS... in a system shell", 4066#endif 4067 ".tables ?TABLE? List names of tables matching LIKE pattern TABLE", 4068 ".testcase NAME Begin redirecting output to 'testcase-out.txt'", 4069 ".testctrl CMD ... Run various sqlite3_test_control() operations", 4070 " Run \".testctrl\" with no arguments for details", 4071 ".timeout MS Try opening locked tables for MS milliseconds", 4072 ".timer on|off Turn SQL timer on or off", 4073#ifndef SQLITE_OMIT_TRACE 4074 ".trace ?OPTIONS? Output each SQL statement as it is run", 4075 " FILE Send output to FILE", 4076 " stdout Send output to stdout", 4077 " stderr Send output to stderr", 4078 " off Disable tracing", 4079 " --expanded Expand query parameters", 4080#ifdef SQLITE_ENABLE_NORMALIZE 4081 " --normalized Normal the SQL statements", 4082#endif 4083 " --plain Show SQL as it is input", 4084 " --stmt Trace statement execution (SQLITE_TRACE_STMT)", 4085 " --profile Profile statements (SQLITE_TRACE_PROFILE)", 4086 " --row Trace each row (SQLITE_TRACE_ROW)", 4087 " --close Trace connection close (SQLITE_TRACE_CLOSE)", 4088#endif /* SQLITE_OMIT_TRACE */ 4089#ifdef SQLITE_DEBUG 4090 ".unmodule NAME ... Unregister virtual table modules", 4091 " --allexcept Unregister everything except those named", 4092#endif 4093 ".vfsinfo ?AUX? Information about the top-level VFS", 4094 ".vfslist List all available VFSes", 4095 ".vfsname ?AUX? Print the name of the VFS stack", 4096 ".width NUM1 NUM2 ... Set minimum column widths for columnar output", 4097 " Negative values right-justify", 4098}; 4099 4100/* 4101** Output help text. 4102** 4103** zPattern describes the set of commands for which help text is provided. 4104** If zPattern is NULL, then show all commands, but only give a one-line 4105** description of each. 4106** 4107** Return the number of matches. 4108*/ 4109static int showHelp(FILE *out, const char *zPattern){ 4110 int i = 0; 4111 int j = 0; 4112 int n = 0; 4113 char *zPat; 4114 if( zPattern==0 4115 || zPattern[0]=='0' 4116 || strcmp(zPattern,"-a")==0 4117 || strcmp(zPattern,"-all")==0 4118 || strcmp(zPattern,"--all")==0 4119 ){ 4120 /* Show all commands, but only one line per command */ 4121 if( zPattern==0 ) zPattern = ""; 4122 for(i=0; i<ArraySize(azHelp); i++){ 4123 if( azHelp[i][0]=='.' || zPattern[0] ){ 4124 utf8_printf(out, "%s\n", azHelp[i]); 4125 n++; 4126 } 4127 } 4128 }else{ 4129 /* Look for commands that for which zPattern is an exact prefix */ 4130 zPat = sqlite3_mprintf(".%s*", zPattern); 4131 for(i=0; i<ArraySize(azHelp); i++){ 4132 if( sqlite3_strglob(zPat, azHelp[i])==0 ){ 4133 utf8_printf(out, "%s\n", azHelp[i]); 4134 j = i+1; 4135 n++; 4136 } 4137 } 4138 sqlite3_free(zPat); 4139 if( n ){ 4140 if( n==1 ){ 4141 /* when zPattern is a prefix of exactly one command, then include the 4142 ** details of that command, which should begin at offset j */ 4143 while( j<ArraySize(azHelp)-1 && azHelp[j][0]!='.' ){ 4144 utf8_printf(out, "%s\n", azHelp[j]); 4145 j++; 4146 } 4147 } 4148 return n; 4149 } 4150 /* Look for commands that contain zPattern anywhere. Show the complete 4151 ** text of all commands that match. */ 4152 zPat = sqlite3_mprintf("%%%s%%", zPattern); 4153 for(i=0; i<ArraySize(azHelp); i++){ 4154 if( azHelp[i][0]=='.' ) j = i; 4155 if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){ 4156 utf8_printf(out, "%s\n", azHelp[j]); 4157 while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]!='.' ){ 4158 j++; 4159 utf8_printf(out, "%s\n", azHelp[j]); 4160 } 4161 i = j; 4162 n++; 4163 } 4164 } 4165 sqlite3_free(zPat); 4166 } 4167 return n; 4168} 4169 4170/* Forward reference */ 4171static int process_input(ShellState *p); 4172 4173/* 4174** Read the content of file zName into memory obtained from sqlite3_malloc64() 4175** and return a pointer to the buffer. The caller is responsible for freeing 4176** the memory. 4177** 4178** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes 4179** read. 4180** 4181** For convenience, a nul-terminator byte is always appended to the data read 4182** from the file before the buffer is returned. This byte is not included in 4183** the final value of (*pnByte), if applicable. 4184** 4185** NULL is returned if any error is encountered. The final value of *pnByte 4186** is undefined in this case. 4187*/ 4188static char *readFile(const char *zName, int *pnByte){ 4189 FILE *in = fopen(zName, "rb"); 4190 long nIn; 4191 size_t nRead; 4192 char *pBuf; 4193 if( in==0 ) return 0; 4194 fseek(in, 0, SEEK_END); 4195 nIn = ftell(in); 4196 rewind(in); 4197 pBuf = sqlite3_malloc64( nIn+1 ); 4198 if( pBuf==0 ){ fclose(in); return 0; } 4199 nRead = fread(pBuf, nIn, 1, in); 4200 fclose(in); 4201 if( nRead!=1 ){ 4202 sqlite3_free(pBuf); 4203 return 0; 4204 } 4205 pBuf[nIn] = 0; 4206 if( pnByte ) *pnByte = nIn; 4207 return pBuf; 4208} 4209 4210#if defined(SQLITE_ENABLE_SESSION) 4211/* 4212** Close a single OpenSession object and release all of its associated 4213** resources. 4214*/ 4215static void session_close(OpenSession *pSession){ 4216 int i; 4217 sqlite3session_delete(pSession->p); 4218 sqlite3_free(pSession->zName); 4219 for(i=0; i<pSession->nFilter; i++){ 4220 sqlite3_free(pSession->azFilter[i]); 4221 } 4222 sqlite3_free(pSession->azFilter); 4223 memset(pSession, 0, sizeof(OpenSession)); 4224} 4225#endif 4226 4227/* 4228** Close all OpenSession objects and release all associated resources. 4229*/ 4230#if defined(SQLITE_ENABLE_SESSION) 4231static void session_close_all(ShellState *p){ 4232 int i; 4233 for(i=0; i<p->nSession; i++){ 4234 session_close(&p->aSession[i]); 4235 } 4236 p->nSession = 0; 4237} 4238#else 4239# define session_close_all(X) 4240#endif 4241 4242/* 4243** Implementation of the xFilter function for an open session. Omit 4244** any tables named by ".session filter" but let all other table through. 4245*/ 4246#if defined(SQLITE_ENABLE_SESSION) 4247static int session_filter(void *pCtx, const char *zTab){ 4248 OpenSession *pSession = (OpenSession*)pCtx; 4249 int i; 4250 for(i=0; i<pSession->nFilter; i++){ 4251 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0; 4252 } 4253 return 1; 4254} 4255#endif 4256 4257/* 4258** Try to deduce the type of file for zName based on its content. Return 4259** one of the SHELL_OPEN_* constants. 4260** 4261** If the file does not exist or is empty but its name looks like a ZIP 4262** archive and the dfltZip flag is true, then assume it is a ZIP archive. 4263** Otherwise, assume an ordinary database regardless of the filename if 4264** the type cannot be determined from content. 4265*/ 4266int deduceDatabaseType(const char *zName, int dfltZip){ 4267 FILE *f = fopen(zName, "rb"); 4268 size_t n; 4269 int rc = SHELL_OPEN_UNSPEC; 4270 char zBuf[100]; 4271 if( f==0 ){ 4272 if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 4273 return SHELL_OPEN_ZIPFILE; 4274 }else{ 4275 return SHELL_OPEN_NORMAL; 4276 } 4277 } 4278 n = fread(zBuf, 16, 1, f); 4279 if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){ 4280 fclose(f); 4281 return SHELL_OPEN_NORMAL; 4282 } 4283 fseek(f, -25, SEEK_END); 4284 n = fread(zBuf, 25, 1, f); 4285 if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){ 4286 rc = SHELL_OPEN_APPENDVFS; 4287 }else{ 4288 fseek(f, -22, SEEK_END); 4289 n = fread(zBuf, 22, 1, f); 4290 if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05 4291 && zBuf[3]==0x06 ){ 4292 rc = SHELL_OPEN_ZIPFILE; 4293 }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 4294 rc = SHELL_OPEN_ZIPFILE; 4295 } 4296 } 4297 fclose(f); 4298 return rc; 4299} 4300 4301#ifdef SQLITE_ENABLE_DESERIALIZE 4302/* 4303** Reconstruct an in-memory database using the output from the "dbtotxt" 4304** program. Read content from the file in p->zDbFilename. If p->zDbFilename 4305** is 0, then read from standard input. 4306*/ 4307static unsigned char *readHexDb(ShellState *p, int *pnData){ 4308 unsigned char *a = 0; 4309 int nLine; 4310 int n = 0; 4311 int pgsz = 0; 4312 int iOffset = 0; 4313 int j, k; 4314 int rc; 4315 FILE *in; 4316 unsigned int x[16]; 4317 char zLine[1000]; 4318 if( p->zDbFilename ){ 4319 in = fopen(p->zDbFilename, "r"); 4320 if( in==0 ){ 4321 utf8_printf(stderr, "cannot open \"%s\" for reading\n", p->zDbFilename); 4322 return 0; 4323 } 4324 nLine = 0; 4325 }else{ 4326 in = p->in; 4327 nLine = p->lineno; 4328 if( in==0 ) in = stdin; 4329 } 4330 *pnData = 0; 4331 nLine++; 4332 if( fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error; 4333 rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz); 4334 if( rc!=2 ) goto readHexDb_error; 4335 if( n<0 ) goto readHexDb_error; 4336 if( pgsz<512 || pgsz>65536 || (pgsz&(pgsz-1))!=0 ) goto readHexDb_error; 4337 n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */ 4338 a = sqlite3_malloc( n ? n : 1 ); 4339 if( a==0 ){ 4340 utf8_printf(stderr, "Out of memory!\n"); 4341 goto readHexDb_error; 4342 } 4343 memset(a, 0, n); 4344 if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){ 4345 utf8_printf(stderr, "invalid pagesize\n"); 4346 goto readHexDb_error; 4347 } 4348 for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){ 4349 rc = sscanf(zLine, "| page %d offset %d", &j, &k); 4350 if( rc==2 ){ 4351 iOffset = k; 4352 continue; 4353 } 4354 if( strncmp(zLine, "| end ", 6)==0 ){ 4355 break; 4356 } 4357 rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", 4358 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7], 4359 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]); 4360 if( rc==17 ){ 4361 k = iOffset+j; 4362 if( k+16<=n ){ 4363 int ii; 4364 for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff; 4365 } 4366 } 4367 } 4368 *pnData = n; 4369 if( in!=p->in ){ 4370 fclose(in); 4371 }else{ 4372 p->lineno = nLine; 4373 } 4374 return a; 4375 4376readHexDb_error: 4377 if( in!=p->in ){ 4378 fclose(in); 4379 }else{ 4380 while( fgets(zLine, sizeof(zLine), p->in)!=0 ){ 4381 nLine++; 4382 if(strncmp(zLine, "| end ", 6)==0 ) break; 4383 } 4384 p->lineno = nLine; 4385 } 4386 sqlite3_free(a); 4387 utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine); 4388 return 0; 4389} 4390#endif /* SQLITE_ENABLE_DESERIALIZE */ 4391 4392/* 4393** Scalar function "shell_int32". The first argument to this function 4394** must be a blob. The second a non-negative integer. This function 4395** reads and returns a 32-bit big-endian integer from byte 4396** offset (4*<arg2>) of the blob. 4397*/ 4398static void shellInt32( 4399 sqlite3_context *context, 4400 int argc, 4401 sqlite3_value **argv 4402){ 4403 const unsigned char *pBlob; 4404 int nBlob; 4405 int iInt; 4406 4407 UNUSED_PARAMETER(argc); 4408 nBlob = sqlite3_value_bytes(argv[0]); 4409 pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]); 4410 iInt = sqlite3_value_int(argv[1]); 4411 4412 if( iInt>=0 && (iInt+1)*4<=nBlob ){ 4413 const unsigned char *a = &pBlob[iInt*4]; 4414 sqlite3_int64 iVal = ((sqlite3_int64)a[0]<<24) 4415 + ((sqlite3_int64)a[1]<<16) 4416 + ((sqlite3_int64)a[2]<< 8) 4417 + ((sqlite3_int64)a[3]<< 0); 4418 sqlite3_result_int64(context, iVal); 4419 } 4420} 4421 4422/* 4423** Scalar function "shell_idquote(X)" returns string X quoted as an identifier, 4424** using "..." with internal double-quote characters doubled. 4425*/ 4426static void shellIdQuote( 4427 sqlite3_context *context, 4428 int argc, 4429 sqlite3_value **argv 4430){ 4431 const char *zName = (const char*)sqlite3_value_text(argv[0]); 4432 UNUSED_PARAMETER(argc); 4433 if( zName ){ 4434 char *z = sqlite3_mprintf("\"%w\"", zName); 4435 sqlite3_result_text(context, z, -1, sqlite3_free); 4436 } 4437} 4438 4439/* 4440** Scalar function "usleep(X)" invokes sqlite3_sleep(X) and returns X. 4441*/ 4442static void shellUSleepFunc( 4443 sqlite3_context *context, 4444 int argcUnused, 4445 sqlite3_value **argv 4446){ 4447 int sleep = sqlite3_value_int(argv[0]); 4448 (void)argcUnused; 4449 sqlite3_sleep(sleep/1000); 4450 sqlite3_result_int(context, sleep); 4451} 4452 4453/* 4454** Scalar function "shell_escape_crnl" used by the .recover command. 4455** The argument passed to this function is the output of built-in 4456** function quote(). If the first character of the input is "'", 4457** indicating that the value passed to quote() was a text value, 4458** then this function searches the input for "\n" and "\r" characters 4459** and adds a wrapper similar to the following: 4460** 4461** replace(replace(<input>, '\n', char(10), '\r', char(13)); 4462** 4463** Or, if the first character of the input is not "'", then a copy 4464** of the input is returned. 4465*/ 4466static void shellEscapeCrnl( 4467 sqlite3_context *context, 4468 int argc, 4469 sqlite3_value **argv 4470){ 4471 const char *zText = (const char*)sqlite3_value_text(argv[0]); 4472 UNUSED_PARAMETER(argc); 4473 if( zText[0]=='\'' ){ 4474 int nText = sqlite3_value_bytes(argv[0]); 4475 int i; 4476 char zBuf1[20]; 4477 char zBuf2[20]; 4478 const char *zNL = 0; 4479 const char *zCR = 0; 4480 int nCR = 0; 4481 int nNL = 0; 4482 4483 for(i=0; zText[i]; i++){ 4484 if( zNL==0 && zText[i]=='\n' ){ 4485 zNL = unused_string(zText, "\\n", "\\012", zBuf1); 4486 nNL = (int)strlen(zNL); 4487 } 4488 if( zCR==0 && zText[i]=='\r' ){ 4489 zCR = unused_string(zText, "\\r", "\\015", zBuf2); 4490 nCR = (int)strlen(zCR); 4491 } 4492 } 4493 4494 if( zNL || zCR ){ 4495 int iOut = 0; 4496 i64 nMax = (nNL > nCR) ? nNL : nCR; 4497 i64 nAlloc = nMax * nText + (nMax+64)*2; 4498 char *zOut = (char*)sqlite3_malloc64(nAlloc); 4499 if( zOut==0 ){ 4500 sqlite3_result_error_nomem(context); 4501 return; 4502 } 4503 4504 if( zNL && zCR ){ 4505 memcpy(&zOut[iOut], "replace(replace(", 16); 4506 iOut += 16; 4507 }else{ 4508 memcpy(&zOut[iOut], "replace(", 8); 4509 iOut += 8; 4510 } 4511 for(i=0; zText[i]; i++){ 4512 if( zText[i]=='\n' ){ 4513 memcpy(&zOut[iOut], zNL, nNL); 4514 iOut += nNL; 4515 }else if( zText[i]=='\r' ){ 4516 memcpy(&zOut[iOut], zCR, nCR); 4517 iOut += nCR; 4518 }else{ 4519 zOut[iOut] = zText[i]; 4520 iOut++; 4521 } 4522 } 4523 4524 if( zNL ){ 4525 memcpy(&zOut[iOut], ",'", 2); iOut += 2; 4526 memcpy(&zOut[iOut], zNL, nNL); iOut += nNL; 4527 memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12; 4528 } 4529 if( zCR ){ 4530 memcpy(&zOut[iOut], ",'", 2); iOut += 2; 4531 memcpy(&zOut[iOut], zCR, nCR); iOut += nCR; 4532 memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12; 4533 } 4534 4535 sqlite3_result_text(context, zOut, iOut, SQLITE_TRANSIENT); 4536 sqlite3_free(zOut); 4537 return; 4538 } 4539 } 4540 4541 sqlite3_result_value(context, argv[0]); 4542} 4543 4544/* Flags for open_db(). 4545** 4546** The default behavior of open_db() is to exit(1) if the database fails to 4547** open. The OPEN_DB_KEEPALIVE flag changes that so that it prints an error 4548** but still returns without calling exit. 4549** 4550** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a 4551** ZIP archive if the file does not exist or is empty and its name matches 4552** the *.zip pattern. 4553*/ 4554#define OPEN_DB_KEEPALIVE 0x001 /* Return after error if true */ 4555#define OPEN_DB_ZIPFILE 0x002 /* Open as ZIP if name matches *.zip */ 4556 4557/* 4558** Make sure the database is open. If it is not, then open it. If 4559** the database fails to open, print an error message and exit. 4560*/ 4561static void open_db(ShellState *p, int openFlags){ 4562 if( p->db==0 ){ 4563 if( p->openMode==SHELL_OPEN_UNSPEC ){ 4564 if( p->zDbFilename==0 || p->zDbFilename[0]==0 ){ 4565 p->openMode = SHELL_OPEN_NORMAL; 4566 }else{ 4567 p->openMode = (u8)deduceDatabaseType(p->zDbFilename, 4568 (openFlags & OPEN_DB_ZIPFILE)!=0); 4569 } 4570 } 4571 switch( p->openMode ){ 4572 case SHELL_OPEN_APPENDVFS: { 4573 sqlite3_open_v2(p->zDbFilename, &p->db, 4574 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, "apndvfs"); 4575 break; 4576 } 4577 case SHELL_OPEN_HEXDB: 4578 case SHELL_OPEN_DESERIALIZE: { 4579 sqlite3_open(0, &p->db); 4580 break; 4581 } 4582 case SHELL_OPEN_ZIPFILE: { 4583 sqlite3_open(":memory:", &p->db); 4584 break; 4585 } 4586 case SHELL_OPEN_READONLY: { 4587 sqlite3_open_v2(p->zDbFilename, &p->db, 4588 SQLITE_OPEN_READONLY|p->openFlags, 0); 4589 break; 4590 } 4591 case SHELL_OPEN_UNSPEC: 4592 case SHELL_OPEN_NORMAL: { 4593 sqlite3_open_v2(p->zDbFilename, &p->db, 4594 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, 0); 4595 break; 4596 } 4597 } 4598 globalDb = p->db; 4599 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){ 4600 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n", 4601 p->zDbFilename, sqlite3_errmsg(p->db)); 4602 if( openFlags & OPEN_DB_KEEPALIVE ){ 4603 sqlite3_open(":memory:", &p->db); 4604 return; 4605 } 4606 exit(1); 4607 } 4608#ifndef SQLITE_OMIT_LOAD_EXTENSION 4609 sqlite3_enable_load_extension(p->db, 1); 4610#endif 4611 sqlite3_fileio_init(p->db, 0, 0); 4612 sqlite3_shathree_init(p->db, 0, 0); 4613 sqlite3_completion_init(p->db, 0, 0); 4614 sqlite3_uint_init(p->db, 0, 0); 4615 sqlite3_decimal_init(p->db, 0, 0); 4616 sqlite3_ieee_init(p->db, 0, 0); 4617 sqlite3_series_init(p->db, 0, 0); 4618#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 4619 sqlite3_dbdata_init(p->db, 0, 0); 4620#endif 4621#ifdef SQLITE_HAVE_ZLIB 4622 sqlite3_zipfile_init(p->db, 0, 0); 4623 sqlite3_sqlar_init(p->db, 0, 0); 4624#endif 4625 sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0, 4626 shellAddSchemaName, 0, 0); 4627 sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, 0, 4628 shellModuleSchema, 0, 0); 4629 sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p, 4630 shellPutsFunc, 0, 0); 4631 sqlite3_create_function(p->db, "shell_escape_crnl", 1, SQLITE_UTF8, 0, 4632 shellEscapeCrnl, 0, 0); 4633 sqlite3_create_function(p->db, "shell_int32", 2, SQLITE_UTF8, 0, 4634 shellInt32, 0, 0); 4635 sqlite3_create_function(p->db, "shell_idquote", 1, SQLITE_UTF8, 0, 4636 shellIdQuote, 0, 0); 4637 sqlite3_create_function(p->db, "usleep",1,SQLITE_UTF8,0, 4638 shellUSleepFunc, 0, 0); 4639#ifndef SQLITE_NOHAVE_SYSTEM 4640 sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0, 4641 editFunc, 0, 0); 4642 sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0, 4643 editFunc, 0, 0); 4644#endif 4645 if( p->openMode==SHELL_OPEN_ZIPFILE ){ 4646 char *zSql = sqlite3_mprintf( 4647 "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", p->zDbFilename); 4648 sqlite3_exec(p->db, zSql, 0, 0, 0); 4649 sqlite3_free(zSql); 4650 } 4651#ifdef SQLITE_ENABLE_DESERIALIZE 4652 else 4653 if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){ 4654 int rc; 4655 int nData = 0; 4656 unsigned char *aData; 4657 if( p->openMode==SHELL_OPEN_DESERIALIZE ){ 4658 aData = (unsigned char*)readFile(p->zDbFilename, &nData); 4659 }else{ 4660 aData = readHexDb(p, &nData); 4661 if( aData==0 ){ 4662 return; 4663 } 4664 } 4665 rc = sqlite3_deserialize(p->db, "main", aData, nData, nData, 4666 SQLITE_DESERIALIZE_RESIZEABLE | 4667 SQLITE_DESERIALIZE_FREEONCLOSE); 4668 if( rc ){ 4669 utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc); 4670 } 4671 if( p->szMax>0 ){ 4672 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax); 4673 } 4674 } 4675#endif 4676 } 4677} 4678 4679/* 4680** Attempt to close the databaes connection. Report errors. 4681*/ 4682void close_db(sqlite3 *db){ 4683 int rc = sqlite3_close(db); 4684 if( rc ){ 4685 utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n", 4686 rc, sqlite3_errmsg(db)); 4687 } 4688} 4689 4690#if HAVE_READLINE || HAVE_EDITLINE 4691/* 4692** Readline completion callbacks 4693*/ 4694static char *readline_completion_generator(const char *text, int state){ 4695 static sqlite3_stmt *pStmt = 0; 4696 char *zRet; 4697 if( state==0 ){ 4698 char *zSql; 4699 sqlite3_finalize(pStmt); 4700 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 4701 " FROM completion(%Q) ORDER BY 1", text); 4702 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 4703 sqlite3_free(zSql); 4704 } 4705 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 4706 zRet = strdup((const char*)sqlite3_column_text(pStmt, 0)); 4707 }else{ 4708 sqlite3_finalize(pStmt); 4709 pStmt = 0; 4710 zRet = 0; 4711 } 4712 return zRet; 4713} 4714static char **readline_completion(const char *zText, int iStart, int iEnd){ 4715 rl_attempted_completion_over = 1; 4716 return rl_completion_matches(zText, readline_completion_generator); 4717} 4718 4719#elif HAVE_LINENOISE 4720/* 4721** Linenoise completion callback 4722*/ 4723static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){ 4724 int nLine = strlen30(zLine); 4725 int i, iStart; 4726 sqlite3_stmt *pStmt = 0; 4727 char *zSql; 4728 char zBuf[1000]; 4729 4730 if( nLine>sizeof(zBuf)-30 ) return; 4731 if( zLine[0]=='.' || zLine[0]=='#') return; 4732 for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){} 4733 if( i==nLine-1 ) return; 4734 iStart = i+1; 4735 memcpy(zBuf, zLine, iStart); 4736 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 4737 " FROM completion(%Q,%Q) ORDER BY 1", 4738 &zLine[iStart], zLine); 4739 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 4740 sqlite3_free(zSql); 4741 sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */ 4742 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 4743 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0); 4744 int nCompletion = sqlite3_column_bytes(pStmt, 0); 4745 if( iStart+nCompletion < sizeof(zBuf)-1 ){ 4746 memcpy(zBuf+iStart, zCompletion, nCompletion+1); 4747 linenoiseAddCompletion(lc, zBuf); 4748 } 4749 } 4750 sqlite3_finalize(pStmt); 4751} 4752#endif 4753 4754/* 4755** Do C-language style dequoting. 4756** 4757** \a -> alarm 4758** \b -> backspace 4759** \t -> tab 4760** \n -> newline 4761** \v -> vertical tab 4762** \f -> form feed 4763** \r -> carriage return 4764** \s -> space 4765** \" -> " 4766** \' -> ' 4767** \\ -> backslash 4768** \NNN -> ascii character NNN in octal 4769*/ 4770static void resolve_backslashes(char *z){ 4771 int i, j; 4772 char c; 4773 while( *z && *z!='\\' ) z++; 4774 for(i=j=0; (c = z[i])!=0; i++, j++){ 4775 if( c=='\\' && z[i+1]!=0 ){ 4776 c = z[++i]; 4777 if( c=='a' ){ 4778 c = '\a'; 4779 }else if( c=='b' ){ 4780 c = '\b'; 4781 }else if( c=='t' ){ 4782 c = '\t'; 4783 }else if( c=='n' ){ 4784 c = '\n'; 4785 }else if( c=='v' ){ 4786 c = '\v'; 4787 }else if( c=='f' ){ 4788 c = '\f'; 4789 }else if( c=='r' ){ 4790 c = '\r'; 4791 }else if( c=='"' ){ 4792 c = '"'; 4793 }else if( c=='\'' ){ 4794 c = '\''; 4795 }else if( c=='\\' ){ 4796 c = '\\'; 4797 }else if( c>='0' && c<='7' ){ 4798 c -= '0'; 4799 if( z[i+1]>='0' && z[i+1]<='7' ){ 4800 i++; 4801 c = (c<<3) + z[i] - '0'; 4802 if( z[i+1]>='0' && z[i+1]<='7' ){ 4803 i++; 4804 c = (c<<3) + z[i] - '0'; 4805 } 4806 } 4807 } 4808 } 4809 z[j] = c; 4810 } 4811 if( j<i ) z[j] = 0; 4812} 4813 4814/* 4815** Interpret zArg as either an integer or a boolean value. Return 1 or 0 4816** for TRUE and FALSE. Return the integer value if appropriate. 4817*/ 4818static int booleanValue(const char *zArg){ 4819 int i; 4820 if( zArg[0]=='0' && zArg[1]=='x' ){ 4821 for(i=2; hexDigitValue(zArg[i])>=0; i++){} 4822 }else{ 4823 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){} 4824 } 4825 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff); 4826 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){ 4827 return 1; 4828 } 4829 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){ 4830 return 0; 4831 } 4832 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", 4833 zArg); 4834 return 0; 4835} 4836 4837/* 4838** Set or clear a shell flag according to a boolean value. 4839*/ 4840static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){ 4841 if( booleanValue(zArg) ){ 4842 ShellSetFlag(p, mFlag); 4843 }else{ 4844 ShellClearFlag(p, mFlag); 4845 } 4846} 4847 4848/* 4849** Close an output file, assuming it is not stderr or stdout 4850*/ 4851static void output_file_close(FILE *f){ 4852 if( f && f!=stdout && f!=stderr ) fclose(f); 4853} 4854 4855/* 4856** Try to open an output file. The names "stdout" and "stderr" are 4857** recognized and do the right thing. NULL is returned if the output 4858** filename is "off". 4859*/ 4860static FILE *output_file_open(const char *zFile, int bTextMode){ 4861 FILE *f; 4862 if( strcmp(zFile,"stdout")==0 ){ 4863 f = stdout; 4864 }else if( strcmp(zFile, "stderr")==0 ){ 4865 f = stderr; 4866 }else if( strcmp(zFile, "off")==0 ){ 4867 f = 0; 4868 }else{ 4869 f = fopen(zFile, bTextMode ? "w" : "wb"); 4870 if( f==0 ){ 4871 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 4872 } 4873 } 4874 return f; 4875} 4876 4877#ifndef SQLITE_OMIT_TRACE 4878/* 4879** A routine for handling output from sqlite3_trace(). 4880*/ 4881static int sql_trace_callback( 4882 unsigned mType, /* The trace type */ 4883 void *pArg, /* The ShellState pointer */ 4884 void *pP, /* Usually a pointer to sqlite_stmt */ 4885 void *pX /* Auxiliary output */ 4886){ 4887 ShellState *p = (ShellState*)pArg; 4888 sqlite3_stmt *pStmt; 4889 const char *zSql; 4890 int nSql; 4891 if( p->traceOut==0 ) return 0; 4892 if( mType==SQLITE_TRACE_CLOSE ){ 4893 utf8_printf(p->traceOut, "-- closing database connection\n"); 4894 return 0; 4895 } 4896 if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){ 4897 zSql = (const char*)pX; 4898 }else{ 4899 pStmt = (sqlite3_stmt*)pP; 4900 switch( p->eTraceType ){ 4901 case SHELL_TRACE_EXPANDED: { 4902 zSql = sqlite3_expanded_sql(pStmt); 4903 break; 4904 } 4905#ifdef SQLITE_ENABLE_NORMALIZE 4906 case SHELL_TRACE_NORMALIZED: { 4907 zSql = sqlite3_normalized_sql(pStmt); 4908 break; 4909 } 4910#endif 4911 default: { 4912 zSql = sqlite3_sql(pStmt); 4913 break; 4914 } 4915 } 4916 } 4917 if( zSql==0 ) return 0; 4918 nSql = strlen30(zSql); 4919 while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; } 4920 switch( mType ){ 4921 case SQLITE_TRACE_ROW: 4922 case SQLITE_TRACE_STMT: { 4923 utf8_printf(p->traceOut, "%.*s;\n", nSql, zSql); 4924 break; 4925 } 4926 case SQLITE_TRACE_PROFILE: { 4927 sqlite3_int64 nNanosec = *(sqlite3_int64*)pX; 4928 utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", nSql, zSql, nNanosec); 4929 break; 4930 } 4931 } 4932 return 0; 4933} 4934#endif 4935 4936/* 4937** A no-op routine that runs with the ".breakpoint" doc-command. This is 4938** a useful spot to set a debugger breakpoint. 4939*/ 4940static void test_breakpoint(void){ 4941 static int nCall = 0; 4942 nCall++; 4943} 4944 4945/* 4946** An object used to read a CSV and other files for import. 4947*/ 4948typedef struct ImportCtx ImportCtx; 4949struct ImportCtx { 4950 const char *zFile; /* Name of the input file */ 4951 FILE *in; /* Read the CSV text from this input stream */ 4952 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close in */ 4953 char *z; /* Accumulated text for a field */ 4954 int n; /* Number of bytes in z */ 4955 int nAlloc; /* Space allocated for z[] */ 4956 int nLine; /* Current line number */ 4957 int nRow; /* Number of rows imported */ 4958 int nErr; /* Number of errors encountered */ 4959 int bNotFirst; /* True if one or more bytes already read */ 4960 int cTerm; /* Character that terminated the most recent field */ 4961 int cColSep; /* The column separator character. (Usually ",") */ 4962 int cRowSep; /* The row separator character. (Usually "\n") */ 4963}; 4964 4965/* Clean up resourced used by an ImportCtx */ 4966static void import_cleanup(ImportCtx *p){ 4967 if( p->in!=0 && p->xCloser!=0 ){ 4968 p->xCloser(p->in); 4969 p->in = 0; 4970 } 4971 sqlite3_free(p->z); 4972 p->z = 0; 4973} 4974 4975/* Append a single byte to z[] */ 4976static void import_append_char(ImportCtx *p, int c){ 4977 if( p->n+1>=p->nAlloc ){ 4978 p->nAlloc += p->nAlloc + 100; 4979 p->z = sqlite3_realloc64(p->z, p->nAlloc); 4980 if( p->z==0 ) shell_out_of_memory(); 4981 } 4982 p->z[p->n++] = (char)c; 4983} 4984 4985/* Read a single field of CSV text. Compatible with rfc4180 and extended 4986** with the option of having a separator other than ",". 4987** 4988** + Input comes from p->in. 4989** + Store results in p->z of length p->n. Space to hold p->z comes 4990** from sqlite3_malloc64(). 4991** + Use p->cSep as the column separator. The default is ",". 4992** + Use p->rSep as the row separator. The default is "\n". 4993** + Keep track of the line number in p->nLine. 4994** + Store the character that terminates the field in p->cTerm. Store 4995** EOF on end-of-file. 4996** + Report syntax errors on stderr 4997*/ 4998static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){ 4999 int c; 5000 int cSep = p->cColSep; 5001 int rSep = p->cRowSep; 5002 p->n = 0; 5003 c = fgetc(p->in); 5004 if( c==EOF || seenInterrupt ){ 5005 p->cTerm = EOF; 5006 return 0; 5007 } 5008 if( c=='"' ){ 5009 int pc, ppc; 5010 int startLine = p->nLine; 5011 int cQuote = c; 5012 pc = ppc = 0; 5013 while( 1 ){ 5014 c = fgetc(p->in); 5015 if( c==rSep ) p->nLine++; 5016 if( c==cQuote ){ 5017 if( pc==cQuote ){ 5018 pc = 0; 5019 continue; 5020 } 5021 } 5022 if( (c==cSep && pc==cQuote) 5023 || (c==rSep && pc==cQuote) 5024 || (c==rSep && pc=='\r' && ppc==cQuote) 5025 || (c==EOF && pc==cQuote) 5026 ){ 5027 do{ p->n--; }while( p->z[p->n]!=cQuote ); 5028 p->cTerm = c; 5029 break; 5030 } 5031 if( pc==cQuote && c!='\r' ){ 5032 utf8_printf(stderr, "%s:%d: unescaped %c character\n", 5033 p->zFile, p->nLine, cQuote); 5034 } 5035 if( c==EOF ){ 5036 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n", 5037 p->zFile, startLine, cQuote); 5038 p->cTerm = c; 5039 break; 5040 } 5041 import_append_char(p, c); 5042 ppc = pc; 5043 pc = c; 5044 } 5045 }else{ 5046 /* If this is the first field being parsed and it begins with the 5047 ** UTF-8 BOM (0xEF BB BF) then skip the BOM */ 5048 if( (c&0xff)==0xef && p->bNotFirst==0 ){ 5049 import_append_char(p, c); 5050 c = fgetc(p->in); 5051 if( (c&0xff)==0xbb ){ 5052 import_append_char(p, c); 5053 c = fgetc(p->in); 5054 if( (c&0xff)==0xbf ){ 5055 p->bNotFirst = 1; 5056 p->n = 0; 5057 return csv_read_one_field(p); 5058 } 5059 } 5060 } 5061 while( c!=EOF && c!=cSep && c!=rSep ){ 5062 import_append_char(p, c); 5063 c = fgetc(p->in); 5064 } 5065 if( c==rSep ){ 5066 p->nLine++; 5067 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--; 5068 } 5069 p->cTerm = c; 5070 } 5071 if( p->z ) p->z[p->n] = 0; 5072 p->bNotFirst = 1; 5073 return p->z; 5074} 5075 5076/* Read a single field of ASCII delimited text. 5077** 5078** + Input comes from p->in. 5079** + Store results in p->z of length p->n. Space to hold p->z comes 5080** from sqlite3_malloc64(). 5081** + Use p->cSep as the column separator. The default is "\x1F". 5082** + Use p->rSep as the row separator. The default is "\x1E". 5083** + Keep track of the row number in p->nLine. 5084** + Store the character that terminates the field in p->cTerm. Store 5085** EOF on end-of-file. 5086** + Report syntax errors on stderr 5087*/ 5088static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){ 5089 int c; 5090 int cSep = p->cColSep; 5091 int rSep = p->cRowSep; 5092 p->n = 0; 5093 c = fgetc(p->in); 5094 if( c==EOF || seenInterrupt ){ 5095 p->cTerm = EOF; 5096 return 0; 5097 } 5098 while( c!=EOF && c!=cSep && c!=rSep ){ 5099 import_append_char(p, c); 5100 c = fgetc(p->in); 5101 } 5102 if( c==rSep ){ 5103 p->nLine++; 5104 } 5105 p->cTerm = c; 5106 if( p->z ) p->z[p->n] = 0; 5107 return p->z; 5108} 5109 5110/* 5111** Try to transfer data for table zTable. If an error is seen while 5112** moving forward, try to go backwards. The backwards movement won't 5113** work for WITHOUT ROWID tables. 5114*/ 5115static void tryToCloneData( 5116 ShellState *p, 5117 sqlite3 *newDb, 5118 const char *zTable 5119){ 5120 sqlite3_stmt *pQuery = 0; 5121 sqlite3_stmt *pInsert = 0; 5122 char *zQuery = 0; 5123 char *zInsert = 0; 5124 int rc; 5125 int i, j, n; 5126 int nTable = strlen30(zTable); 5127 int k = 0; 5128 int cnt = 0; 5129 const int spinRate = 10000; 5130 5131 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); 5132 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 5133 if( rc ){ 5134 utf8_printf(stderr, "Error %d: %s on [%s]\n", 5135 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 5136 zQuery); 5137 goto end_data_xfer; 5138 } 5139 n = sqlite3_column_count(pQuery); 5140 zInsert = sqlite3_malloc64(200 + nTable + n*3); 5141 if( zInsert==0 ) shell_out_of_memory(); 5142 sqlite3_snprintf(200+nTable,zInsert, 5143 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable); 5144 i = strlen30(zInsert); 5145 for(j=1; j<n; j++){ 5146 memcpy(zInsert+i, ",?", 2); 5147 i += 2; 5148 } 5149 memcpy(zInsert+i, ");", 3); 5150 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0); 5151 if( rc ){ 5152 utf8_printf(stderr, "Error %d: %s on [%s]\n", 5153 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), 5154 zQuery); 5155 goto end_data_xfer; 5156 } 5157 for(k=0; k<2; k++){ 5158 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 5159 for(i=0; i<n; i++){ 5160 switch( sqlite3_column_type(pQuery, i) ){ 5161 case SQLITE_NULL: { 5162 sqlite3_bind_null(pInsert, i+1); 5163 break; 5164 } 5165 case SQLITE_INTEGER: { 5166 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i)); 5167 break; 5168 } 5169 case SQLITE_FLOAT: { 5170 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i)); 5171 break; 5172 } 5173 case SQLITE_TEXT: { 5174 sqlite3_bind_text(pInsert, i+1, 5175 (const char*)sqlite3_column_text(pQuery,i), 5176 -1, SQLITE_STATIC); 5177 break; 5178 } 5179 case SQLITE_BLOB: { 5180 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i), 5181 sqlite3_column_bytes(pQuery,i), 5182 SQLITE_STATIC); 5183 break; 5184 } 5185 } 5186 } /* End for */ 5187 rc = sqlite3_step(pInsert); 5188 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){ 5189 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb), 5190 sqlite3_errmsg(newDb)); 5191 } 5192 sqlite3_reset(pInsert); 5193 cnt++; 5194 if( (cnt%spinRate)==0 ){ 5195 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]); 5196 fflush(stdout); 5197 } 5198 } /* End while */ 5199 if( rc==SQLITE_DONE ) break; 5200 sqlite3_finalize(pQuery); 5201 sqlite3_free(zQuery); 5202 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;", 5203 zTable); 5204 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 5205 if( rc ){ 5206 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable); 5207 break; 5208 } 5209 } /* End for(k=0...) */ 5210 5211end_data_xfer: 5212 sqlite3_finalize(pQuery); 5213 sqlite3_finalize(pInsert); 5214 sqlite3_free(zQuery); 5215 sqlite3_free(zInsert); 5216} 5217 5218 5219/* 5220** Try to transfer all rows of the schema that match zWhere. For 5221** each row, invoke xForEach() on the object defined by that row. 5222** If an error is encountered while moving forward through the 5223** sqlite_schema table, try again moving backwards. 5224*/ 5225static void tryToCloneSchema( 5226 ShellState *p, 5227 sqlite3 *newDb, 5228 const char *zWhere, 5229 void (*xForEach)(ShellState*,sqlite3*,const char*) 5230){ 5231 sqlite3_stmt *pQuery = 0; 5232 char *zQuery = 0; 5233 int rc; 5234 const unsigned char *zName; 5235 const unsigned char *zSql; 5236 char *zErrMsg = 0; 5237 5238 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema" 5239 " WHERE %s", zWhere); 5240 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 5241 if( rc ){ 5242 utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 5243 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 5244 zQuery); 5245 goto end_schema_xfer; 5246 } 5247 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 5248 zName = sqlite3_column_text(pQuery, 0); 5249 zSql = sqlite3_column_text(pQuery, 1); 5250 printf("%s... ", zName); fflush(stdout); 5251 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 5252 if( zErrMsg ){ 5253 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 5254 sqlite3_free(zErrMsg); 5255 zErrMsg = 0; 5256 } 5257 if( xForEach ){ 5258 xForEach(p, newDb, (const char*)zName); 5259 } 5260 printf("done\n"); 5261 } 5262 if( rc!=SQLITE_DONE ){ 5263 sqlite3_finalize(pQuery); 5264 sqlite3_free(zQuery); 5265 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema" 5266 " WHERE %s ORDER BY rowid DESC", zWhere); 5267 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 5268 if( rc ){ 5269 utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 5270 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 5271 zQuery); 5272 goto end_schema_xfer; 5273 } 5274 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 5275 zName = sqlite3_column_text(pQuery, 0); 5276 zSql = sqlite3_column_text(pQuery, 1); 5277 printf("%s... ", zName); fflush(stdout); 5278 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 5279 if( zErrMsg ){ 5280 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 5281 sqlite3_free(zErrMsg); 5282 zErrMsg = 0; 5283 } 5284 if( xForEach ){ 5285 xForEach(p, newDb, (const char*)zName); 5286 } 5287 printf("done\n"); 5288 } 5289 } 5290end_schema_xfer: 5291 sqlite3_finalize(pQuery); 5292 sqlite3_free(zQuery); 5293} 5294 5295/* 5296** Open a new database file named "zNewDb". Try to recover as much information 5297** as possible out of the main database (which might be corrupt) and write it 5298** into zNewDb. 5299*/ 5300static void tryToClone(ShellState *p, const char *zNewDb){ 5301 int rc; 5302 sqlite3 *newDb = 0; 5303 if( access(zNewDb,0)==0 ){ 5304 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb); 5305 return; 5306 } 5307 rc = sqlite3_open(zNewDb, &newDb); 5308 if( rc ){ 5309 utf8_printf(stderr, "Cannot create output database: %s\n", 5310 sqlite3_errmsg(newDb)); 5311 }else{ 5312 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0); 5313 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0); 5314 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData); 5315 tryToCloneSchema(p, newDb, "type!='table'", 0); 5316 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0); 5317 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 5318 } 5319 close_db(newDb); 5320} 5321 5322/* 5323** Change the output file back to stdout. 5324** 5325** If the p->doXdgOpen flag is set, that means the output was being 5326** redirected to a temporary file named by p->zTempFile. In that case, 5327** launch start/open/xdg-open on that temporary file. 5328*/ 5329static void output_reset(ShellState *p){ 5330 if( p->outfile[0]=='|' ){ 5331#ifndef SQLITE_OMIT_POPEN 5332 pclose(p->out); 5333#endif 5334 }else{ 5335 output_file_close(p->out); 5336#ifndef SQLITE_NOHAVE_SYSTEM 5337 if( p->doXdgOpen ){ 5338 const char *zXdgOpenCmd = 5339#if defined(_WIN32) 5340 "start"; 5341#elif defined(__APPLE__) 5342 "open"; 5343#else 5344 "xdg-open"; 5345#endif 5346 char *zCmd; 5347 zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile); 5348 if( system(zCmd) ){ 5349 utf8_printf(stderr, "Failed: [%s]\n", zCmd); 5350 }else{ 5351 /* Give the start/open/xdg-open command some time to get 5352 ** going before we continue, and potential delete the 5353 ** p->zTempFile data file out from under it */ 5354 sqlite3_sleep(2000); 5355 } 5356 sqlite3_free(zCmd); 5357 outputModePop(p); 5358 p->doXdgOpen = 0; 5359 } 5360#endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 5361 } 5362 p->outfile[0] = 0; 5363 p->out = stdout; 5364} 5365 5366/* 5367** Run an SQL command and return the single integer result. 5368*/ 5369static int db_int(ShellState *p, const char *zSql){ 5370 sqlite3_stmt *pStmt; 5371 int res = 0; 5372 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 5373 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ 5374 res = sqlite3_column_int(pStmt,0); 5375 } 5376 sqlite3_finalize(pStmt); 5377 return res; 5378} 5379 5380/* 5381** Convert a 2-byte or 4-byte big-endian integer into a native integer 5382*/ 5383static unsigned int get2byteInt(unsigned char *a){ 5384 return (a[0]<<8) + a[1]; 5385} 5386static unsigned int get4byteInt(unsigned char *a){ 5387 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3]; 5388} 5389 5390/* 5391** Implementation of the ".dbinfo" command. 5392** 5393** Return 1 on error, 2 to exit, and 0 otherwise. 5394*/ 5395static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){ 5396 static const struct { const char *zName; int ofst; } aField[] = { 5397 { "file change counter:", 24 }, 5398 { "database page count:", 28 }, 5399 { "freelist page count:", 36 }, 5400 { "schema cookie:", 40 }, 5401 { "schema format:", 44 }, 5402 { "default cache size:", 48 }, 5403 { "autovacuum top root:", 52 }, 5404 { "incremental vacuum:", 64 }, 5405 { "text encoding:", 56 }, 5406 { "user version:", 60 }, 5407 { "application id:", 68 }, 5408 { "software version:", 96 }, 5409 }; 5410 static const struct { const char *zName; const char *zSql; } aQuery[] = { 5411 { "number of tables:", 5412 "SELECT count(*) FROM %s WHERE type='table'" }, 5413 { "number of indexes:", 5414 "SELECT count(*) FROM %s WHERE type='index'" }, 5415 { "number of triggers:", 5416 "SELECT count(*) FROM %s WHERE type='trigger'" }, 5417 { "number of views:", 5418 "SELECT count(*) FROM %s WHERE type='view'" }, 5419 { "schema size:", 5420 "SELECT total(length(sql)) FROM %s" }, 5421 }; 5422 int i, rc; 5423 unsigned iDataVersion; 5424 char *zSchemaTab; 5425 char *zDb = nArg>=2 ? azArg[1] : "main"; 5426 sqlite3_stmt *pStmt = 0; 5427 unsigned char aHdr[100]; 5428 open_db(p, 0); 5429 if( p->db==0 ) return 1; 5430 rc = sqlite3_prepare_v2(p->db, 5431 "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1", 5432 -1, &pStmt, 0); 5433 if( rc ){ 5434 utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db)); 5435 sqlite3_finalize(pStmt); 5436 return 1; 5437 } 5438 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC); 5439 if( sqlite3_step(pStmt)==SQLITE_ROW 5440 && sqlite3_column_bytes(pStmt,0)>100 5441 ){ 5442 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100); 5443 sqlite3_finalize(pStmt); 5444 }else{ 5445 raw_printf(stderr, "unable to read database header\n"); 5446 sqlite3_finalize(pStmt); 5447 return 1; 5448 } 5449 i = get2byteInt(aHdr+16); 5450 if( i==1 ) i = 65536; 5451 utf8_printf(p->out, "%-20s %d\n", "database page size:", i); 5452 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]); 5453 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]); 5454 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]); 5455 for(i=0; i<ArraySize(aField); i++){ 5456 int ofst = aField[i].ofst; 5457 unsigned int val = get4byteInt(aHdr + ofst); 5458 utf8_printf(p->out, "%-20s %u", aField[i].zName, val); 5459 switch( ofst ){ 5460 case 56: { 5461 if( val==1 ) raw_printf(p->out, " (utf8)"); 5462 if( val==2 ) raw_printf(p->out, " (utf16le)"); 5463 if( val==3 ) raw_printf(p->out, " (utf16be)"); 5464 } 5465 } 5466 raw_printf(p->out, "\n"); 5467 } 5468 if( zDb==0 ){ 5469 zSchemaTab = sqlite3_mprintf("main.sqlite_schema"); 5470 }else if( strcmp(zDb,"temp")==0 ){ 5471 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_schema"); 5472 }else{ 5473 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_schema", zDb); 5474 } 5475 for(i=0; i<ArraySize(aQuery); i++){ 5476 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab); 5477 int val = db_int(p, zSql); 5478 sqlite3_free(zSql); 5479 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val); 5480 } 5481 sqlite3_free(zSchemaTab); 5482 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion); 5483 utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion); 5484 return 0; 5485} 5486 5487/* 5488** Print the current sqlite3_errmsg() value to stderr and return 1. 5489*/ 5490static int shellDatabaseError(sqlite3 *db){ 5491 const char *zErr = sqlite3_errmsg(db); 5492 utf8_printf(stderr, "Error: %s\n", zErr); 5493 return 1; 5494} 5495 5496/* 5497** Compare the pattern in zGlob[] against the text in z[]. Return TRUE 5498** if they match and FALSE (0) if they do not match. 5499** 5500** Globbing rules: 5501** 5502** '*' Matches any sequence of zero or more characters. 5503** 5504** '?' Matches exactly one character. 5505** 5506** [...] Matches one character from the enclosed list of 5507** characters. 5508** 5509** [^...] Matches one character not in the enclosed list. 5510** 5511** '#' Matches any sequence of one or more digits with an 5512** optional + or - sign in front 5513** 5514** ' ' Any span of whitespace matches any other span of 5515** whitespace. 5516** 5517** Extra whitespace at the end of z[] is ignored. 5518*/ 5519static int testcase_glob(const char *zGlob, const char *z){ 5520 int c, c2; 5521 int invert; 5522 int seen; 5523 5524 while( (c = (*(zGlob++)))!=0 ){ 5525 if( IsSpace(c) ){ 5526 if( !IsSpace(*z) ) return 0; 5527 while( IsSpace(*zGlob) ) zGlob++; 5528 while( IsSpace(*z) ) z++; 5529 }else if( c=='*' ){ 5530 while( (c=(*(zGlob++))) == '*' || c=='?' ){ 5531 if( c=='?' && (*(z++))==0 ) return 0; 5532 } 5533 if( c==0 ){ 5534 return 1; 5535 }else if( c=='[' ){ 5536 while( *z && testcase_glob(zGlob-1,z)==0 ){ 5537 z++; 5538 } 5539 return (*z)!=0; 5540 } 5541 while( (c2 = (*(z++)))!=0 ){ 5542 while( c2!=c ){ 5543 c2 = *(z++); 5544 if( c2==0 ) return 0; 5545 } 5546 if( testcase_glob(zGlob,z) ) return 1; 5547 } 5548 return 0; 5549 }else if( c=='?' ){ 5550 if( (*(z++))==0 ) return 0; 5551 }else if( c=='[' ){ 5552 int prior_c = 0; 5553 seen = 0; 5554 invert = 0; 5555 c = *(z++); 5556 if( c==0 ) return 0; 5557 c2 = *(zGlob++); 5558 if( c2=='^' ){ 5559 invert = 1; 5560 c2 = *(zGlob++); 5561 } 5562 if( c2==']' ){ 5563 if( c==']' ) seen = 1; 5564 c2 = *(zGlob++); 5565 } 5566 while( c2 && c2!=']' ){ 5567 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){ 5568 c2 = *(zGlob++); 5569 if( c>=prior_c && c<=c2 ) seen = 1; 5570 prior_c = 0; 5571 }else{ 5572 if( c==c2 ){ 5573 seen = 1; 5574 } 5575 prior_c = c2; 5576 } 5577 c2 = *(zGlob++); 5578 } 5579 if( c2==0 || (seen ^ invert)==0 ) return 0; 5580 }else if( c=='#' ){ 5581 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++; 5582 if( !IsDigit(z[0]) ) return 0; 5583 z++; 5584 while( IsDigit(z[0]) ){ z++; } 5585 }else{ 5586 if( c!=(*(z++)) ) return 0; 5587 } 5588 } 5589 while( IsSpace(*z) ){ z++; } 5590 return *z==0; 5591} 5592 5593 5594/* 5595** Compare the string as a command-line option with either one or two 5596** initial "-" characters. 5597*/ 5598static int optionMatch(const char *zStr, const char *zOpt){ 5599 if( zStr[0]!='-' ) return 0; 5600 zStr++; 5601 if( zStr[0]=='-' ) zStr++; 5602 return strcmp(zStr, zOpt)==0; 5603} 5604 5605/* 5606** Delete a file. 5607*/ 5608int shellDeleteFile(const char *zFilename){ 5609 int rc; 5610#ifdef _WIN32 5611 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename); 5612 rc = _wunlink(z); 5613 sqlite3_free(z); 5614#else 5615 rc = unlink(zFilename); 5616#endif 5617 return rc; 5618} 5619 5620/* 5621** Try to delete the temporary file (if there is one) and free the 5622** memory used to hold the name of the temp file. 5623*/ 5624static void clearTempFile(ShellState *p){ 5625 if( p->zTempFile==0 ) return; 5626 if( p->doXdgOpen ) return; 5627 if( shellDeleteFile(p->zTempFile) ) return; 5628 sqlite3_free(p->zTempFile); 5629 p->zTempFile = 0; 5630} 5631 5632/* 5633** Create a new temp file name with the given suffix. 5634*/ 5635static void newTempFile(ShellState *p, const char *zSuffix){ 5636 clearTempFile(p); 5637 sqlite3_free(p->zTempFile); 5638 p->zTempFile = 0; 5639 if( p->db ){ 5640 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile); 5641 } 5642 if( p->zTempFile==0 ){ 5643 /* If p->db is an in-memory database then the TEMPFILENAME file-control 5644 ** will not work and we will need to fallback to guessing */ 5645 char *zTemp; 5646 sqlite3_uint64 r; 5647 sqlite3_randomness(sizeof(r), &r); 5648 zTemp = getenv("TEMP"); 5649 if( zTemp==0 ) zTemp = getenv("TMP"); 5650 if( zTemp==0 ){ 5651#ifdef _WIN32 5652 zTemp = "\\tmp"; 5653#else 5654 zTemp = "/tmp"; 5655#endif 5656 } 5657 p->zTempFile = sqlite3_mprintf("%s/temp%llx.%s", zTemp, r, zSuffix); 5658 }else{ 5659 p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix); 5660 } 5661 if( p->zTempFile==0 ){ 5662 raw_printf(stderr, "out of memory\n"); 5663 exit(1); 5664 } 5665} 5666 5667 5668/* 5669** The implementation of SQL scalar function fkey_collate_clause(), used 5670** by the ".lint fkey-indexes" command. This scalar function is always 5671** called with four arguments - the parent table name, the parent column name, 5672** the child table name and the child column name. 5673** 5674** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col') 5675** 5676** If either of the named tables or columns do not exist, this function 5677** returns an empty string. An empty string is also returned if both tables 5678** and columns exist but have the same default collation sequence. Or, 5679** if both exist but the default collation sequences are different, this 5680** function returns the string " COLLATE <parent-collation>", where 5681** <parent-collation> is the default collation sequence of the parent column. 5682*/ 5683static void shellFkeyCollateClause( 5684 sqlite3_context *pCtx, 5685 int nVal, 5686 sqlite3_value **apVal 5687){ 5688 sqlite3 *db = sqlite3_context_db_handle(pCtx); 5689 const char *zParent; 5690 const char *zParentCol; 5691 const char *zParentSeq; 5692 const char *zChild; 5693 const char *zChildCol; 5694 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */ 5695 int rc; 5696 5697 assert( nVal==4 ); 5698 zParent = (const char*)sqlite3_value_text(apVal[0]); 5699 zParentCol = (const char*)sqlite3_value_text(apVal[1]); 5700 zChild = (const char*)sqlite3_value_text(apVal[2]); 5701 zChildCol = (const char*)sqlite3_value_text(apVal[3]); 5702 5703 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC); 5704 rc = sqlite3_table_column_metadata( 5705 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0 5706 ); 5707 if( rc==SQLITE_OK ){ 5708 rc = sqlite3_table_column_metadata( 5709 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0 5710 ); 5711 } 5712 5713 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){ 5714 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq); 5715 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT); 5716 sqlite3_free(z); 5717 } 5718} 5719 5720 5721/* 5722** The implementation of dot-command ".lint fkey-indexes". 5723*/ 5724static int lintFkeyIndexes( 5725 ShellState *pState, /* Current shell tool state */ 5726 char **azArg, /* Array of arguments passed to dot command */ 5727 int nArg /* Number of entries in azArg[] */ 5728){ 5729 sqlite3 *db = pState->db; /* Database handle to query "main" db of */ 5730 FILE *out = pState->out; /* Stream to write non-error output to */ 5731 int bVerbose = 0; /* If -verbose is present */ 5732 int bGroupByParent = 0; /* If -groupbyparent is present */ 5733 int i; /* To iterate through azArg[] */ 5734 const char *zIndent = ""; /* How much to indent CREATE INDEX by */ 5735 int rc; /* Return code */ 5736 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */ 5737 5738 /* 5739 ** This SELECT statement returns one row for each foreign key constraint 5740 ** in the schema of the main database. The column values are: 5741 ** 5742 ** 0. The text of an SQL statement similar to: 5743 ** 5744 ** "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?" 5745 ** 5746 ** This SELECT is similar to the one that the foreign keys implementation 5747 ** needs to run internally on child tables. If there is an index that can 5748 ** be used to optimize this query, then it can also be used by the FK 5749 ** implementation to optimize DELETE or UPDATE statements on the parent 5750 ** table. 5751 ** 5752 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by 5753 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema 5754 ** contains an index that can be used to optimize the query. 5755 ** 5756 ** 2. Human readable text that describes the child table and columns. e.g. 5757 ** 5758 ** "child_table(child_key1, child_key2)" 5759 ** 5760 ** 3. Human readable text that describes the parent table and columns. e.g. 5761 ** 5762 ** "parent_table(parent_key1, parent_key2)" 5763 ** 5764 ** 4. A full CREATE INDEX statement for an index that could be used to 5765 ** optimize DELETE or UPDATE statements on the parent table. e.g. 5766 ** 5767 ** "CREATE INDEX child_table_child_key ON child_table(child_key)" 5768 ** 5769 ** 5. The name of the parent table. 5770 ** 5771 ** These six values are used by the C logic below to generate the report. 5772 */ 5773 const char *zSql = 5774 "SELECT " 5775 " 'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '" 5776 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' " 5777 " || fkey_collate_clause(" 5778 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')" 5779 ", " 5780 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('" 5781 " || group_concat('*=?', ' AND ') || ')'" 5782 ", " 5783 " s.name || '(' || group_concat(f.[from], ', ') || ')'" 5784 ", " 5785 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'" 5786 ", " 5787 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))" 5788 " || ' ON ' || quote(s.name) || '('" 5789 " || group_concat(quote(f.[from]) ||" 5790 " fkey_collate_clause(" 5791 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')" 5792 " || ');'" 5793 ", " 5794 " f.[table] " 5795 "FROM sqlite_schema AS s, pragma_foreign_key_list(s.name) AS f " 5796 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) " 5797 "GROUP BY s.name, f.id " 5798 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)" 5799 ; 5800 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)"; 5801 5802 for(i=2; i<nArg; i++){ 5803 int n = strlen30(azArg[i]); 5804 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){ 5805 bVerbose = 1; 5806 } 5807 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){ 5808 bGroupByParent = 1; 5809 zIndent = " "; 5810 } 5811 else{ 5812 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n", 5813 azArg[0], azArg[1] 5814 ); 5815 return SQLITE_ERROR; 5816 } 5817 } 5818 5819 /* Register the fkey_collate_clause() SQL function */ 5820 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8, 5821 0, shellFkeyCollateClause, 0, 0 5822 ); 5823 5824 5825 if( rc==SQLITE_OK ){ 5826 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0); 5827 } 5828 if( rc==SQLITE_OK ){ 5829 sqlite3_bind_int(pSql, 1, bGroupByParent); 5830 } 5831 5832 if( rc==SQLITE_OK ){ 5833 int rc2; 5834 char *zPrev = 0; 5835 while( SQLITE_ROW==sqlite3_step(pSql) ){ 5836 int res = -1; 5837 sqlite3_stmt *pExplain = 0; 5838 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0); 5839 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1); 5840 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2); 5841 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3); 5842 const char *zCI = (const char*)sqlite3_column_text(pSql, 4); 5843 const char *zParent = (const char*)sqlite3_column_text(pSql, 5); 5844 5845 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 5846 if( rc!=SQLITE_OK ) break; 5847 if( SQLITE_ROW==sqlite3_step(pExplain) ){ 5848 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3); 5849 res = ( 5850 0==sqlite3_strglob(zGlob, zPlan) 5851 || 0==sqlite3_strglob(zGlobIPK, zPlan) 5852 ); 5853 } 5854 rc = sqlite3_finalize(pExplain); 5855 if( rc!=SQLITE_OK ) break; 5856 5857 if( res<0 ){ 5858 raw_printf(stderr, "Error: internal error"); 5859 break; 5860 }else{ 5861 if( bGroupByParent 5862 && (bVerbose || res==0) 5863 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev)) 5864 ){ 5865 raw_printf(out, "-- Parent table %s\n", zParent); 5866 sqlite3_free(zPrev); 5867 zPrev = sqlite3_mprintf("%s", zParent); 5868 } 5869 5870 if( res==0 ){ 5871 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget); 5872 }else if( bVerbose ){ 5873 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n", 5874 zIndent, zFrom, zTarget 5875 ); 5876 } 5877 } 5878 } 5879 sqlite3_free(zPrev); 5880 5881 if( rc!=SQLITE_OK ){ 5882 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 5883 } 5884 5885 rc2 = sqlite3_finalize(pSql); 5886 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){ 5887 rc = rc2; 5888 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 5889 } 5890 }else{ 5891 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 5892 } 5893 5894 return rc; 5895} 5896 5897/* 5898** Implementation of ".lint" dot command. 5899*/ 5900static int lintDotCommand( 5901 ShellState *pState, /* Current shell tool state */ 5902 char **azArg, /* Array of arguments passed to dot command */ 5903 int nArg /* Number of entries in azArg[] */ 5904){ 5905 int n; 5906 n = (nArg>=2 ? strlen30(azArg[1]) : 0); 5907 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage; 5908 return lintFkeyIndexes(pState, azArg, nArg); 5909 5910 usage: 5911 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]); 5912 raw_printf(stderr, "Where sub-commands are:\n"); 5913 raw_printf(stderr, " fkey-indexes\n"); 5914 return SQLITE_ERROR; 5915} 5916 5917#if !defined SQLITE_OMIT_VIRTUALTABLE 5918static void shellPrepare( 5919 sqlite3 *db, 5920 int *pRc, 5921 const char *zSql, 5922 sqlite3_stmt **ppStmt 5923){ 5924 *ppStmt = 0; 5925 if( *pRc==SQLITE_OK ){ 5926 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); 5927 if( rc!=SQLITE_OK ){ 5928 raw_printf(stderr, "sql error: %s (%d)\n", 5929 sqlite3_errmsg(db), sqlite3_errcode(db) 5930 ); 5931 *pRc = rc; 5932 } 5933 } 5934} 5935 5936/* 5937** Create a prepared statement using printf-style arguments for the SQL. 5938** 5939** This routine is could be marked "static". But it is not always used, 5940** depending on compile-time options. By omitting the "static", we avoid 5941** nuisance compiler warnings about "defined but not used". 5942*/ 5943void shellPreparePrintf( 5944 sqlite3 *db, 5945 int *pRc, 5946 sqlite3_stmt **ppStmt, 5947 const char *zFmt, 5948 ... 5949){ 5950 *ppStmt = 0; 5951 if( *pRc==SQLITE_OK ){ 5952 va_list ap; 5953 char *z; 5954 va_start(ap, zFmt); 5955 z = sqlite3_vmprintf(zFmt, ap); 5956 va_end(ap); 5957 if( z==0 ){ 5958 *pRc = SQLITE_NOMEM; 5959 }else{ 5960 shellPrepare(db, pRc, z, ppStmt); 5961 sqlite3_free(z); 5962 } 5963 } 5964} 5965 5966/* Finalize the prepared statement created using shellPreparePrintf(). 5967** 5968** This routine is could be marked "static". But it is not always used, 5969** depending on compile-time options. By omitting the "static", we avoid 5970** nuisance compiler warnings about "defined but not used". 5971*/ 5972void shellFinalize( 5973 int *pRc, 5974 sqlite3_stmt *pStmt 5975){ 5976 if( pStmt ){ 5977 sqlite3 *db = sqlite3_db_handle(pStmt); 5978 int rc = sqlite3_finalize(pStmt); 5979 if( *pRc==SQLITE_OK ){ 5980 if( rc!=SQLITE_OK ){ 5981 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 5982 } 5983 *pRc = rc; 5984 } 5985 } 5986} 5987 5988/* Reset the prepared statement created using shellPreparePrintf(). 5989** 5990** This routine is could be marked "static". But it is not always used, 5991** depending on compile-time options. By omitting the "static", we avoid 5992** nuisance compiler warnings about "defined but not used". 5993*/ 5994void shellReset( 5995 int *pRc, 5996 sqlite3_stmt *pStmt 5997){ 5998 int rc = sqlite3_reset(pStmt); 5999 if( *pRc==SQLITE_OK ){ 6000 if( rc!=SQLITE_OK ){ 6001 sqlite3 *db = sqlite3_db_handle(pStmt); 6002 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 6003 } 6004 *pRc = rc; 6005 } 6006} 6007#endif /* !defined SQLITE_OMIT_VIRTUALTABLE */ 6008 6009#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 6010/****************************************************************************** 6011** The ".archive" or ".ar" command. 6012*/ 6013/* 6014** Structure representing a single ".ar" command. 6015*/ 6016typedef struct ArCommand ArCommand; 6017struct ArCommand { 6018 u8 eCmd; /* An AR_CMD_* value */ 6019 u8 bVerbose; /* True if --verbose */ 6020 u8 bZip; /* True if the archive is a ZIP */ 6021 u8 bDryRun; /* True if --dry-run */ 6022 u8 bAppend; /* True if --append */ 6023 u8 fromCmdLine; /* Run from -A instead of .archive */ 6024 int nArg; /* Number of command arguments */ 6025 char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */ 6026 const char *zFile; /* --file argument, or NULL */ 6027 const char *zDir; /* --directory argument, or NULL */ 6028 char **azArg; /* Array of command arguments */ 6029 ShellState *p; /* Shell state */ 6030 sqlite3 *db; /* Database containing the archive */ 6031}; 6032 6033/* 6034** Print a usage message for the .ar command to stderr and return SQLITE_ERROR. 6035*/ 6036static int arUsage(FILE *f){ 6037 showHelp(f,"archive"); 6038 return SQLITE_ERROR; 6039} 6040 6041/* 6042** Print an error message for the .ar command to stderr and return 6043** SQLITE_ERROR. 6044*/ 6045static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){ 6046 va_list ap; 6047 char *z; 6048 va_start(ap, zFmt); 6049 z = sqlite3_vmprintf(zFmt, ap); 6050 va_end(ap); 6051 utf8_printf(stderr, "Error: %s\n", z); 6052 if( pAr->fromCmdLine ){ 6053 utf8_printf(stderr, "Use \"-A\" for more help\n"); 6054 }else{ 6055 utf8_printf(stderr, "Use \".archive --help\" for more help\n"); 6056 } 6057 sqlite3_free(z); 6058 return SQLITE_ERROR; 6059} 6060 6061/* 6062** Values for ArCommand.eCmd. 6063*/ 6064#define AR_CMD_CREATE 1 6065#define AR_CMD_UPDATE 2 6066#define AR_CMD_INSERT 3 6067#define AR_CMD_EXTRACT 4 6068#define AR_CMD_LIST 5 6069#define AR_CMD_HELP 6 6070 6071/* 6072** Other (non-command) switches. 6073*/ 6074#define AR_SWITCH_VERBOSE 7 6075#define AR_SWITCH_FILE 8 6076#define AR_SWITCH_DIRECTORY 9 6077#define AR_SWITCH_APPEND 10 6078#define AR_SWITCH_DRYRUN 11 6079 6080static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){ 6081 switch( eSwitch ){ 6082 case AR_CMD_CREATE: 6083 case AR_CMD_EXTRACT: 6084 case AR_CMD_LIST: 6085 case AR_CMD_UPDATE: 6086 case AR_CMD_INSERT: 6087 case AR_CMD_HELP: 6088 if( pAr->eCmd ){ 6089 return arErrorMsg(pAr, "multiple command options"); 6090 } 6091 pAr->eCmd = eSwitch; 6092 break; 6093 6094 case AR_SWITCH_DRYRUN: 6095 pAr->bDryRun = 1; 6096 break; 6097 case AR_SWITCH_VERBOSE: 6098 pAr->bVerbose = 1; 6099 break; 6100 case AR_SWITCH_APPEND: 6101 pAr->bAppend = 1; 6102 /* Fall thru into --file */ 6103 case AR_SWITCH_FILE: 6104 pAr->zFile = zArg; 6105 break; 6106 case AR_SWITCH_DIRECTORY: 6107 pAr->zDir = zArg; 6108 break; 6109 } 6110 6111 return SQLITE_OK; 6112} 6113 6114/* 6115** Parse the command line for an ".ar" command. The results are written into 6116** structure (*pAr). SQLITE_OK is returned if the command line is parsed 6117** successfully, otherwise an error message is written to stderr and 6118** SQLITE_ERROR returned. 6119*/ 6120static int arParseCommand( 6121 char **azArg, /* Array of arguments passed to dot command */ 6122 int nArg, /* Number of entries in azArg[] */ 6123 ArCommand *pAr /* Populate this object */ 6124){ 6125 struct ArSwitch { 6126 const char *zLong; 6127 char cShort; 6128 u8 eSwitch; 6129 u8 bArg; 6130 } aSwitch[] = { 6131 { "create", 'c', AR_CMD_CREATE, 0 }, 6132 { "extract", 'x', AR_CMD_EXTRACT, 0 }, 6133 { "insert", 'i', AR_CMD_INSERT, 0 }, 6134 { "list", 't', AR_CMD_LIST, 0 }, 6135 { "update", 'u', AR_CMD_UPDATE, 0 }, 6136 { "help", 'h', AR_CMD_HELP, 0 }, 6137 { "verbose", 'v', AR_SWITCH_VERBOSE, 0 }, 6138 { "file", 'f', AR_SWITCH_FILE, 1 }, 6139 { "append", 'a', AR_SWITCH_APPEND, 1 }, 6140 { "directory", 'C', AR_SWITCH_DIRECTORY, 1 }, 6141 { "dryrun", 'n', AR_SWITCH_DRYRUN, 0 }, 6142 }; 6143 int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch); 6144 struct ArSwitch *pEnd = &aSwitch[nSwitch]; 6145 6146 if( nArg<=1 ){ 6147 utf8_printf(stderr, "Wrong number of arguments. Usage:\n"); 6148 return arUsage(stderr); 6149 }else{ 6150 char *z = azArg[1]; 6151 if( z[0]!='-' ){ 6152 /* Traditional style [tar] invocation */ 6153 int i; 6154 int iArg = 2; 6155 for(i=0; z[i]; i++){ 6156 const char *zArg = 0; 6157 struct ArSwitch *pOpt; 6158 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 6159 if( z[i]==pOpt->cShort ) break; 6160 } 6161 if( pOpt==pEnd ){ 6162 return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 6163 } 6164 if( pOpt->bArg ){ 6165 if( iArg>=nArg ){ 6166 return arErrorMsg(pAr, "option requires an argument: %c",z[i]); 6167 } 6168 zArg = azArg[iArg++]; 6169 } 6170 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 6171 } 6172 pAr->nArg = nArg-iArg; 6173 if( pAr->nArg>0 ){ 6174 pAr->azArg = &azArg[iArg]; 6175 } 6176 }else{ 6177 /* Non-traditional invocation */ 6178 int iArg; 6179 for(iArg=1; iArg<nArg; iArg++){ 6180 int n; 6181 z = azArg[iArg]; 6182 if( z[0]!='-' ){ 6183 /* All remaining command line words are command arguments. */ 6184 pAr->azArg = &azArg[iArg]; 6185 pAr->nArg = nArg-iArg; 6186 break; 6187 } 6188 n = strlen30(z); 6189 6190 if( z[1]!='-' ){ 6191 int i; 6192 /* One or more short options */ 6193 for(i=1; i<n; i++){ 6194 const char *zArg = 0; 6195 struct ArSwitch *pOpt; 6196 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 6197 if( z[i]==pOpt->cShort ) break; 6198 } 6199 if( pOpt==pEnd ){ 6200 return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 6201 } 6202 if( pOpt->bArg ){ 6203 if( i<(n-1) ){ 6204 zArg = &z[i+1]; 6205 i = n; 6206 }else{ 6207 if( iArg>=(nArg-1) ){ 6208 return arErrorMsg(pAr, "option requires an argument: %c", 6209 z[i]); 6210 } 6211 zArg = azArg[++iArg]; 6212 } 6213 } 6214 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 6215 } 6216 }else if( z[2]=='\0' ){ 6217 /* A -- option, indicating that all remaining command line words 6218 ** are command arguments. */ 6219 pAr->azArg = &azArg[iArg+1]; 6220 pAr->nArg = nArg-iArg-1; 6221 break; 6222 }else{ 6223 /* A long option */ 6224 const char *zArg = 0; /* Argument for option, if any */ 6225 struct ArSwitch *pMatch = 0; /* Matching option */ 6226 struct ArSwitch *pOpt; /* Iterator */ 6227 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 6228 const char *zLong = pOpt->zLong; 6229 if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){ 6230 if( pMatch ){ 6231 return arErrorMsg(pAr, "ambiguous option: %s",z); 6232 }else{ 6233 pMatch = pOpt; 6234 } 6235 } 6236 } 6237 6238 if( pMatch==0 ){ 6239 return arErrorMsg(pAr, "unrecognized option: %s", z); 6240 } 6241 if( pMatch->bArg ){ 6242 if( iArg>=(nArg-1) ){ 6243 return arErrorMsg(pAr, "option requires an argument: %s", z); 6244 } 6245 zArg = azArg[++iArg]; 6246 } 6247 if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR; 6248 } 6249 } 6250 } 6251 } 6252 6253 return SQLITE_OK; 6254} 6255 6256/* 6257** This function assumes that all arguments within the ArCommand.azArg[] 6258** array refer to archive members, as for the --extract or --list commands. 6259** It checks that each of them are present. If any specified file is not 6260** present in the archive, an error is printed to stderr and an error 6261** code returned. Otherwise, if all specified arguments are present in 6262** the archive, SQLITE_OK is returned. 6263** 6264** This function strips any trailing '/' characters from each argument. 6265** This is consistent with the way the [tar] command seems to work on 6266** Linux. 6267*/ 6268static int arCheckEntries(ArCommand *pAr){ 6269 int rc = SQLITE_OK; 6270 if( pAr->nArg ){ 6271 int i, j; 6272 sqlite3_stmt *pTest = 0; 6273 6274 shellPreparePrintf(pAr->db, &rc, &pTest, 6275 "SELECT name FROM %s WHERE name=$name", 6276 pAr->zSrcTable 6277 ); 6278 j = sqlite3_bind_parameter_index(pTest, "$name"); 6279 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 6280 char *z = pAr->azArg[i]; 6281 int n = strlen30(z); 6282 int bOk = 0; 6283 while( n>0 && z[n-1]=='/' ) n--; 6284 z[n] = '\0'; 6285 sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC); 6286 if( SQLITE_ROW==sqlite3_step(pTest) ){ 6287 bOk = 1; 6288 } 6289 shellReset(&rc, pTest); 6290 if( rc==SQLITE_OK && bOk==0 ){ 6291 utf8_printf(stderr, "not found in archive: %s\n", z); 6292 rc = SQLITE_ERROR; 6293 } 6294 } 6295 shellFinalize(&rc, pTest); 6296 } 6297 return rc; 6298} 6299 6300/* 6301** Format a WHERE clause that can be used against the "sqlar" table to 6302** identify all archive members that match the command arguments held 6303** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning. 6304** The caller is responsible for eventually calling sqlite3_free() on 6305** any non-NULL (*pzWhere) value. 6306*/ 6307static void arWhereClause( 6308 int *pRc, 6309 ArCommand *pAr, 6310 char **pzWhere /* OUT: New WHERE clause */ 6311){ 6312 char *zWhere = 0; 6313 if( *pRc==SQLITE_OK ){ 6314 if( pAr->nArg==0 ){ 6315 zWhere = sqlite3_mprintf("1"); 6316 }else{ 6317 int i; 6318 const char *zSep = ""; 6319 for(i=0; i<pAr->nArg; i++){ 6320 const char *z = pAr->azArg[i]; 6321 zWhere = sqlite3_mprintf( 6322 "%z%s name = '%q' OR substr(name,1,%d) = '%q/'", 6323 zWhere, zSep, z, strlen30(z)+1, z 6324 ); 6325 if( zWhere==0 ){ 6326 *pRc = SQLITE_NOMEM; 6327 break; 6328 } 6329 zSep = " OR "; 6330 } 6331 } 6332 } 6333 *pzWhere = zWhere; 6334} 6335 6336/* 6337** Implementation of .ar "lisT" command. 6338*/ 6339static int arListCommand(ArCommand *pAr){ 6340 const char *zSql = "SELECT %s FROM %s WHERE %s"; 6341 const char *azCols[] = { 6342 "name", 6343 "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name" 6344 }; 6345 6346 char *zWhere = 0; 6347 sqlite3_stmt *pSql = 0; 6348 int rc; 6349 6350 rc = arCheckEntries(pAr); 6351 arWhereClause(&rc, pAr, &zWhere); 6352 6353 shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose], 6354 pAr->zSrcTable, zWhere); 6355 if( pAr->bDryRun ){ 6356 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 6357 }else{ 6358 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 6359 if( pAr->bVerbose ){ 6360 utf8_printf(pAr->p->out, "%s % 10d %s %s\n", 6361 sqlite3_column_text(pSql, 0), 6362 sqlite3_column_int(pSql, 1), 6363 sqlite3_column_text(pSql, 2), 6364 sqlite3_column_text(pSql, 3) 6365 ); 6366 }else{ 6367 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 6368 } 6369 } 6370 } 6371 shellFinalize(&rc, pSql); 6372 sqlite3_free(zWhere); 6373 return rc; 6374} 6375 6376 6377/* 6378** Implementation of .ar "eXtract" command. 6379*/ 6380static int arExtractCommand(ArCommand *pAr){ 6381 const char *zSql1 = 6382 "SELECT " 6383 " ($dir || name)," 6384 " writefile(($dir || name), %s, mode, mtime) " 6385 "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)" 6386 " AND name NOT GLOB '*..[/\\]*'"; 6387 6388 const char *azExtraArg[] = { 6389 "sqlar_uncompress(data, sz)", 6390 "data" 6391 }; 6392 6393 sqlite3_stmt *pSql = 0; 6394 int rc = SQLITE_OK; 6395 char *zDir = 0; 6396 char *zWhere = 0; 6397 int i, j; 6398 6399 /* If arguments are specified, check that they actually exist within 6400 ** the archive before proceeding. And formulate a WHERE clause to 6401 ** match them. */ 6402 rc = arCheckEntries(pAr); 6403 arWhereClause(&rc, pAr, &zWhere); 6404 6405 if( rc==SQLITE_OK ){ 6406 if( pAr->zDir ){ 6407 zDir = sqlite3_mprintf("%s/", pAr->zDir); 6408 }else{ 6409 zDir = sqlite3_mprintf(""); 6410 } 6411 if( zDir==0 ) rc = SQLITE_NOMEM; 6412 } 6413 6414 shellPreparePrintf(pAr->db, &rc, &pSql, zSql1, 6415 azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere 6416 ); 6417 6418 if( rc==SQLITE_OK ){ 6419 j = sqlite3_bind_parameter_index(pSql, "$dir"); 6420 sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC); 6421 6422 /* Run the SELECT statement twice. The first time, writefile() is called 6423 ** for all archive members that should be extracted. The second time, 6424 ** only for the directories. This is because the timestamps for 6425 ** extracted directories must be reset after they are populated (as 6426 ** populating them changes the timestamp). */ 6427 for(i=0; i<2; i++){ 6428 j = sqlite3_bind_parameter_index(pSql, "$dirOnly"); 6429 sqlite3_bind_int(pSql, j, i); 6430 if( pAr->bDryRun ){ 6431 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 6432 }else{ 6433 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 6434 if( i==0 && pAr->bVerbose ){ 6435 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 6436 } 6437 } 6438 } 6439 shellReset(&rc, pSql); 6440 } 6441 shellFinalize(&rc, pSql); 6442 } 6443 6444 sqlite3_free(zDir); 6445 sqlite3_free(zWhere); 6446 return rc; 6447} 6448 6449/* 6450** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out. 6451*/ 6452static int arExecSql(ArCommand *pAr, const char *zSql){ 6453 int rc; 6454 if( pAr->bDryRun ){ 6455 utf8_printf(pAr->p->out, "%s\n", zSql); 6456 rc = SQLITE_OK; 6457 }else{ 6458 char *zErr = 0; 6459 rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr); 6460 if( zErr ){ 6461 utf8_printf(stdout, "ERROR: %s\n", zErr); 6462 sqlite3_free(zErr); 6463 } 6464 } 6465 return rc; 6466} 6467 6468 6469/* 6470** Implementation of .ar "create", "insert", and "update" commands. 6471** 6472** create -> Create a new SQL archive 6473** insert -> Insert or reinsert all files listed 6474** update -> Insert files that have changed or that were not 6475** previously in the archive 6476** 6477** Create the "sqlar" table in the database if it does not already exist. 6478** Then add each file in the azFile[] array to the archive. Directories 6479** are added recursively. If argument bVerbose is non-zero, a message is 6480** printed on stdout for each file archived. 6481** 6482** The create command is the same as update, except that it drops 6483** any existing "sqlar" table before beginning. The "insert" command 6484** always overwrites every file named on the command-line, where as 6485** "update" only overwrites if the size or mtime or mode has changed. 6486*/ 6487static int arCreateOrUpdateCommand( 6488 ArCommand *pAr, /* Command arguments and options */ 6489 int bUpdate, /* true for a --create. */ 6490 int bOnlyIfChanged /* Only update if file has changed */ 6491){ 6492 const char *zCreate = 6493 "CREATE TABLE IF NOT EXISTS sqlar(\n" 6494 " name TEXT PRIMARY KEY, -- name of the file\n" 6495 " mode INT, -- access permissions\n" 6496 " mtime INT, -- last modification time\n" 6497 " sz INT, -- original file size\n" 6498 " data BLOB -- compressed content\n" 6499 ")"; 6500 const char *zDrop = "DROP TABLE IF EXISTS sqlar"; 6501 const char *zInsertFmt[2] = { 6502 "REPLACE INTO %s(name,mode,mtime,sz,data)\n" 6503 " SELECT\n" 6504 " %s,\n" 6505 " mode,\n" 6506 " mtime,\n" 6507 " CASE substr(lsmode(mode),1,1)\n" 6508 " WHEN '-' THEN length(data)\n" 6509 " WHEN 'd' THEN 0\n" 6510 " ELSE -1 END,\n" 6511 " sqlar_compress(data)\n" 6512 " FROM fsdir(%Q,%Q) AS disk\n" 6513 " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 6514 , 6515 "REPLACE INTO %s(name,mode,mtime,data)\n" 6516 " SELECT\n" 6517 " %s,\n" 6518 " mode,\n" 6519 " mtime,\n" 6520 " data\n" 6521 " FROM fsdir(%Q,%Q) AS disk\n" 6522 " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 6523 }; 6524 int i; /* For iterating through azFile[] */ 6525 int rc; /* Return code */ 6526 const char *zTab = 0; /* SQL table into which to insert */ 6527 char *zSql; 6528 char zTemp[50]; 6529 char *zExists = 0; 6530 6531 arExecSql(pAr, "PRAGMA page_size=512"); 6532 rc = arExecSql(pAr, "SAVEPOINT ar;"); 6533 if( rc!=SQLITE_OK ) return rc; 6534 zTemp[0] = 0; 6535 if( pAr->bZip ){ 6536 /* Initialize the zipfile virtual table, if necessary */ 6537 if( pAr->zFile ){ 6538 sqlite3_uint64 r; 6539 sqlite3_randomness(sizeof(r),&r); 6540 sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r); 6541 zTab = zTemp; 6542 zSql = sqlite3_mprintf( 6543 "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)", 6544 zTab, pAr->zFile 6545 ); 6546 rc = arExecSql(pAr, zSql); 6547 sqlite3_free(zSql); 6548 }else{ 6549 zTab = "zip"; 6550 } 6551 }else{ 6552 /* Initialize the table for an SQLAR */ 6553 zTab = "sqlar"; 6554 if( bUpdate==0 ){ 6555 rc = arExecSql(pAr, zDrop); 6556 if( rc!=SQLITE_OK ) goto end_ar_transaction; 6557 } 6558 rc = arExecSql(pAr, zCreate); 6559 } 6560 if( bOnlyIfChanged ){ 6561 zExists = sqlite3_mprintf( 6562 " AND NOT EXISTS(" 6563 "SELECT 1 FROM %s AS mem" 6564 " WHERE mem.name=disk.name" 6565 " AND mem.mtime=disk.mtime" 6566 " AND mem.mode=disk.mode)", zTab); 6567 }else{ 6568 zExists = sqlite3_mprintf(""); 6569 } 6570 if( zExists==0 ) rc = SQLITE_NOMEM; 6571 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 6572 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab, 6573 pAr->bVerbose ? "shell_putsnl(name)" : "name", 6574 pAr->azArg[i], pAr->zDir, zExists); 6575 rc = arExecSql(pAr, zSql2); 6576 sqlite3_free(zSql2); 6577 } 6578end_ar_transaction: 6579 if( rc!=SQLITE_OK ){ 6580 sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0); 6581 }else{ 6582 rc = arExecSql(pAr, "RELEASE ar;"); 6583 if( pAr->bZip && pAr->zFile ){ 6584 zSql = sqlite3_mprintf("DROP TABLE %s", zTemp); 6585 arExecSql(pAr, zSql); 6586 sqlite3_free(zSql); 6587 } 6588 } 6589 sqlite3_free(zExists); 6590 return rc; 6591} 6592 6593/* 6594** Implementation of ".ar" dot command. 6595*/ 6596static int arDotCommand( 6597 ShellState *pState, /* Current shell tool state */ 6598 int fromCmdLine, /* True if -A command-line option, not .ar cmd */ 6599 char **azArg, /* Array of arguments passed to dot command */ 6600 int nArg /* Number of entries in azArg[] */ 6601){ 6602 ArCommand cmd; 6603 int rc; 6604 memset(&cmd, 0, sizeof(cmd)); 6605 cmd.fromCmdLine = fromCmdLine; 6606 rc = arParseCommand(azArg, nArg, &cmd); 6607 if( rc==SQLITE_OK ){ 6608 int eDbType = SHELL_OPEN_UNSPEC; 6609 cmd.p = pState; 6610 cmd.db = pState->db; 6611 if( cmd.zFile ){ 6612 eDbType = deduceDatabaseType(cmd.zFile, 1); 6613 }else{ 6614 eDbType = pState->openMode; 6615 } 6616 if( eDbType==SHELL_OPEN_ZIPFILE ){ 6617 if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){ 6618 if( cmd.zFile==0 ){ 6619 cmd.zSrcTable = sqlite3_mprintf("zip"); 6620 }else{ 6621 cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile); 6622 } 6623 } 6624 cmd.bZip = 1; 6625 }else if( cmd.zFile ){ 6626 int flags; 6627 if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS; 6628 if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT 6629 || cmd.eCmd==AR_CMD_UPDATE ){ 6630 flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE; 6631 }else{ 6632 flags = SQLITE_OPEN_READONLY; 6633 } 6634 cmd.db = 0; 6635 if( cmd.bDryRun ){ 6636 utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile, 6637 eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : ""); 6638 } 6639 rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags, 6640 eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0); 6641 if( rc!=SQLITE_OK ){ 6642 utf8_printf(stderr, "cannot open file: %s (%s)\n", 6643 cmd.zFile, sqlite3_errmsg(cmd.db) 6644 ); 6645 goto end_ar_command; 6646 } 6647 sqlite3_fileio_init(cmd.db, 0, 0); 6648 sqlite3_sqlar_init(cmd.db, 0, 0); 6649 sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p, 6650 shellPutsFunc, 0, 0); 6651 6652 } 6653 if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){ 6654 if( cmd.eCmd!=AR_CMD_CREATE 6655 && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0) 6656 ){ 6657 utf8_printf(stderr, "database does not contain an 'sqlar' table\n"); 6658 rc = SQLITE_ERROR; 6659 goto end_ar_command; 6660 } 6661 cmd.zSrcTable = sqlite3_mprintf("sqlar"); 6662 } 6663 6664 switch( cmd.eCmd ){ 6665 case AR_CMD_CREATE: 6666 rc = arCreateOrUpdateCommand(&cmd, 0, 0); 6667 break; 6668 6669 case AR_CMD_EXTRACT: 6670 rc = arExtractCommand(&cmd); 6671 break; 6672 6673 case AR_CMD_LIST: 6674 rc = arListCommand(&cmd); 6675 break; 6676 6677 case AR_CMD_HELP: 6678 arUsage(pState->out); 6679 break; 6680 6681 case AR_CMD_INSERT: 6682 rc = arCreateOrUpdateCommand(&cmd, 1, 0); 6683 break; 6684 6685 default: 6686 assert( cmd.eCmd==AR_CMD_UPDATE ); 6687 rc = arCreateOrUpdateCommand(&cmd, 1, 1); 6688 break; 6689 } 6690 } 6691end_ar_command: 6692 if( cmd.db!=pState->db ){ 6693 close_db(cmd.db); 6694 } 6695 sqlite3_free(cmd.zSrcTable); 6696 6697 return rc; 6698} 6699/* End of the ".archive" or ".ar" command logic 6700*******************************************************************************/ 6701#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */ 6702 6703#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 6704/* 6705** If (*pRc) is not SQLITE_OK when this function is called, it is a no-op. 6706** Otherwise, the SQL statement or statements in zSql are executed using 6707** database connection db and the error code written to *pRc before 6708** this function returns. 6709*/ 6710static void shellExec(sqlite3 *db, int *pRc, const char *zSql){ 6711 int rc = *pRc; 6712 if( rc==SQLITE_OK ){ 6713 char *zErr = 0; 6714 rc = sqlite3_exec(db, zSql, 0, 0, &zErr); 6715 if( rc!=SQLITE_OK ){ 6716 raw_printf(stderr, "SQL error: %s\n", zErr); 6717 } 6718 *pRc = rc; 6719 } 6720} 6721 6722/* 6723** Like shellExec(), except that zFmt is a printf() style format string. 6724*/ 6725static void shellExecPrintf(sqlite3 *db, int *pRc, const char *zFmt, ...){ 6726 char *z = 0; 6727 if( *pRc==SQLITE_OK ){ 6728 va_list ap; 6729 va_start(ap, zFmt); 6730 z = sqlite3_vmprintf(zFmt, ap); 6731 va_end(ap); 6732 if( z==0 ){ 6733 *pRc = SQLITE_NOMEM; 6734 }else{ 6735 shellExec(db, pRc, z); 6736 } 6737 sqlite3_free(z); 6738 } 6739} 6740 6741/* 6742** If *pRc is not SQLITE_OK when this function is called, it is a no-op. 6743** Otherwise, an attempt is made to allocate, zero and return a pointer 6744** to a buffer nByte bytes in size. If an OOM error occurs, *pRc is set 6745** to SQLITE_NOMEM and NULL returned. 6746*/ 6747static void *shellMalloc(int *pRc, sqlite3_int64 nByte){ 6748 void *pRet = 0; 6749 if( *pRc==SQLITE_OK ){ 6750 pRet = sqlite3_malloc64(nByte); 6751 if( pRet==0 ){ 6752 *pRc = SQLITE_NOMEM; 6753 }else{ 6754 memset(pRet, 0, nByte); 6755 } 6756 } 6757 return pRet; 6758} 6759 6760/* 6761** If *pRc is not SQLITE_OK when this function is called, it is a no-op. 6762** Otherwise, zFmt is treated as a printf() style string. The result of 6763** formatting it along with any trailing arguments is written into a 6764** buffer obtained from sqlite3_malloc(), and pointer to which is returned. 6765** It is the responsibility of the caller to eventually free this buffer 6766** using a call to sqlite3_free(). 6767** 6768** If an OOM error occurs, (*pRc) is set to SQLITE_NOMEM and a NULL 6769** pointer returned. 6770*/ 6771static char *shellMPrintf(int *pRc, const char *zFmt, ...){ 6772 char *z = 0; 6773 if( *pRc==SQLITE_OK ){ 6774 va_list ap; 6775 va_start(ap, zFmt); 6776 z = sqlite3_vmprintf(zFmt, ap); 6777 va_end(ap); 6778 if( z==0 ){ 6779 *pRc = SQLITE_NOMEM; 6780 } 6781 } 6782 return z; 6783} 6784 6785/* 6786** When running the ".recover" command, each output table, and the special 6787** orphaned row table if it is required, is represented by an instance 6788** of the following struct. 6789*/ 6790typedef struct RecoverTable RecoverTable; 6791struct RecoverTable { 6792 char *zQuoted; /* Quoted version of table name */ 6793 int nCol; /* Number of columns in table */ 6794 char **azlCol; /* Array of column lists */ 6795 int iPk; /* Index of IPK column */ 6796}; 6797 6798/* 6799** Free a RecoverTable object allocated by recoverFindTable() or 6800** recoverOrphanTable(). 6801*/ 6802static void recoverFreeTable(RecoverTable *pTab){ 6803 if( pTab ){ 6804 sqlite3_free(pTab->zQuoted); 6805 if( pTab->azlCol ){ 6806 int i; 6807 for(i=0; i<=pTab->nCol; i++){ 6808 sqlite3_free(pTab->azlCol[i]); 6809 } 6810 sqlite3_free(pTab->azlCol); 6811 } 6812 sqlite3_free(pTab); 6813 } 6814} 6815 6816/* 6817** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. 6818** Otherwise, it allocates and returns a RecoverTable object based on the 6819** final four arguments passed to this function. It is the responsibility 6820** of the caller to eventually free the returned object using 6821** recoverFreeTable(). 6822*/ 6823static RecoverTable *recoverNewTable( 6824 int *pRc, /* IN/OUT: Error code */ 6825 const char *zName, /* Name of table */ 6826 const char *zSql, /* CREATE TABLE statement */ 6827 int bIntkey, 6828 int nCol 6829){ 6830 sqlite3 *dbtmp = 0; /* sqlite3 handle for testing CREATE TABLE */ 6831 int rc = *pRc; 6832 RecoverTable *pTab = 0; 6833 6834 pTab = (RecoverTable*)shellMalloc(&rc, sizeof(RecoverTable)); 6835 if( rc==SQLITE_OK ){ 6836 int nSqlCol = 0; 6837 int bSqlIntkey = 0; 6838 sqlite3_stmt *pStmt = 0; 6839 6840 rc = sqlite3_open("", &dbtmp); 6841 if( rc==SQLITE_OK ){ 6842 sqlite3_create_function(dbtmp, "shell_idquote", 1, SQLITE_UTF8, 0, 6843 shellIdQuote, 0, 0); 6844 } 6845 if( rc==SQLITE_OK ){ 6846 rc = sqlite3_exec(dbtmp, "PRAGMA writable_schema = on", 0, 0, 0); 6847 } 6848 if( rc==SQLITE_OK ){ 6849 rc = sqlite3_exec(dbtmp, zSql, 0, 0, 0); 6850 if( rc==SQLITE_ERROR ){ 6851 rc = SQLITE_OK; 6852 goto finished; 6853 } 6854 } 6855 shellPreparePrintf(dbtmp, &rc, &pStmt, 6856 "SELECT count(*) FROM pragma_table_info(%Q)", zName 6857 ); 6858 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 6859 nSqlCol = sqlite3_column_int(pStmt, 0); 6860 } 6861 shellFinalize(&rc, pStmt); 6862 6863 if( rc!=SQLITE_OK || nSqlCol<nCol ){ 6864 goto finished; 6865 } 6866 6867 shellPreparePrintf(dbtmp, &rc, &pStmt, 6868 "SELECT (" 6869 " SELECT substr(data,1,1)==X'0D' FROM sqlite_dbpage WHERE pgno=rootpage" 6870 ") FROM sqlite_schema WHERE name = %Q", zName 6871 ); 6872 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 6873 bSqlIntkey = sqlite3_column_int(pStmt, 0); 6874 } 6875 shellFinalize(&rc, pStmt); 6876 6877 if( bIntkey==bSqlIntkey ){ 6878 int i; 6879 const char *zPk = "_rowid_"; 6880 sqlite3_stmt *pPkFinder = 0; 6881 6882 /* If this is an intkey table and there is an INTEGER PRIMARY KEY, 6883 ** set zPk to the name of the PK column, and pTab->iPk to the index 6884 ** of the column, where columns are 0-numbered from left to right. 6885 ** Or, if this is a WITHOUT ROWID table or if there is no IPK column, 6886 ** leave zPk as "_rowid_" and pTab->iPk at -2. */ 6887 pTab->iPk = -2; 6888 if( bIntkey ){ 6889 shellPreparePrintf(dbtmp, &rc, &pPkFinder, 6890 "SELECT cid, name FROM pragma_table_info(%Q) " 6891 " WHERE pk=1 AND type='integer' COLLATE nocase" 6892 " AND NOT EXISTS (SELECT cid FROM pragma_table_info(%Q) WHERE pk=2)" 6893 , zName, zName 6894 ); 6895 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPkFinder) ){ 6896 pTab->iPk = sqlite3_column_int(pPkFinder, 0); 6897 zPk = (const char*)sqlite3_column_text(pPkFinder, 1); 6898 } 6899 } 6900 6901 pTab->zQuoted = shellMPrintf(&rc, "\"%w\"", zName); 6902 pTab->azlCol = (char**)shellMalloc(&rc, sizeof(char*) * (nSqlCol+1)); 6903 pTab->nCol = nSqlCol; 6904 6905 if( bIntkey ){ 6906 pTab->azlCol[0] = shellMPrintf(&rc, "\"%w\"", zPk); 6907 }else{ 6908 pTab->azlCol[0] = shellMPrintf(&rc, ""); 6909 } 6910 i = 1; 6911 shellPreparePrintf(dbtmp, &rc, &pStmt, 6912 "SELECT %Q || group_concat(shell_idquote(name), ', ') " 6913 " FILTER (WHERE cid!=%d) OVER (ORDER BY %s cid) " 6914 "FROM pragma_table_info(%Q)", 6915 bIntkey ? ", " : "", pTab->iPk, 6916 bIntkey ? "" : "(CASE WHEN pk=0 THEN 1000000 ELSE pk END), ", 6917 zName 6918 ); 6919 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 6920 const char *zText = (const char*)sqlite3_column_text(pStmt, 0); 6921 pTab->azlCol[i] = shellMPrintf(&rc, "%s%s", pTab->azlCol[0], zText); 6922 i++; 6923 } 6924 shellFinalize(&rc, pStmt); 6925 6926 shellFinalize(&rc, pPkFinder); 6927 } 6928 } 6929 6930 finished: 6931 sqlite3_close(dbtmp); 6932 *pRc = rc; 6933 if( rc!=SQLITE_OK || (pTab && pTab->zQuoted==0) ){ 6934 recoverFreeTable(pTab); 6935 pTab = 0; 6936 } 6937 return pTab; 6938} 6939 6940/* 6941** This function is called to search the schema recovered from the 6942** sqlite_schema table of the (possibly) corrupt database as part 6943** of a ".recover" command. Specifically, for a table with root page 6944** iRoot and at least nCol columns. Additionally, if bIntkey is 0, the 6945** table must be a WITHOUT ROWID table, or if non-zero, not one of 6946** those. 6947** 6948** If a table is found, a (RecoverTable*) object is returned. Or, if 6949** no such table is found, but bIntkey is false and iRoot is the 6950** root page of an index in the recovered schema, then (*pbNoop) is 6951** set to true and NULL returned. Or, if there is no such table or 6952** index, NULL is returned and (*pbNoop) set to 0, indicating that 6953** the caller should write data to the orphans table. 6954*/ 6955static RecoverTable *recoverFindTable( 6956 ShellState *pState, /* Shell state object */ 6957 int *pRc, /* IN/OUT: Error code */ 6958 int iRoot, /* Root page of table */ 6959 int bIntkey, /* True for an intkey table */ 6960 int nCol, /* Number of columns in table */ 6961 int *pbNoop /* OUT: True if iRoot is root of index */ 6962){ 6963 sqlite3_stmt *pStmt = 0; 6964 RecoverTable *pRet = 0; 6965 int bNoop = 0; 6966 const char *zSql = 0; 6967 const char *zName = 0; 6968 6969 /* Search the recovered schema for an object with root page iRoot. */ 6970 shellPreparePrintf(pState->db, pRc, &pStmt, 6971 "SELECT type, name, sql FROM recovery.schema WHERE rootpage=%d", iRoot 6972 ); 6973 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 6974 const char *zType = (const char*)sqlite3_column_text(pStmt, 0); 6975 if( bIntkey==0 && sqlite3_stricmp(zType, "index")==0 ){ 6976 bNoop = 1; 6977 break; 6978 } 6979 if( sqlite3_stricmp(zType, "table")==0 ){ 6980 zName = (const char*)sqlite3_column_text(pStmt, 1); 6981 zSql = (const char*)sqlite3_column_text(pStmt, 2); 6982 pRet = recoverNewTable(pRc, zName, zSql, bIntkey, nCol); 6983 break; 6984 } 6985 } 6986 6987 shellFinalize(pRc, pStmt); 6988 *pbNoop = bNoop; 6989 return pRet; 6990} 6991 6992/* 6993** Return a RecoverTable object representing the orphans table. 6994*/ 6995static RecoverTable *recoverOrphanTable( 6996 ShellState *pState, /* Shell state object */ 6997 int *pRc, /* IN/OUT: Error code */ 6998 const char *zLostAndFound, /* Base name for orphans table */ 6999 int nCol /* Number of user data columns */ 7000){ 7001 RecoverTable *pTab = 0; 7002 if( nCol>=0 && *pRc==SQLITE_OK ){ 7003 int i; 7004 7005 /* This block determines the name of the orphan table. The prefered 7006 ** name is zLostAndFound. But if that clashes with another name 7007 ** in the recovered schema, try zLostAndFound_0, zLostAndFound_1 7008 ** and so on until a non-clashing name is found. */ 7009 int iTab = 0; 7010 char *zTab = shellMPrintf(pRc, "%s", zLostAndFound); 7011 sqlite3_stmt *pTest = 0; 7012 shellPrepare(pState->db, pRc, 7013 "SELECT 1 FROM recovery.schema WHERE name=?", &pTest 7014 ); 7015 if( pTest ) sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT); 7016 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pTest) ){ 7017 shellReset(pRc, pTest); 7018 sqlite3_free(zTab); 7019 zTab = shellMPrintf(pRc, "%s_%d", zLostAndFound, iTab++); 7020 sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT); 7021 } 7022 shellFinalize(pRc, pTest); 7023 7024 pTab = (RecoverTable*)shellMalloc(pRc, sizeof(RecoverTable)); 7025 if( pTab ){ 7026 pTab->zQuoted = shellMPrintf(pRc, "\"%w\"", zTab); 7027 pTab->nCol = nCol; 7028 pTab->iPk = -2; 7029 if( nCol>0 ){ 7030 pTab->azlCol = (char**)shellMalloc(pRc, sizeof(char*) * (nCol+1)); 7031 if( pTab->azlCol ){ 7032 pTab->azlCol[nCol] = shellMPrintf(pRc, ""); 7033 for(i=nCol-1; i>=0; i--){ 7034 pTab->azlCol[i] = shellMPrintf(pRc, "%s, NULL", pTab->azlCol[i+1]); 7035 } 7036 } 7037 } 7038 7039 if( *pRc!=SQLITE_OK ){ 7040 recoverFreeTable(pTab); 7041 pTab = 0; 7042 }else{ 7043 raw_printf(pState->out, 7044 "CREATE TABLE %s(rootpgno INTEGER, " 7045 "pgno INTEGER, nfield INTEGER, id INTEGER", pTab->zQuoted 7046 ); 7047 for(i=0; i<nCol; i++){ 7048 raw_printf(pState->out, ", c%d", i); 7049 } 7050 raw_printf(pState->out, ");\n"); 7051 } 7052 } 7053 sqlite3_free(zTab); 7054 } 7055 return pTab; 7056} 7057 7058/* 7059** This function is called to recover data from the database. A script 7060** to construct a new database containing all recovered data is output 7061** on stream pState->out. 7062*/ 7063static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){ 7064 int rc = SQLITE_OK; 7065 sqlite3_stmt *pLoop = 0; /* Loop through all root pages */ 7066 sqlite3_stmt *pPages = 0; /* Loop through all pages in a group */ 7067 sqlite3_stmt *pCells = 0; /* Loop through all cells in a page */ 7068 const char *zRecoveryDb = ""; /* Name of "recovery" database */ 7069 const char *zLostAndFound = "lost_and_found"; 7070 int i; 7071 int nOrphan = -1; 7072 RecoverTable *pOrphan = 0; 7073 7074 int bFreelist = 1; /* 0 if --freelist-corrupt is specified */ 7075 int bRowids = 1; /* 0 if --no-rowids */ 7076 for(i=1; i<nArg; i++){ 7077 char *z = azArg[i]; 7078 int n; 7079 if( z[0]=='-' && z[1]=='-' ) z++; 7080 n = strlen30(z); 7081 if( n<=17 && memcmp("-freelist-corrupt", z, n)==0 ){ 7082 bFreelist = 0; 7083 }else 7084 if( n<=12 && memcmp("-recovery-db", z, n)==0 && i<(nArg-1) ){ 7085 i++; 7086 zRecoveryDb = azArg[i]; 7087 }else 7088 if( n<=15 && memcmp("-lost-and-found", z, n)==0 && i<(nArg-1) ){ 7089 i++; 7090 zLostAndFound = azArg[i]; 7091 }else 7092 if( n<=10 && memcmp("-no-rowids", z, n)==0 ){ 7093 bRowids = 0; 7094 } 7095 else{ 7096 utf8_printf(stderr, "unexpected option: %s\n", azArg[i]); 7097 showHelp(pState->out, azArg[0]); 7098 return 1; 7099 } 7100 } 7101 7102 shellExecPrintf(pState->db, &rc, 7103 /* Attach an in-memory database named 'recovery'. Create an indexed 7104 ** cache of the sqlite_dbptr virtual table. */ 7105 "PRAGMA writable_schema = on;" 7106 "ATTACH %Q AS recovery;" 7107 "DROP TABLE IF EXISTS recovery.dbptr;" 7108 "DROP TABLE IF EXISTS recovery.freelist;" 7109 "DROP TABLE IF EXISTS recovery.map;" 7110 "DROP TABLE IF EXISTS recovery.schema;" 7111 "CREATE TABLE recovery.freelist(pgno INTEGER PRIMARY KEY);", zRecoveryDb 7112 ); 7113 7114 if( bFreelist ){ 7115 shellExec(pState->db, &rc, 7116 "WITH trunk(pgno) AS (" 7117 " SELECT shell_int32(" 7118 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 8) AS x " 7119 " WHERE x>0" 7120 " UNION" 7121 " SELECT shell_int32(" 7122 " (SELECT data FROM sqlite_dbpage WHERE pgno=trunk.pgno), 0) AS x " 7123 " FROM trunk WHERE x>0" 7124 ")," 7125 "freelist(data, n, freepgno) AS (" 7126 " SELECT data, min(16384, shell_int32(data, 1)-1), t.pgno " 7127 " FROM trunk t, sqlite_dbpage s WHERE s.pgno=t.pgno" 7128 " UNION ALL" 7129 " SELECT data, n-1, shell_int32(data, 2+n) " 7130 " FROM freelist WHERE n>=0" 7131 ")" 7132 "REPLACE INTO recovery.freelist SELECT freepgno FROM freelist;" 7133 ); 7134 } 7135 7136 /* If this is an auto-vacuum database, add all pointer-map pages to 7137 ** the freelist table. Do this regardless of whether or not 7138 ** --freelist-corrupt was specified. */ 7139 shellExec(pState->db, &rc, 7140 "WITH ptrmap(pgno) AS (" 7141 " SELECT 2 WHERE shell_int32(" 7142 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 13" 7143 " )" 7144 " UNION ALL " 7145 " SELECT pgno+1+(SELECT page_size FROM pragma_page_size)/5 AS pp " 7146 " FROM ptrmap WHERE pp<=(SELECT page_count FROM pragma_page_count)" 7147 ")" 7148 "REPLACE INTO recovery.freelist SELECT pgno FROM ptrmap" 7149 ); 7150 7151 shellExec(pState->db, &rc, 7152 "CREATE TABLE recovery.dbptr(" 7153 " pgno, child, PRIMARY KEY(child, pgno)" 7154 ") WITHOUT ROWID;" 7155 "INSERT OR IGNORE INTO recovery.dbptr(pgno, child) " 7156 " SELECT * FROM sqlite_dbptr" 7157 " WHERE pgno NOT IN freelist AND child NOT IN freelist;" 7158 7159 /* Delete any pointer to page 1. This ensures that page 1 is considered 7160 ** a root page, regardless of how corrupt the db is. */ 7161 "DELETE FROM recovery.dbptr WHERE child = 1;" 7162 7163 /* Delete all pointers to any pages that have more than one pointer 7164 ** to them. Such pages will be treated as root pages when recovering 7165 ** data. */ 7166 "DELETE FROM recovery.dbptr WHERE child IN (" 7167 " SELECT child FROM recovery.dbptr GROUP BY child HAVING count(*)>1" 7168 ");" 7169 7170 /* Create the "map" table that will (eventually) contain instructions 7171 ** for dealing with each page in the db that contains one or more 7172 ** records. */ 7173 "CREATE TABLE recovery.map(" 7174 "pgno INTEGER PRIMARY KEY, maxlen INT, intkey, root INT" 7175 ");" 7176 7177 /* Populate table [map]. If there are circular loops of pages in the 7178 ** database, the following adds all pages in such a loop to the map 7179 ** as individual root pages. This could be handled better. */ 7180 "WITH pages(i, maxlen) AS (" 7181 " SELECT page_count, (" 7182 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=page_count" 7183 " ) FROM pragma_page_count WHERE page_count>0" 7184 " UNION ALL" 7185 " SELECT i-1, (" 7186 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=i-1" 7187 " ) FROM pages WHERE i>=2" 7188 ")" 7189 "INSERT INTO recovery.map(pgno, maxlen, intkey, root) " 7190 " SELECT i, maxlen, NULL, (" 7191 " WITH p(orig, pgno, parent) AS (" 7192 " SELECT 0, i, (SELECT pgno FROM recovery.dbptr WHERE child=i)" 7193 " UNION " 7194 " SELECT i, p.parent, " 7195 " (SELECT pgno FROM recovery.dbptr WHERE child=p.parent) FROM p" 7196 " )" 7197 " SELECT pgno FROM p WHERE (parent IS NULL OR pgno = orig)" 7198 ") " 7199 "FROM pages WHERE maxlen IS NOT NULL AND i NOT IN freelist;" 7200 "UPDATE recovery.map AS o SET intkey = (" 7201 " SELECT substr(data, 1, 1)==X'0D' FROM sqlite_dbpage WHERE pgno=o.pgno" 7202 ");" 7203 7204 /* Extract data from page 1 and any linked pages into table 7205 ** recovery.schema. With the same schema as an sqlite_schema table. */ 7206 "CREATE TABLE recovery.schema(type, name, tbl_name, rootpage, sql);" 7207 "INSERT INTO recovery.schema SELECT " 7208 " max(CASE WHEN field=0 THEN value ELSE NULL END)," 7209 " max(CASE WHEN field=1 THEN value ELSE NULL END)," 7210 " max(CASE WHEN field=2 THEN value ELSE NULL END)," 7211 " max(CASE WHEN field=3 THEN value ELSE NULL END)," 7212 " max(CASE WHEN field=4 THEN value ELSE NULL END)" 7213 "FROM sqlite_dbdata WHERE pgno IN (" 7214 " SELECT pgno FROM recovery.map WHERE root=1" 7215 ")" 7216 "GROUP BY pgno, cell;" 7217 "CREATE INDEX recovery.schema_rootpage ON schema(rootpage);" 7218 ); 7219 7220 /* Open a transaction, then print out all non-virtual, non-"sqlite_%" 7221 ** CREATE TABLE statements that extracted from the existing schema. */ 7222 if( rc==SQLITE_OK ){ 7223 sqlite3_stmt *pStmt = 0; 7224 /* ".recover" might output content in an order which causes immediate 7225 ** foreign key constraints to be violated. So disable foreign-key 7226 ** constraint enforcement to prevent problems when running the output 7227 ** script. */ 7228 raw_printf(pState->out, "PRAGMA foreign_keys=OFF;\n"); 7229 raw_printf(pState->out, "BEGIN;\n"); 7230 raw_printf(pState->out, "PRAGMA writable_schema = on;\n"); 7231 shellPrepare(pState->db, &rc, 7232 "SELECT sql FROM recovery.schema " 7233 "WHERE type='table' AND sql LIKE 'create table%'", &pStmt 7234 ); 7235 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 7236 const char *zCreateTable = (const char*)sqlite3_column_text(pStmt, 0); 7237 raw_printf(pState->out, "CREATE TABLE IF NOT EXISTS %s;\n", 7238 &zCreateTable[12] 7239 ); 7240 } 7241 shellFinalize(&rc, pStmt); 7242 } 7243 7244 /* Figure out if an orphan table will be required. And if so, how many 7245 ** user columns it should contain */ 7246 shellPrepare(pState->db, &rc, 7247 "SELECT coalesce(max(maxlen), -2) FROM recovery.map WHERE root>1" 7248 , &pLoop 7249 ); 7250 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){ 7251 nOrphan = sqlite3_column_int(pLoop, 0); 7252 } 7253 shellFinalize(&rc, pLoop); 7254 pLoop = 0; 7255 7256 shellPrepare(pState->db, &rc, 7257 "SELECT pgno FROM recovery.map WHERE root=?", &pPages 7258 ); 7259 7260 shellPrepare(pState->db, &rc, 7261 "SELECT max(field), group_concat(shell_escape_crnl(quote" 7262 "(case when (? AND field<0) then NULL else value end)" 7263 "), ', ')" 7264 ", min(field) " 7265 "FROM sqlite_dbdata WHERE pgno = ? AND field != ?" 7266 "GROUP BY cell", &pCells 7267 ); 7268 7269 /* Loop through each root page. */ 7270 shellPrepare(pState->db, &rc, 7271 "SELECT root, intkey, max(maxlen) FROM recovery.map" 7272 " WHERE root>1 GROUP BY root, intkey ORDER BY root=(" 7273 " SELECT rootpage FROM recovery.schema WHERE name='sqlite_sequence'" 7274 ")", &pLoop 7275 ); 7276 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){ 7277 int iRoot = sqlite3_column_int(pLoop, 0); 7278 int bIntkey = sqlite3_column_int(pLoop, 1); 7279 int nCol = sqlite3_column_int(pLoop, 2); 7280 int bNoop = 0; 7281 RecoverTable *pTab; 7282 7283 assert( bIntkey==0 || bIntkey==1 ); 7284 pTab = recoverFindTable(pState, &rc, iRoot, bIntkey, nCol, &bNoop); 7285 if( bNoop || rc ) continue; 7286 if( pTab==0 ){ 7287 if( pOrphan==0 ){ 7288 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan); 7289 } 7290 pTab = pOrphan; 7291 if( pTab==0 ) break; 7292 } 7293 7294 if( 0==sqlite3_stricmp(pTab->zQuoted, "\"sqlite_sequence\"") ){ 7295 raw_printf(pState->out, "DELETE FROM sqlite_sequence;\n"); 7296 } 7297 sqlite3_bind_int(pPages, 1, iRoot); 7298 if( bRowids==0 && pTab->iPk<0 ){ 7299 sqlite3_bind_int(pCells, 1, 1); 7300 }else{ 7301 sqlite3_bind_int(pCells, 1, 0); 7302 } 7303 sqlite3_bind_int(pCells, 3, pTab->iPk); 7304 7305 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPages) ){ 7306 int iPgno = sqlite3_column_int(pPages, 0); 7307 sqlite3_bind_int(pCells, 2, iPgno); 7308 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pCells) ){ 7309 int nField = sqlite3_column_int(pCells, 0); 7310 int iMin = sqlite3_column_int(pCells, 2); 7311 const char *zVal = (const char*)sqlite3_column_text(pCells, 1); 7312 7313 RecoverTable *pTab2 = pTab; 7314 if( pTab!=pOrphan && (iMin<0)!=bIntkey ){ 7315 if( pOrphan==0 ){ 7316 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan); 7317 } 7318 pTab2 = pOrphan; 7319 if( pTab2==0 ) break; 7320 } 7321 7322 nField = nField+1; 7323 if( pTab2==pOrphan ){ 7324 raw_printf(pState->out, 7325 "INSERT INTO %s VALUES(%d, %d, %d, %s%s%s);\n", 7326 pTab2->zQuoted, iRoot, iPgno, nField, 7327 iMin<0 ? "" : "NULL, ", zVal, pTab2->azlCol[nField] 7328 ); 7329 }else{ 7330 raw_printf(pState->out, "INSERT INTO %s(%s) VALUES( %s );\n", 7331 pTab2->zQuoted, pTab2->azlCol[nField], zVal 7332 ); 7333 } 7334 } 7335 shellReset(&rc, pCells); 7336 } 7337 shellReset(&rc, pPages); 7338 if( pTab!=pOrphan ) recoverFreeTable(pTab); 7339 } 7340 shellFinalize(&rc, pLoop); 7341 shellFinalize(&rc, pPages); 7342 shellFinalize(&rc, pCells); 7343 recoverFreeTable(pOrphan); 7344 7345 /* The rest of the schema */ 7346 if( rc==SQLITE_OK ){ 7347 sqlite3_stmt *pStmt = 0; 7348 shellPrepare(pState->db, &rc, 7349 "SELECT sql, name FROM recovery.schema " 7350 "WHERE sql NOT LIKE 'create table%'", &pStmt 7351 ); 7352 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 7353 const char *zSql = (const char*)sqlite3_column_text(pStmt, 0); 7354 if( sqlite3_strnicmp(zSql, "create virt", 11)==0 ){ 7355 const char *zName = (const char*)sqlite3_column_text(pStmt, 1); 7356 char *zPrint = shellMPrintf(&rc, 7357 "INSERT INTO sqlite_schema VALUES('table', %Q, %Q, 0, %Q)", 7358 zName, zName, zSql 7359 ); 7360 raw_printf(pState->out, "%s;\n", zPrint); 7361 sqlite3_free(zPrint); 7362 }else{ 7363 raw_printf(pState->out, "%s;\n", zSql); 7364 } 7365 } 7366 shellFinalize(&rc, pStmt); 7367 } 7368 7369 if( rc==SQLITE_OK ){ 7370 raw_printf(pState->out, "PRAGMA writable_schema = off;\n"); 7371 raw_printf(pState->out, "COMMIT;\n"); 7372 } 7373 sqlite3_exec(pState->db, "DETACH recovery", 0, 0, 0); 7374 return rc; 7375} 7376#endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */ 7377 7378 7379/* 7380** If an input line begins with "." then invoke this routine to 7381** process that line. 7382** 7383** Return 1 on error, 2 to exit, and 0 otherwise. 7384*/ 7385static int do_meta_command(char *zLine, ShellState *p){ 7386 int h = 1; 7387 int nArg = 0; 7388 int n, c; 7389 int rc = 0; 7390 char *azArg[52]; 7391 7392#ifndef SQLITE_OMIT_VIRTUALTABLE 7393 if( p->expert.pExpert ){ 7394 expertFinish(p, 1, 0); 7395 } 7396#endif 7397 7398 /* Parse the input line into tokens. 7399 */ 7400 while( zLine[h] && nArg<ArraySize(azArg)-1 ){ 7401 while( IsSpace(zLine[h]) ){ h++; } 7402 if( zLine[h]==0 ) break; 7403 if( zLine[h]=='\'' || zLine[h]=='"' ){ 7404 int delim = zLine[h++]; 7405 azArg[nArg++] = &zLine[h]; 7406 while( zLine[h] && zLine[h]!=delim ){ 7407 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++; 7408 h++; 7409 } 7410 if( zLine[h]==delim ){ 7411 zLine[h++] = 0; 7412 } 7413 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]); 7414 }else{ 7415 azArg[nArg++] = &zLine[h]; 7416 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; } 7417 if( zLine[h] ) zLine[h++] = 0; 7418 resolve_backslashes(azArg[nArg-1]); 7419 } 7420 } 7421 azArg[nArg] = 0; 7422 7423 /* Process the input line. 7424 */ 7425 if( nArg==0 ) return 0; /* no tokens, no error */ 7426 n = strlen30(azArg[0]); 7427 c = azArg[0][0]; 7428 clearTempFile(p); 7429 7430#ifndef SQLITE_OMIT_AUTHORIZATION 7431 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){ 7432 if( nArg!=2 ){ 7433 raw_printf(stderr, "Usage: .auth ON|OFF\n"); 7434 rc = 1; 7435 goto meta_command_exit; 7436 } 7437 open_db(p, 0); 7438 if( booleanValue(azArg[1]) ){ 7439 sqlite3_set_authorizer(p->db, shellAuth, p); 7440 }else{ 7441 sqlite3_set_authorizer(p->db, 0, 0); 7442 } 7443 }else 7444#endif 7445 7446#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 7447 if( c=='a' && strncmp(azArg[0], "archive", n)==0 ){ 7448 open_db(p, 0); 7449 rc = arDotCommand(p, 0, azArg, nArg); 7450 }else 7451#endif 7452 7453 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0) 7454 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0) 7455 ){ 7456 const char *zDestFile = 0; 7457 const char *zDb = 0; 7458 sqlite3 *pDest; 7459 sqlite3_backup *pBackup; 7460 int j; 7461 int bAsync = 0; 7462 const char *zVfs = 0; 7463 for(j=1; j<nArg; j++){ 7464 const char *z = azArg[j]; 7465 if( z[0]=='-' ){ 7466 if( z[1]=='-' ) z++; 7467 if( strcmp(z, "-append")==0 ){ 7468 zVfs = "apndvfs"; 7469 }else 7470 if( strcmp(z, "-async")==0 ){ 7471 bAsync = 1; 7472 }else 7473 { 7474 utf8_printf(stderr, "unknown option: %s\n", azArg[j]); 7475 return 1; 7476 } 7477 }else if( zDestFile==0 ){ 7478 zDestFile = azArg[j]; 7479 }else if( zDb==0 ){ 7480 zDb = zDestFile; 7481 zDestFile = azArg[j]; 7482 }else{ 7483 raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n"); 7484 return 1; 7485 } 7486 } 7487 if( zDestFile==0 ){ 7488 raw_printf(stderr, "missing FILENAME argument on .backup\n"); 7489 return 1; 7490 } 7491 if( zDb==0 ) zDb = "main"; 7492 rc = sqlite3_open_v2(zDestFile, &pDest, 7493 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs); 7494 if( rc!=SQLITE_OK ){ 7495 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile); 7496 close_db(pDest); 7497 return 1; 7498 } 7499 if( bAsync ){ 7500 sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;", 7501 0, 0, 0); 7502 } 7503 open_db(p, 0); 7504 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb); 7505 if( pBackup==0 ){ 7506 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 7507 close_db(pDest); 7508 return 1; 7509 } 7510 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} 7511 sqlite3_backup_finish(pBackup); 7512 if( rc==SQLITE_DONE ){ 7513 rc = 0; 7514 }else{ 7515 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 7516 rc = 1; 7517 } 7518 close_db(pDest); 7519 }else 7520 7521 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){ 7522 if( nArg==2 ){ 7523 bail_on_error = booleanValue(azArg[1]); 7524 }else{ 7525 raw_printf(stderr, "Usage: .bail on|off\n"); 7526 rc = 1; 7527 } 7528 }else 7529 7530 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){ 7531 if( nArg==2 ){ 7532 if( booleanValue(azArg[1]) ){ 7533 setBinaryMode(p->out, 1); 7534 }else{ 7535 setTextMode(p->out, 1); 7536 } 7537 }else{ 7538 raw_printf(stderr, "Usage: .binary on|off\n"); 7539 rc = 1; 7540 } 7541 }else 7542 7543 if( c=='c' && strcmp(azArg[0],"cd")==0 ){ 7544 if( nArg==2 ){ 7545#if defined(_WIN32) || defined(WIN32) 7546 wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]); 7547 rc = !SetCurrentDirectoryW(z); 7548 sqlite3_free(z); 7549#else 7550 rc = chdir(azArg[1]); 7551#endif 7552 if( rc ){ 7553 utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]); 7554 rc = 1; 7555 } 7556 }else{ 7557 raw_printf(stderr, "Usage: .cd DIRECTORY\n"); 7558 rc = 1; 7559 } 7560 }else 7561 7562 /* The undocumented ".breakpoint" command causes a call to the no-op 7563 ** routine named test_breakpoint(). 7564 */ 7565 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){ 7566 test_breakpoint(); 7567 }else 7568 7569 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){ 7570 if( nArg==2 ){ 7571 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]); 7572 }else{ 7573 raw_printf(stderr, "Usage: .changes on|off\n"); 7574 rc = 1; 7575 } 7576 }else 7577 7578 /* Cancel output redirection, if it is currently set (by .testcase) 7579 ** Then read the content of the testcase-out.txt file and compare against 7580 ** azArg[1]. If there are differences, report an error and exit. 7581 */ 7582 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){ 7583 char *zRes = 0; 7584 output_reset(p); 7585 if( nArg!=2 ){ 7586 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n"); 7587 rc = 2; 7588 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){ 7589 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n"); 7590 rc = 2; 7591 }else if( testcase_glob(azArg[1],zRes)==0 ){ 7592 utf8_printf(stderr, 7593 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n", 7594 p->zTestcase, azArg[1], zRes); 7595 rc = 1; 7596 }else{ 7597 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase); 7598 p->nCheck++; 7599 } 7600 sqlite3_free(zRes); 7601 }else 7602 7603 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){ 7604 if( nArg==2 ){ 7605 tryToClone(p, azArg[1]); 7606 }else{ 7607 raw_printf(stderr, "Usage: .clone FILENAME\n"); 7608 rc = 1; 7609 } 7610 }else 7611 7612 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){ 7613 char **azName = 0; 7614 int nName = 0; 7615 sqlite3_stmt *pStmt; 7616 int i; 7617 open_db(p, 0); 7618 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); 7619 if( rc ){ 7620 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 7621 rc = 1; 7622 }else{ 7623 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 7624 const char *zSchema = (const char *)sqlite3_column_text(pStmt,1); 7625 const char *zFile = (const char*)sqlite3_column_text(pStmt,2); 7626 azName = sqlite3_realloc(azName, (nName+1)*2*sizeof(char*)); 7627 if( azName==0 ){ shell_out_of_memory(); /* Does not return */ } 7628 azName[nName*2] = strdup(zSchema); 7629 azName[nName*2+1] = strdup(zFile); 7630 nName++; 7631 } 7632 } 7633 sqlite3_finalize(pStmt); 7634 for(i=0; i<nName; i++){ 7635 int eTxn = sqlite3_txn_state(p->db, azName[i*2]); 7636 int bRdonly = sqlite3_db_readonly(p->db, azName[i*2]); 7637 const char *z = azName[i*2+1]; 7638 utf8_printf(p->out, "%s: %s %s%s\n", 7639 azName[i*2], 7640 z && z[0] ? z : "\"\"", 7641 bRdonly ? "r/o" : "r/w", 7642 eTxn==SQLITE_TXN_NONE ? "" : 7643 eTxn==SQLITE_TXN_READ ? " read-txn" : " write-txn"); 7644 free(azName[i*2]); 7645 free(azName[i*2+1]); 7646 } 7647 sqlite3_free(azName); 7648 }else 7649 7650 if( c=='d' && n>=3 && strncmp(azArg[0], "dbconfig", n)==0 ){ 7651 static const struct DbConfigChoices { 7652 const char *zName; 7653 int op; 7654 } aDbConfig[] = { 7655 { "defensive", SQLITE_DBCONFIG_DEFENSIVE }, 7656 { "dqs_ddl", SQLITE_DBCONFIG_DQS_DDL }, 7657 { "dqs_dml", SQLITE_DBCONFIG_DQS_DML }, 7658 { "enable_fkey", SQLITE_DBCONFIG_ENABLE_FKEY }, 7659 { "enable_qpsg", SQLITE_DBCONFIG_ENABLE_QPSG }, 7660 { "enable_trigger", SQLITE_DBCONFIG_ENABLE_TRIGGER }, 7661 { "enable_view", SQLITE_DBCONFIG_ENABLE_VIEW }, 7662 { "fts3_tokenizer", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER }, 7663 { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE }, 7664 { "legacy_file_format", SQLITE_DBCONFIG_LEGACY_FILE_FORMAT }, 7665 { "load_extension", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION }, 7666 { "no_ckpt_on_close", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE }, 7667 { "reset_database", SQLITE_DBCONFIG_RESET_DATABASE }, 7668 { "trigger_eqp", SQLITE_DBCONFIG_TRIGGER_EQP }, 7669 { "trusted_schema", SQLITE_DBCONFIG_TRUSTED_SCHEMA }, 7670 { "writable_schema", SQLITE_DBCONFIG_WRITABLE_SCHEMA }, 7671 }; 7672 int ii, v; 7673 open_db(p, 0); 7674 for(ii=0; ii<ArraySize(aDbConfig); ii++){ 7675 if( nArg>1 && strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue; 7676 if( nArg>=3 ){ 7677 sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0); 7678 } 7679 sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v); 7680 utf8_printf(p->out, "%19s %s\n", aDbConfig[ii].zName, v ? "on" : "off"); 7681 if( nArg>1 ) break; 7682 } 7683 if( nArg>1 && ii==ArraySize(aDbConfig) ){ 7684 utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]); 7685 utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n"); 7686 } 7687 }else 7688 7689 if( c=='d' && n>=3 && strncmp(azArg[0], "dbinfo", n)==0 ){ 7690 rc = shell_dbinfo_command(p, nArg, azArg); 7691 }else 7692 7693#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 7694 if( c=='r' && strncmp(azArg[0], "recover", n)==0 ){ 7695 open_db(p, 0); 7696 rc = recoverDatabaseCmd(p, nArg, azArg); 7697 }else 7698#endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */ 7699 7700 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ 7701 char *zLike = 0; 7702 char *zSql; 7703 int i; 7704 int savedShowHeader = p->showHeader; 7705 int savedShellFlags = p->shellFlgs; 7706 ShellClearFlag(p, 7707 SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo 7708 |SHFLG_DumpDataOnly|SHFLG_DumpNoSys); 7709 for(i=1; i<nArg; i++){ 7710 if( azArg[i][0]=='-' ){ 7711 const char *z = azArg[i]+1; 7712 if( z[0]=='-' ) z++; 7713 if( strcmp(z,"preserve-rowids")==0 ){ 7714#ifdef SQLITE_OMIT_VIRTUALTABLE 7715 raw_printf(stderr, "The --preserve-rowids option is not compatible" 7716 " with SQLITE_OMIT_VIRTUALTABLE\n"); 7717 rc = 1; 7718 sqlite3_free(zLike); 7719 goto meta_command_exit; 7720#else 7721 ShellSetFlag(p, SHFLG_PreserveRowid); 7722#endif 7723 }else 7724 if( strcmp(z,"newlines")==0 ){ 7725 ShellSetFlag(p, SHFLG_Newlines); 7726 }else 7727 if( strcmp(z,"data-only")==0 ){ 7728 ShellSetFlag(p, SHFLG_DumpDataOnly); 7729 }else 7730 if( strcmp(z,"nosys")==0 ){ 7731 ShellSetFlag(p, SHFLG_DumpNoSys); 7732 }else 7733 { 7734 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]); 7735 rc = 1; 7736 sqlite3_free(zLike); 7737 goto meta_command_exit; 7738 } 7739 }else if( zLike ){ 7740 zLike = sqlite3_mprintf("%z OR name LIKE %Q ESCAPE '\\'", 7741 zLike, azArg[i]); 7742 }else{ 7743 zLike = sqlite3_mprintf("name LIKE %Q ESCAPE '\\'", azArg[i]); 7744 } 7745 } 7746 7747 open_db(p, 0); 7748 7749 if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){ 7750 /* When playing back a "dump", the content might appear in an order 7751 ** which causes immediate foreign key constraints to be violated. 7752 ** So disable foreign-key constraint enforcement to prevent problems. */ 7753 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n"); 7754 raw_printf(p->out, "BEGIN TRANSACTION;\n"); 7755 } 7756 p->writableSchema = 0; 7757 p->showHeader = 0; 7758 /* Set writable_schema=ON since doing so forces SQLite to initialize 7759 ** as much of the schema as it can even if the sqlite_schema table is 7760 ** corrupt. */ 7761 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0); 7762 p->nErr = 0; 7763 if( zLike==0 ) zLike = sqlite3_mprintf("true"); 7764 zSql = sqlite3_mprintf( 7765 "SELECT name, type, sql FROM sqlite_schema " 7766 "WHERE (%s) AND type=='table'" 7767 " AND sql NOT NULL" 7768 " ORDER BY tbl_name='sqlite_sequence', rowid", 7769 zLike 7770 ); 7771 run_schema_dump_query(p,zSql); 7772 sqlite3_free(zSql); 7773 if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){ 7774 zSql = sqlite3_mprintf( 7775 "SELECT sql FROM sqlite_schema " 7776 "WHERE (%s) AND sql NOT NULL" 7777 " AND type IN ('index','trigger','view')", 7778 zLike 7779 ); 7780 run_table_dump_query(p, zSql); 7781 sqlite3_free(zSql); 7782 } 7783 sqlite3_free(zLike); 7784 if( p->writableSchema ){ 7785 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n"); 7786 p->writableSchema = 0; 7787 } 7788 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 7789 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0); 7790 if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){ 7791 raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n"); 7792 } 7793 p->showHeader = savedShowHeader; 7794 p->shellFlgs = savedShellFlags; 7795 }else 7796 7797 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){ 7798 if( nArg==2 ){ 7799 setOrClearFlag(p, SHFLG_Echo, azArg[1]); 7800 }else{ 7801 raw_printf(stderr, "Usage: .echo on|off\n"); 7802 rc = 1; 7803 } 7804 }else 7805 7806 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){ 7807 if( nArg==2 ){ 7808 p->autoEQPtest = 0; 7809 if( p->autoEQPtrace ){ 7810 if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0); 7811 p->autoEQPtrace = 0; 7812 } 7813 if( strcmp(azArg[1],"full")==0 ){ 7814 p->autoEQP = AUTOEQP_full; 7815 }else if( strcmp(azArg[1],"trigger")==0 ){ 7816 p->autoEQP = AUTOEQP_trigger; 7817#ifdef SQLITE_DEBUG 7818 }else if( strcmp(azArg[1],"test")==0 ){ 7819 p->autoEQP = AUTOEQP_on; 7820 p->autoEQPtest = 1; 7821 }else if( strcmp(azArg[1],"trace")==0 ){ 7822 p->autoEQP = AUTOEQP_full; 7823 p->autoEQPtrace = 1; 7824 open_db(p, 0); 7825 sqlite3_exec(p->db, "SELECT name FROM sqlite_schema LIMIT 1", 0, 0, 0); 7826 sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0); 7827#endif 7828 }else{ 7829 p->autoEQP = (u8)booleanValue(azArg[1]); 7830 } 7831 }else{ 7832 raw_printf(stderr, "Usage: .eqp off|on|trace|trigger|full\n"); 7833 rc = 1; 7834 } 7835 }else 7836 7837 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){ 7838 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc); 7839 rc = 2; 7840 }else 7841 7842 /* The ".explain" command is automatic now. It is largely pointless. It 7843 ** retained purely for backwards compatibility */ 7844 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ 7845 int val = 1; 7846 if( nArg>=2 ){ 7847 if( strcmp(azArg[1],"auto")==0 ){ 7848 val = 99; 7849 }else{ 7850 val = booleanValue(azArg[1]); 7851 } 7852 } 7853 if( val==1 && p->mode!=MODE_Explain ){ 7854 p->normalMode = p->mode; 7855 p->mode = MODE_Explain; 7856 p->autoExplain = 0; 7857 }else if( val==0 ){ 7858 if( p->mode==MODE_Explain ) p->mode = p->normalMode; 7859 p->autoExplain = 0; 7860 }else if( val==99 ){ 7861 if( p->mode==MODE_Explain ) p->mode = p->normalMode; 7862 p->autoExplain = 1; 7863 } 7864 }else 7865 7866#ifndef SQLITE_OMIT_VIRTUALTABLE 7867 if( c=='e' && strncmp(azArg[0], "expert", n)==0 ){ 7868 open_db(p, 0); 7869 expertDotCommand(p, azArg, nArg); 7870 }else 7871#endif 7872 7873 if( c=='f' && strncmp(azArg[0], "filectrl", n)==0 ){ 7874 static const struct { 7875 const char *zCtrlName; /* Name of a test-control option */ 7876 int ctrlCode; /* Integer code for that option */ 7877 const char *zUsage; /* Usage notes */ 7878 } aCtrl[] = { 7879 { "size_limit", SQLITE_FCNTL_SIZE_LIMIT, "[LIMIT]" }, 7880 { "chunk_size", SQLITE_FCNTL_CHUNK_SIZE, "SIZE" }, 7881 /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY, "COUNT DELAY" },*/ 7882 { "persist_wal", SQLITE_FCNTL_PERSIST_WAL, "[BOOLEAN]" }, 7883 { "psow", SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]" }, 7884 /* { "pragma", SQLITE_FCNTL_PRAGMA, "NAME ARG" },*/ 7885 { "tempfilename", SQLITE_FCNTL_TEMPFILENAME, "" }, 7886 { "has_moved", SQLITE_FCNTL_HAS_MOVED, "" }, 7887 { "lock_timeout", SQLITE_FCNTL_LOCK_TIMEOUT, "MILLISEC" }, 7888 { "reserve_bytes", SQLITE_FCNTL_RESERVE_BYTES, "[N]" }, 7889 }; 7890 int filectrl = -1; 7891 int iCtrl = -1; 7892 sqlite3_int64 iRes = 0; /* Integer result to display if rc2==1 */ 7893 int isOk = 0; /* 0: usage 1: %lld 2: no-result */ 7894 int n2, i; 7895 const char *zCmd = 0; 7896 const char *zSchema = 0; 7897 7898 open_db(p, 0); 7899 zCmd = nArg>=2 ? azArg[1] : "help"; 7900 7901 if( zCmd[0]=='-' 7902 && (strcmp(zCmd,"--schema")==0 || strcmp(zCmd,"-schema")==0) 7903 && nArg>=4 7904 ){ 7905 zSchema = azArg[2]; 7906 for(i=3; i<nArg; i++) azArg[i-2] = azArg[i]; 7907 nArg -= 2; 7908 zCmd = azArg[1]; 7909 } 7910 7911 /* The argument can optionally begin with "-" or "--" */ 7912 if( zCmd[0]=='-' && zCmd[1] ){ 7913 zCmd++; 7914 if( zCmd[0]=='-' && zCmd[1] ) zCmd++; 7915 } 7916 7917 /* --help lists all file-controls */ 7918 if( strcmp(zCmd,"help")==0 ){ 7919 utf8_printf(p->out, "Available file-controls:\n"); 7920 for(i=0; i<ArraySize(aCtrl); i++){ 7921 utf8_printf(p->out, " .filectrl %s %s\n", 7922 aCtrl[i].zCtrlName, aCtrl[i].zUsage); 7923 } 7924 rc = 1; 7925 goto meta_command_exit; 7926 } 7927 7928 /* convert filectrl text option to value. allow any unique prefix 7929 ** of the option name, or a numerical value. */ 7930 n2 = strlen30(zCmd); 7931 for(i=0; i<ArraySize(aCtrl); i++){ 7932 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){ 7933 if( filectrl<0 ){ 7934 filectrl = aCtrl[i].ctrlCode; 7935 iCtrl = i; 7936 }else{ 7937 utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n" 7938 "Use \".filectrl --help\" for help\n", zCmd); 7939 rc = 1; 7940 goto meta_command_exit; 7941 } 7942 } 7943 } 7944 if( filectrl<0 ){ 7945 utf8_printf(stderr,"Error: unknown file-control: %s\n" 7946 "Use \".filectrl --help\" for help\n", zCmd); 7947 }else{ 7948 switch(filectrl){ 7949 case SQLITE_FCNTL_SIZE_LIMIT: { 7950 if( nArg!=2 && nArg!=3 ) break; 7951 iRes = nArg==3 ? integerValue(azArg[2]) : -1; 7952 sqlite3_file_control(p->db, zSchema, SQLITE_FCNTL_SIZE_LIMIT, &iRes); 7953 isOk = 1; 7954 break; 7955 } 7956 case SQLITE_FCNTL_LOCK_TIMEOUT: 7957 case SQLITE_FCNTL_CHUNK_SIZE: { 7958 int x; 7959 if( nArg!=3 ) break; 7960 x = (int)integerValue(azArg[2]); 7961 sqlite3_file_control(p->db, zSchema, filectrl, &x); 7962 isOk = 2; 7963 break; 7964 } 7965 case SQLITE_FCNTL_PERSIST_WAL: 7966 case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { 7967 int x; 7968 if( nArg!=2 && nArg!=3 ) break; 7969 x = nArg==3 ? booleanValue(azArg[2]) : -1; 7970 sqlite3_file_control(p->db, zSchema, filectrl, &x); 7971 iRes = x; 7972 isOk = 1; 7973 break; 7974 } 7975 case SQLITE_FCNTL_HAS_MOVED: { 7976 int x; 7977 if( nArg!=2 ) break; 7978 sqlite3_file_control(p->db, zSchema, filectrl, &x); 7979 iRes = x; 7980 isOk = 1; 7981 break; 7982 } 7983 case SQLITE_FCNTL_TEMPFILENAME: { 7984 char *z = 0; 7985 if( nArg!=2 ) break; 7986 sqlite3_file_control(p->db, zSchema, filectrl, &z); 7987 if( z ){ 7988 utf8_printf(p->out, "%s\n", z); 7989 sqlite3_free(z); 7990 } 7991 isOk = 2; 7992 break; 7993 } 7994 case SQLITE_FCNTL_RESERVE_BYTES: { 7995 int x; 7996 if( nArg>=3 ){ 7997 x = atoi(azArg[2]); 7998 sqlite3_file_control(p->db, zSchema, filectrl, &x); 7999 } 8000 x = -1; 8001 sqlite3_file_control(p->db, zSchema, filectrl, &x); 8002 utf8_printf(p->out,"%d\n", x); 8003 isOk = 2; 8004 break; 8005 } 8006 } 8007 } 8008 if( isOk==0 && iCtrl>=0 ){ 8009 utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage); 8010 rc = 1; 8011 }else if( isOk==1 ){ 8012 char zBuf[100]; 8013 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes); 8014 raw_printf(p->out, "%s\n", zBuf); 8015 } 8016 }else 8017 8018 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){ 8019 ShellState data; 8020 char *zErrMsg = 0; 8021 int doStats = 0; 8022 memcpy(&data, p, sizeof(data)); 8023 data.showHeader = 0; 8024 data.cMode = data.mode = MODE_Semi; 8025 if( nArg==2 && optionMatch(azArg[1], "indent") ){ 8026 data.cMode = data.mode = MODE_Pretty; 8027 nArg = 1; 8028 } 8029 if( nArg!=1 ){ 8030 raw_printf(stderr, "Usage: .fullschema ?--indent?\n"); 8031 rc = 1; 8032 goto meta_command_exit; 8033 } 8034 open_db(p, 0); 8035 rc = sqlite3_exec(p->db, 8036 "SELECT sql FROM" 8037 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" 8038 " FROM sqlite_schema UNION ALL" 8039 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_schema) " 8040 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " 8041 "ORDER BY rowid", 8042 callback, &data, &zErrMsg 8043 ); 8044 if( rc==SQLITE_OK ){ 8045 sqlite3_stmt *pStmt; 8046 rc = sqlite3_prepare_v2(p->db, 8047 "SELECT rowid FROM sqlite_schema" 8048 " WHERE name GLOB 'sqlite_stat[134]'", 8049 -1, &pStmt, 0); 8050 doStats = sqlite3_step(pStmt)==SQLITE_ROW; 8051 sqlite3_finalize(pStmt); 8052 } 8053 if( doStats==0 ){ 8054 raw_printf(p->out, "/* No STAT tables available */\n"); 8055 }else{ 8056 raw_printf(p->out, "ANALYZE sqlite_schema;\n"); 8057 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_schema'", 8058 callback, &data, &zErrMsg); 8059 data.cMode = data.mode = MODE_Insert; 8060 data.zDestTable = "sqlite_stat1"; 8061 shell_exec(&data, "SELECT * FROM sqlite_stat1", &zErrMsg); 8062 data.zDestTable = "sqlite_stat4"; 8063 shell_exec(&data, "SELECT * FROM sqlite_stat4", &zErrMsg); 8064 raw_printf(p->out, "ANALYZE sqlite_schema;\n"); 8065 } 8066 }else 8067 8068 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){ 8069 if( nArg==2 ){ 8070 p->showHeader = booleanValue(azArg[1]); 8071 p->shellFlgs |= SHFLG_HeaderSet; 8072 }else{ 8073 raw_printf(stderr, "Usage: .headers on|off\n"); 8074 rc = 1; 8075 } 8076 }else 8077 8078 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ 8079 if( nArg>=2 ){ 8080 n = showHelp(p->out, azArg[1]); 8081 if( n==0 ){ 8082 utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]); 8083 } 8084 }else{ 8085 showHelp(p->out, 0); 8086 } 8087 }else 8088 8089 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){ 8090 char *zTable = 0; /* Insert data into this table */ 8091 char *zFile = 0; /* Name of file to extra content from */ 8092 sqlite3_stmt *pStmt = NULL; /* A statement */ 8093 int nCol; /* Number of columns in the table */ 8094 int nByte; /* Number of bytes in an SQL string */ 8095 int i, j; /* Loop counters */ 8096 int needCommit; /* True to COMMIT or ROLLBACK at end */ 8097 int nSep; /* Number of bytes in p->colSeparator[] */ 8098 char *zSql; /* An SQL statement */ 8099 ImportCtx sCtx; /* Reader context */ 8100 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */ 8101 int eVerbose = 0; /* Larger for more console output */ 8102 int nSkip = 0; /* Initial lines to skip */ 8103 int useOutputMode = 1; /* Use output mode to determine separators */ 8104 8105 memset(&sCtx, 0, sizeof(sCtx)); 8106 if( p->mode==MODE_Ascii ){ 8107 xRead = ascii_read_one_field; 8108 }else{ 8109 xRead = csv_read_one_field; 8110 } 8111 for(i=1; i<nArg; i++){ 8112 char *z = azArg[i]; 8113 if( z[0]=='-' && z[1]=='-' ) z++; 8114 if( z[0]!='-' ){ 8115 if( zFile==0 ){ 8116 zFile = z; 8117 }else if( zTable==0 ){ 8118 zTable = z; 8119 }else{ 8120 utf8_printf(p->out, "ERROR: extra argument: \"%s\". Usage:\n", z); 8121 showHelp(p->out, "import"); 8122 rc = 1; 8123 goto meta_command_exit; 8124 } 8125 }else if( strcmp(z,"-v")==0 ){ 8126 eVerbose++; 8127 }else if( strcmp(z,"-skip")==0 && i<nArg-1 ){ 8128 nSkip = integerValue(azArg[++i]); 8129 }else if( strcmp(z,"-ascii")==0 ){ 8130 sCtx.cColSep = SEP_Unit[0]; 8131 sCtx.cRowSep = SEP_Record[0]; 8132 xRead = ascii_read_one_field; 8133 useOutputMode = 0; 8134 }else if( strcmp(z,"-csv")==0 ){ 8135 sCtx.cColSep = ','; 8136 sCtx.cRowSep = '\n'; 8137 xRead = csv_read_one_field; 8138 useOutputMode = 0; 8139 }else{ 8140 utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n", z); 8141 showHelp(p->out, "import"); 8142 rc = 1; 8143 goto meta_command_exit; 8144 } 8145 } 8146 if( zTable==0 ){ 8147 utf8_printf(p->out, "ERROR: missing %s argument. Usage:\n", 8148 zFile==0 ? "FILE" : "TABLE"); 8149 showHelp(p->out, "import"); 8150 rc = 1; 8151 goto meta_command_exit; 8152 } 8153 seenInterrupt = 0; 8154 open_db(p, 0); 8155 if( useOutputMode ){ 8156 /* If neither the --csv or --ascii options are specified, then set 8157 ** the column and row separator characters from the output mode. */ 8158 nSep = strlen30(p->colSeparator); 8159 if( nSep==0 ){ 8160 raw_printf(stderr, 8161 "Error: non-null column separator required for import\n"); 8162 rc = 1; 8163 goto meta_command_exit; 8164 } 8165 if( nSep>1 ){ 8166 raw_printf(stderr, 8167 "Error: multi-character column separators not allowed" 8168 " for import\n"); 8169 rc = 1; 8170 goto meta_command_exit; 8171 } 8172 nSep = strlen30(p->rowSeparator); 8173 if( nSep==0 ){ 8174 raw_printf(stderr, 8175 "Error: non-null row separator required for import\n"); 8176 rc = 1; 8177 goto meta_command_exit; 8178 } 8179 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator,SEP_CrLf)==0 ){ 8180 /* When importing CSV (only), if the row separator is set to the 8181 ** default output row separator, change it to the default input 8182 ** row separator. This avoids having to maintain different input 8183 ** and output row separators. */ 8184 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 8185 nSep = strlen30(p->rowSeparator); 8186 } 8187 if( nSep>1 ){ 8188 raw_printf(stderr, "Error: multi-character row separators not allowed" 8189 " for import\n"); 8190 rc = 1; 8191 goto meta_command_exit; 8192 } 8193 sCtx.cColSep = p->colSeparator[0]; 8194 sCtx.cRowSep = p->rowSeparator[0]; 8195 } 8196 sCtx.zFile = zFile; 8197 sCtx.nLine = 1; 8198 if( sCtx.zFile[0]=='|' ){ 8199#ifdef SQLITE_OMIT_POPEN 8200 raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 8201 rc = 1; 8202 goto meta_command_exit; 8203#else 8204 sCtx.in = popen(sCtx.zFile+1, "r"); 8205 sCtx.zFile = "<pipe>"; 8206 sCtx.xCloser = pclose; 8207#endif 8208 }else{ 8209 sCtx.in = fopen(sCtx.zFile, "rb"); 8210 sCtx.xCloser = fclose; 8211 } 8212 if( sCtx.in==0 ){ 8213 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 8214 rc = 1; 8215 goto meta_command_exit; 8216 } 8217 if( eVerbose>=2 || (eVerbose>=1 && useOutputMode) ){ 8218 char zSep[2]; 8219 zSep[1] = 0; 8220 zSep[0] = sCtx.cColSep; 8221 utf8_printf(p->out, "Column separator "); 8222 output_c_string(p->out, zSep); 8223 utf8_printf(p->out, ", row separator "); 8224 zSep[0] = sCtx.cRowSep; 8225 output_c_string(p->out, zSep); 8226 utf8_printf(p->out, "\n"); 8227 } 8228 while( (nSkip--)>0 ){ 8229 while( xRead(&sCtx) && sCtx.cTerm==sCtx.cColSep ){} 8230 } 8231 zSql = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); 8232 if( zSql==0 ){ 8233 import_cleanup(&sCtx); 8234 shell_out_of_memory(); 8235 } 8236 nByte = strlen30(zSql); 8237 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 8238 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */ 8239 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){ 8240 char *zCreate = sqlite3_mprintf("CREATE TABLE \"%w\"", zTable); 8241 char cSep = '('; 8242 while( xRead(&sCtx) ){ 8243 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z); 8244 cSep = ','; 8245 if( sCtx.cTerm!=sCtx.cColSep ) break; 8246 } 8247 if( cSep=='(' ){ 8248 sqlite3_free(zCreate); 8249 import_cleanup(&sCtx); 8250 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile); 8251 rc = 1; 8252 goto meta_command_exit; 8253 } 8254 zCreate = sqlite3_mprintf("%z\n)", zCreate); 8255 if( eVerbose>=1 ){ 8256 utf8_printf(p->out, "%s\n", zCreate); 8257 } 8258 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0); 8259 sqlite3_free(zCreate); 8260 if( rc ){ 8261 utf8_printf(stderr, "CREATE TABLE \"%s\"(...) failed: %s\n", zTable, 8262 sqlite3_errmsg(p->db)); 8263 import_cleanup(&sCtx); 8264 rc = 1; 8265 goto meta_command_exit; 8266 } 8267 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 8268 } 8269 sqlite3_free(zSql); 8270 if( rc ){ 8271 if (pStmt) sqlite3_finalize(pStmt); 8272 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db)); 8273 import_cleanup(&sCtx); 8274 rc = 1; 8275 goto meta_command_exit; 8276 } 8277 nCol = sqlite3_column_count(pStmt); 8278 sqlite3_finalize(pStmt); 8279 pStmt = 0; 8280 if( nCol==0 ) return 0; /* no columns, no error */ 8281 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 ); 8282 if( zSql==0 ){ 8283 import_cleanup(&sCtx); 8284 shell_out_of_memory(); 8285 } 8286 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable); 8287 j = strlen30(zSql); 8288 for(i=1; i<nCol; i++){ 8289 zSql[j++] = ','; 8290 zSql[j++] = '?'; 8291 } 8292 zSql[j++] = ')'; 8293 zSql[j] = 0; 8294 if( eVerbose>=2 ){ 8295 utf8_printf(p->out, "Insert using: %s\n", zSql); 8296 } 8297 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 8298 sqlite3_free(zSql); 8299 if( rc ){ 8300 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 8301 if (pStmt) sqlite3_finalize(pStmt); 8302 import_cleanup(&sCtx); 8303 rc = 1; 8304 goto meta_command_exit; 8305 } 8306 needCommit = sqlite3_get_autocommit(p->db); 8307 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0); 8308 do{ 8309 int startLine = sCtx.nLine; 8310 for(i=0; i<nCol; i++){ 8311 char *z = xRead(&sCtx); 8312 /* 8313 ** Did we reach end-of-file before finding any columns? 8314 ** If so, stop instead of NULL filling the remaining columns. 8315 */ 8316 if( z==0 && i==0 ) break; 8317 /* 8318 ** Did we reach end-of-file OR end-of-line before finding any 8319 ** columns in ASCII mode? If so, stop instead of NULL filling 8320 ** the remaining columns. 8321 */ 8322 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break; 8323 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT); 8324 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){ 8325 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 8326 "filling the rest with NULL\n", 8327 sCtx.zFile, startLine, nCol, i+1); 8328 i += 2; 8329 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; } 8330 } 8331 } 8332 if( sCtx.cTerm==sCtx.cColSep ){ 8333 do{ 8334 xRead(&sCtx); 8335 i++; 8336 }while( sCtx.cTerm==sCtx.cColSep ); 8337 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 8338 "extras ignored\n", 8339 sCtx.zFile, startLine, nCol, i); 8340 } 8341 if( i>=nCol ){ 8342 sqlite3_step(pStmt); 8343 rc = sqlite3_reset(pStmt); 8344 if( rc!=SQLITE_OK ){ 8345 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, 8346 startLine, sqlite3_errmsg(p->db)); 8347 sCtx.nErr++; 8348 }else{ 8349 sCtx.nRow++; 8350 } 8351 } 8352 }while( sCtx.cTerm!=EOF ); 8353 8354 import_cleanup(&sCtx); 8355 sqlite3_finalize(pStmt); 8356 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0); 8357 if( eVerbose>0 ){ 8358 utf8_printf(p->out, 8359 "Added %d rows with %d errors using %d lines of input\n", 8360 sCtx.nRow, sCtx.nErr, sCtx.nLine-1); 8361 } 8362 }else 8363 8364#ifndef SQLITE_UNTESTABLE 8365 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){ 8366 char *zSql; 8367 char *zCollist = 0; 8368 sqlite3_stmt *pStmt; 8369 int tnum = 0; 8370 int isWO = 0; /* True if making an imposter of a WITHOUT ROWID table */ 8371 int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */ 8372 int i; 8373 if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){ 8374 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n" 8375 " .imposter off\n"); 8376 /* Also allowed, but not documented: 8377 ** 8378 ** .imposter TABLE IMPOSTER 8379 ** 8380 ** where TABLE is a WITHOUT ROWID table. In that case, the 8381 ** imposter is another WITHOUT ROWID table with the columns in 8382 ** storage order. */ 8383 rc = 1; 8384 goto meta_command_exit; 8385 } 8386 open_db(p, 0); 8387 if( nArg==2 ){ 8388 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1); 8389 goto meta_command_exit; 8390 } 8391 zSql = sqlite3_mprintf( 8392 "SELECT rootpage, 0 FROM sqlite_schema" 8393 " WHERE name='%q' AND type='index'" 8394 "UNION ALL " 8395 "SELECT rootpage, 1 FROM sqlite_schema" 8396 " WHERE name='%q' AND type='table'" 8397 " AND sql LIKE '%%without%%rowid%%'", 8398 azArg[1], azArg[1] 8399 ); 8400 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 8401 sqlite3_free(zSql); 8402 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 8403 tnum = sqlite3_column_int(pStmt, 0); 8404 isWO = sqlite3_column_int(pStmt, 1); 8405 } 8406 sqlite3_finalize(pStmt); 8407 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]); 8408 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 8409 sqlite3_free(zSql); 8410 i = 0; 8411 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 8412 char zLabel[20]; 8413 const char *zCol = (const char*)sqlite3_column_text(pStmt,2); 8414 i++; 8415 if( zCol==0 ){ 8416 if( sqlite3_column_int(pStmt,1)==-1 ){ 8417 zCol = "_ROWID_"; 8418 }else{ 8419 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i); 8420 zCol = zLabel; 8421 } 8422 } 8423 if( isWO && lenPK==0 && sqlite3_column_int(pStmt,5)==0 && zCollist ){ 8424 lenPK = (int)strlen(zCollist); 8425 } 8426 if( zCollist==0 ){ 8427 zCollist = sqlite3_mprintf("\"%w\"", zCol); 8428 }else{ 8429 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol); 8430 } 8431 } 8432 sqlite3_finalize(pStmt); 8433 if( i==0 || tnum==0 ){ 8434 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]); 8435 rc = 1; 8436 sqlite3_free(zCollist); 8437 goto meta_command_exit; 8438 } 8439 if( lenPK==0 ) lenPK = 100000; 8440 zSql = sqlite3_mprintf( 8441 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%.*s))WITHOUT ROWID", 8442 azArg[2], zCollist, lenPK, zCollist); 8443 sqlite3_free(zCollist); 8444 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum); 8445 if( rc==SQLITE_OK ){ 8446 rc = sqlite3_exec(p->db, zSql, 0, 0, 0); 8447 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0); 8448 if( rc ){ 8449 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db)); 8450 }else{ 8451 utf8_printf(stdout, "%s;\n", zSql); 8452 raw_printf(stdout, 8453 "WARNING: writing to an imposter table will corrupt the \"%s\" %s!\n", 8454 azArg[1], isWO ? "table" : "index" 8455 ); 8456 } 8457 }else{ 8458 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc); 8459 rc = 1; 8460 } 8461 sqlite3_free(zSql); 8462 }else 8463#endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */ 8464 8465#ifdef SQLITE_ENABLE_IOTRACE 8466 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ 8467 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...); 8468 if( iotrace && iotrace!=stdout ) fclose(iotrace); 8469 iotrace = 0; 8470 if( nArg<2 ){ 8471 sqlite3IoTrace = 0; 8472 }else if( strcmp(azArg[1], "-")==0 ){ 8473 sqlite3IoTrace = iotracePrintf; 8474 iotrace = stdout; 8475 }else{ 8476 iotrace = fopen(azArg[1], "w"); 8477 if( iotrace==0 ){ 8478 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); 8479 sqlite3IoTrace = 0; 8480 rc = 1; 8481 }else{ 8482 sqlite3IoTrace = iotracePrintf; 8483 } 8484 } 8485 }else 8486#endif 8487 8488 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){ 8489 static const struct { 8490 const char *zLimitName; /* Name of a limit */ 8491 int limitCode; /* Integer code for that limit */ 8492 } aLimit[] = { 8493 { "length", SQLITE_LIMIT_LENGTH }, 8494 { "sql_length", SQLITE_LIMIT_SQL_LENGTH }, 8495 { "column", SQLITE_LIMIT_COLUMN }, 8496 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH }, 8497 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT }, 8498 { "vdbe_op", SQLITE_LIMIT_VDBE_OP }, 8499 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG }, 8500 { "attached", SQLITE_LIMIT_ATTACHED }, 8501 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH }, 8502 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER }, 8503 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH }, 8504 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS }, 8505 }; 8506 int i, n2; 8507 open_db(p, 0); 8508 if( nArg==1 ){ 8509 for(i=0; i<ArraySize(aLimit); i++){ 8510 printf("%20s %d\n", aLimit[i].zLimitName, 8511 sqlite3_limit(p->db, aLimit[i].limitCode, -1)); 8512 } 8513 }else if( nArg>3 ){ 8514 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n"); 8515 rc = 1; 8516 goto meta_command_exit; 8517 }else{ 8518 int iLimit = -1; 8519 n2 = strlen30(azArg[1]); 8520 for(i=0; i<ArraySize(aLimit); i++){ 8521 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){ 8522 if( iLimit<0 ){ 8523 iLimit = i; 8524 }else{ 8525 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]); 8526 rc = 1; 8527 goto meta_command_exit; 8528 } 8529 } 8530 } 8531 if( iLimit<0 ){ 8532 utf8_printf(stderr, "unknown limit: \"%s\"\n" 8533 "enter \".limits\" with no arguments for a list.\n", 8534 azArg[1]); 8535 rc = 1; 8536 goto meta_command_exit; 8537 } 8538 if( nArg==3 ){ 8539 sqlite3_limit(p->db, aLimit[iLimit].limitCode, 8540 (int)integerValue(azArg[2])); 8541 } 8542 printf("%20s %d\n", aLimit[iLimit].zLimitName, 8543 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1)); 8544 } 8545 }else 8546 8547 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){ 8548 open_db(p, 0); 8549 lintDotCommand(p, azArg, nArg); 8550 }else 8551 8552#ifndef SQLITE_OMIT_LOAD_EXTENSION 8553 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){ 8554 const char *zFile, *zProc; 8555 char *zErrMsg = 0; 8556 if( nArg<2 ){ 8557 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n"); 8558 rc = 1; 8559 goto meta_command_exit; 8560 } 8561 zFile = azArg[1]; 8562 zProc = nArg>=3 ? azArg[2] : 0; 8563 open_db(p, 0); 8564 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); 8565 if( rc!=SQLITE_OK ){ 8566 utf8_printf(stderr, "Error: %s\n", zErrMsg); 8567 sqlite3_free(zErrMsg); 8568 rc = 1; 8569 } 8570 }else 8571#endif 8572 8573 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){ 8574 if( nArg!=2 ){ 8575 raw_printf(stderr, "Usage: .log FILENAME\n"); 8576 rc = 1; 8577 }else{ 8578 const char *zFile = azArg[1]; 8579 output_file_close(p->pLog); 8580 p->pLog = output_file_open(zFile, 0); 8581 } 8582 }else 8583 8584 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){ 8585 const char *zMode = nArg>=2 ? azArg[1] : ""; 8586 int n2 = strlen30(zMode); 8587 int c2 = zMode[0]; 8588 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){ 8589 p->mode = MODE_Line; 8590 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 8591 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){ 8592 p->mode = MODE_Column; 8593 if( (p->shellFlgs & SHFLG_HeaderSet)==0 ){ 8594 p->showHeader = 1; 8595 } 8596 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 8597 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){ 8598 p->mode = MODE_List; 8599 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column); 8600 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 8601 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){ 8602 p->mode = MODE_Html; 8603 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){ 8604 p->mode = MODE_Tcl; 8605 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space); 8606 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 8607 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){ 8608 p->mode = MODE_Csv; 8609 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 8610 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 8611 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){ 8612 p->mode = MODE_List; 8613 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab); 8614 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){ 8615 p->mode = MODE_Insert; 8616 set_table_name(p, nArg>=3 ? azArg[2] : "table"); 8617 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){ 8618 p->mode = MODE_Quote; 8619 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 8620 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 8621 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){ 8622 p->mode = MODE_Ascii; 8623 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit); 8624 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record); 8625 }else if( c2=='m' && strncmp(azArg[1],"markdown",n2)==0 ){ 8626 p->mode = MODE_Markdown; 8627 }else if( c2=='t' && strncmp(azArg[1],"table",n2)==0 ){ 8628 p->mode = MODE_Table; 8629 }else if( c2=='b' && strncmp(azArg[1],"box",n2)==0 ){ 8630 p->mode = MODE_Box; 8631 }else if( c2=='j' && strncmp(azArg[1],"json",n2)==0 ){ 8632 p->mode = MODE_Json; 8633 }else if( nArg==1 ){ 8634 raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]); 8635 }else{ 8636 raw_printf(stderr, "Error: mode should be one of: " 8637 "ascii box column csv html insert json line list markdown " 8638 "quote table tabs tcl\n"); 8639 rc = 1; 8640 } 8641 p->cMode = p->mode; 8642 }else 8643 8644 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){ 8645 if( nArg==2 ){ 8646 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue, 8647 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]); 8648 }else{ 8649 raw_printf(stderr, "Usage: .nullvalue STRING\n"); 8650 rc = 1; 8651 } 8652 }else 8653 8654#ifdef SQLITE_DEBUG 8655 if( c=='o' && strcmp(azArg[0],"oom")==0 ){ 8656 int i; 8657 for(i=1; i<nArg; i++){ 8658 const char *z = azArg[i]; 8659 if( z[0]=='-' && z[1]=='-' ) z++; 8660 if( strcmp(z,"-repeat")==0 ){ 8661 if( i==nArg-1 ){ 8662 raw_printf(p->out, "missing argument on \"%s\"\n", azArg[i]); 8663 rc = 1; 8664 }else{ 8665 oomRepeat = (int)integerValue(azArg[++i]); 8666 } 8667 }else if( IsDigit(z[0]) ){ 8668 oomCounter = (int)integerValue(azArg[i]); 8669 }else{ 8670 raw_printf(p->out, "unknown argument: \"%s\"\n", azArg[i]); 8671 raw_printf(p->out, "Usage: .oom [--repeat N] [M]\n"); 8672 rc = 1; 8673 } 8674 } 8675 if( rc==0 ){ 8676 raw_printf(p->out, "oomCounter = %d\n", oomCounter); 8677 raw_printf(p->out, "oomRepeat = %d\n", oomRepeat); 8678 } 8679 }else 8680#endif /* SQLITE_DEBUG */ 8681 8682 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){ 8683 char *zNewFilename; /* Name of the database file to open */ 8684 int iName = 1; /* Index in azArg[] of the filename */ 8685 int newFlag = 0; /* True to delete file before opening */ 8686 /* Close the existing database */ 8687 session_close_all(p); 8688 close_db(p->db); 8689 p->db = 0; 8690 p->zDbFilename = 0; 8691 sqlite3_free(p->zFreeOnClose); 8692 p->zFreeOnClose = 0; 8693 p->openMode = SHELL_OPEN_UNSPEC; 8694 p->openFlags = 0; 8695 p->szMax = 0; 8696 /* Check for command-line arguments */ 8697 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){ 8698 const char *z = azArg[iName]; 8699 if( optionMatch(z,"new") ){ 8700 newFlag = 1; 8701#ifdef SQLITE_HAVE_ZLIB 8702 }else if( optionMatch(z, "zip") ){ 8703 p->openMode = SHELL_OPEN_ZIPFILE; 8704#endif 8705 }else if( optionMatch(z, "append") ){ 8706 p->openMode = SHELL_OPEN_APPENDVFS; 8707 }else if( optionMatch(z, "readonly") ){ 8708 p->openMode = SHELL_OPEN_READONLY; 8709 }else if( optionMatch(z, "nofollow") ){ 8710 p->openFlags |= SQLITE_OPEN_NOFOLLOW; 8711#ifdef SQLITE_ENABLE_DESERIALIZE 8712 }else if( optionMatch(z, "deserialize") ){ 8713 p->openMode = SHELL_OPEN_DESERIALIZE; 8714 }else if( optionMatch(z, "hexdb") ){ 8715 p->openMode = SHELL_OPEN_HEXDB; 8716 }else if( optionMatch(z, "maxsize") && iName+1<nArg ){ 8717 p->szMax = integerValue(azArg[++iName]); 8718#endif /* SQLITE_ENABLE_DESERIALIZE */ 8719 }else if( z[0]=='-' ){ 8720 utf8_printf(stderr, "unknown option: %s\n", z); 8721 rc = 1; 8722 goto meta_command_exit; 8723 } 8724 } 8725 /* If a filename is specified, try to open it first */ 8726 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0; 8727 if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){ 8728 if( newFlag ) shellDeleteFile(zNewFilename); 8729 p->zDbFilename = zNewFilename; 8730 open_db(p, OPEN_DB_KEEPALIVE); 8731 if( p->db==0 ){ 8732 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename); 8733 sqlite3_free(zNewFilename); 8734 }else{ 8735 p->zFreeOnClose = zNewFilename; 8736 } 8737 } 8738 if( p->db==0 ){ 8739 /* As a fall-back open a TEMP database */ 8740 p->zDbFilename = 0; 8741 open_db(p, 0); 8742 } 8743 }else 8744 8745 if( (c=='o' 8746 && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0)) 8747 || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0) 8748 ){ 8749 const char *zFile = 0; 8750 int bTxtMode = 0; 8751 int i; 8752 int eMode = 0; 8753 int bBOM = 0; 8754 int bOnce = 0; /* 0: .output, 1: .once, 2: .excel */ 8755 8756 if( c=='e' ){ 8757 eMode = 'x'; 8758 bOnce = 2; 8759 }else if( strncmp(azArg[0],"once",n)==0 ){ 8760 bOnce = 1; 8761 } 8762 for(i=1; i<nArg; i++){ 8763 char *z = azArg[i]; 8764 if( z[0]=='-' ){ 8765 if( z[1]=='-' ) z++; 8766 if( strcmp(z,"-bom")==0 ){ 8767 bBOM = 1; 8768 }else if( c!='e' && strcmp(z,"-x")==0 ){ 8769 eMode = 'x'; /* spreadsheet */ 8770 }else if( c!='e' && strcmp(z,"-e")==0 ){ 8771 eMode = 'e'; /* text editor */ 8772 }else{ 8773 utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n", 8774 azArg[i]); 8775 showHelp(p->out, azArg[0]); 8776 rc = 1; 8777 goto meta_command_exit; 8778 } 8779 }else if( zFile==0 ){ 8780 zFile = z; 8781 }else{ 8782 utf8_printf(p->out,"ERROR: extra parameter: \"%s\". Usage:\n", 8783 azArg[i]); 8784 showHelp(p->out, azArg[0]); 8785 rc = 1; 8786 goto meta_command_exit; 8787 } 8788 } 8789 if( zFile==0 ) zFile = "stdout"; 8790 if( bOnce ){ 8791 p->outCount = 2; 8792 }else{ 8793 p->outCount = 0; 8794 } 8795 output_reset(p); 8796#ifndef SQLITE_NOHAVE_SYSTEM 8797 if( eMode=='e' || eMode=='x' ){ 8798 p->doXdgOpen = 1; 8799 outputModePush(p); 8800 if( eMode=='x' ){ 8801 /* spreadsheet mode. Output as CSV. */ 8802 newTempFile(p, "csv"); 8803 ShellClearFlag(p, SHFLG_Echo); 8804 p->mode = MODE_Csv; 8805 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 8806 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 8807 }else{ 8808 /* text editor mode */ 8809 newTempFile(p, "txt"); 8810 bTxtMode = 1; 8811 } 8812 zFile = p->zTempFile; 8813 } 8814#endif /* SQLITE_NOHAVE_SYSTEM */ 8815 if( zFile[0]=='|' ){ 8816#ifdef SQLITE_OMIT_POPEN 8817 raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 8818 rc = 1; 8819 p->out = stdout; 8820#else 8821 p->out = popen(zFile + 1, "w"); 8822 if( p->out==0 ){ 8823 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1); 8824 p->out = stdout; 8825 rc = 1; 8826 }else{ 8827 if( bBOM ) fprintf(p->out,"\357\273\277"); 8828 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 8829 } 8830#endif 8831 }else{ 8832 p->out = output_file_open(zFile, bTxtMode); 8833 if( p->out==0 ){ 8834 if( strcmp(zFile,"off")!=0 ){ 8835 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile); 8836 } 8837 p->out = stdout; 8838 rc = 1; 8839 } else { 8840 if( bBOM ) fprintf(p->out,"\357\273\277"); 8841 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 8842 } 8843 } 8844 }else 8845 8846 if( c=='p' && n>=3 && strncmp(azArg[0], "parameter", n)==0 ){ 8847 open_db(p,0); 8848 if( nArg<=1 ) goto parameter_syntax_error; 8849 8850 /* .parameter clear 8851 ** Clear all bind parameters by dropping the TEMP table that holds them. 8852 */ 8853 if( nArg==2 && strcmp(azArg[1],"clear")==0 ){ 8854 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;", 8855 0, 0, 0); 8856 }else 8857 8858 /* .parameter list 8859 ** List all bind parameters. 8860 */ 8861 if( nArg==2 && strcmp(azArg[1],"list")==0 ){ 8862 sqlite3_stmt *pStmt = 0; 8863 int rx; 8864 int len = 0; 8865 rx = sqlite3_prepare_v2(p->db, 8866 "SELECT max(length(key)) " 8867 "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 8868 if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ 8869 len = sqlite3_column_int(pStmt, 0); 8870 if( len>40 ) len = 40; 8871 } 8872 sqlite3_finalize(pStmt); 8873 pStmt = 0; 8874 if( len ){ 8875 rx = sqlite3_prepare_v2(p->db, 8876 "SELECT key, quote(value) " 8877 "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 8878 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 8879 utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0), 8880 sqlite3_column_text(pStmt,1)); 8881 } 8882 sqlite3_finalize(pStmt); 8883 } 8884 }else 8885 8886 /* .parameter init 8887 ** Make sure the TEMP table used to hold bind parameters exists. 8888 ** Create it if necessary. 8889 */ 8890 if( nArg==2 && strcmp(azArg[1],"init")==0 ){ 8891 bind_table_init(p); 8892 }else 8893 8894 /* .parameter set NAME VALUE 8895 ** Set or reset a bind parameter. NAME should be the full parameter 8896 ** name exactly as it appears in the query. (ex: $abc, @def). The 8897 ** VALUE can be in either SQL literal notation, or if not it will be 8898 ** understood to be a text string. 8899 */ 8900 if( nArg==4 && strcmp(azArg[1],"set")==0 ){ 8901 int rx; 8902 char *zSql; 8903 sqlite3_stmt *pStmt; 8904 const char *zKey = azArg[2]; 8905 const char *zValue = azArg[3]; 8906 bind_table_init(p); 8907 zSql = sqlite3_mprintf( 8908 "REPLACE INTO temp.sqlite_parameters(key,value)" 8909 "VALUES(%Q,%s);", zKey, zValue); 8910 if( zSql==0 ) shell_out_of_memory(); 8911 pStmt = 0; 8912 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 8913 sqlite3_free(zSql); 8914 if( rx!=SQLITE_OK ){ 8915 sqlite3_finalize(pStmt); 8916 pStmt = 0; 8917 zSql = sqlite3_mprintf( 8918 "REPLACE INTO temp.sqlite_parameters(key,value)" 8919 "VALUES(%Q,%Q);", zKey, zValue); 8920 if( zSql==0 ) shell_out_of_memory(); 8921 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 8922 sqlite3_free(zSql); 8923 if( rx!=SQLITE_OK ){ 8924 utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db)); 8925 sqlite3_finalize(pStmt); 8926 pStmt = 0; 8927 rc = 1; 8928 } 8929 } 8930 sqlite3_step(pStmt); 8931 sqlite3_finalize(pStmt); 8932 }else 8933 8934 /* .parameter unset NAME 8935 ** Remove the NAME binding from the parameter binding table, if it 8936 ** exists. 8937 */ 8938 if( nArg==3 && strcmp(azArg[1],"unset")==0 ){ 8939 char *zSql = sqlite3_mprintf( 8940 "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]); 8941 if( zSql==0 ) shell_out_of_memory(); 8942 sqlite3_exec(p->db, zSql, 0, 0, 0); 8943 sqlite3_free(zSql); 8944 }else 8945 /* If no command name matches, show a syntax error */ 8946 parameter_syntax_error: 8947 showHelp(p->out, "parameter"); 8948 }else 8949 8950 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){ 8951 int i; 8952 for(i=1; i<nArg; i++){ 8953 if( i>1 ) raw_printf(p->out, " "); 8954 utf8_printf(p->out, "%s", azArg[i]); 8955 } 8956 raw_printf(p->out, "\n"); 8957 }else 8958 8959#ifndef SQLITE_OMIT_PROGRESS_CALLBACK 8960 if( c=='p' && n>=3 && strncmp(azArg[0], "progress", n)==0 ){ 8961 int i; 8962 int nn = 0; 8963 p->flgProgress = 0; 8964 p->mxProgress = 0; 8965 p->nProgress = 0; 8966 for(i=1; i<nArg; i++){ 8967 const char *z = azArg[i]; 8968 if( z[0]=='-' ){ 8969 z++; 8970 if( z[0]=='-' ) z++; 8971 if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){ 8972 p->flgProgress |= SHELL_PROGRESS_QUIET; 8973 continue; 8974 } 8975 if( strcmp(z,"reset")==0 ){ 8976 p->flgProgress |= SHELL_PROGRESS_RESET; 8977 continue; 8978 } 8979 if( strcmp(z,"once")==0 ){ 8980 p->flgProgress |= SHELL_PROGRESS_ONCE; 8981 continue; 8982 } 8983 if( strcmp(z,"limit")==0 ){ 8984 if( i+1>=nArg ){ 8985 utf8_printf(stderr, "Error: missing argument on --limit\n"); 8986 rc = 1; 8987 goto meta_command_exit; 8988 }else{ 8989 p->mxProgress = (int)integerValue(azArg[++i]); 8990 } 8991 continue; 8992 } 8993 utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]); 8994 rc = 1; 8995 goto meta_command_exit; 8996 }else{ 8997 nn = (int)integerValue(z); 8998 } 8999 } 9000 open_db(p, 0); 9001 sqlite3_progress_handler(p->db, nn, progress_handler, p); 9002 }else 9003#endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 9004 9005 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){ 9006 if( nArg >= 2) { 9007 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); 9008 } 9009 if( nArg >= 3) { 9010 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); 9011 } 9012 }else 9013 9014 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){ 9015 rc = 2; 9016 }else 9017 9018 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){ 9019 FILE *inSaved = p->in; 9020 int savedLineno = p->lineno; 9021 if( nArg!=2 ){ 9022 raw_printf(stderr, "Usage: .read FILE\n"); 9023 rc = 1; 9024 goto meta_command_exit; 9025 } 9026 if( azArg[1][0]=='|' ){ 9027 p->in = popen(azArg[1]+1, "r"); 9028 if( p->in==0 ){ 9029 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); 9030 rc = 1; 9031 }else{ 9032 rc = process_input(p); 9033 pclose(p->in); 9034 } 9035 }else if( notNormalFile(azArg[1]) || (p->in = fopen(azArg[1], "rb"))==0 ){ 9036 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); 9037 rc = 1; 9038 }else{ 9039 rc = process_input(p); 9040 fclose(p->in); 9041 } 9042 p->in = inSaved; 9043 p->lineno = savedLineno; 9044 }else 9045 9046 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){ 9047 const char *zSrcFile; 9048 const char *zDb; 9049 sqlite3 *pSrc; 9050 sqlite3_backup *pBackup; 9051 int nTimeout = 0; 9052 9053 if( nArg==2 ){ 9054 zSrcFile = azArg[1]; 9055 zDb = "main"; 9056 }else if( nArg==3 ){ 9057 zSrcFile = azArg[2]; 9058 zDb = azArg[1]; 9059 }else{ 9060 raw_printf(stderr, "Usage: .restore ?DB? FILE\n"); 9061 rc = 1; 9062 goto meta_command_exit; 9063 } 9064 rc = sqlite3_open(zSrcFile, &pSrc); 9065 if( rc!=SQLITE_OK ){ 9066 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); 9067 close_db(pSrc); 9068 return 1; 9069 } 9070 open_db(p, 0); 9071 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); 9072 if( pBackup==0 ){ 9073 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 9074 close_db(pSrc); 9075 return 1; 9076 } 9077 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK 9078 || rc==SQLITE_BUSY ){ 9079 if( rc==SQLITE_BUSY ){ 9080 if( nTimeout++ >= 3 ) break; 9081 sqlite3_sleep(100); 9082 } 9083 } 9084 sqlite3_backup_finish(pBackup); 9085 if( rc==SQLITE_DONE ){ 9086 rc = 0; 9087 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ 9088 raw_printf(stderr, "Error: source database is busy\n"); 9089 rc = 1; 9090 }else{ 9091 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 9092 rc = 1; 9093 } 9094 close_db(pSrc); 9095 }else 9096 9097 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){ 9098 if( nArg==2 ){ 9099 p->scanstatsOn = (u8)booleanValue(azArg[1]); 9100#ifndef SQLITE_ENABLE_STMT_SCANSTATUS 9101 raw_printf(stderr, "Warning: .scanstats not available in this build.\n"); 9102#endif 9103 }else{ 9104 raw_printf(stderr, "Usage: .scanstats on|off\n"); 9105 rc = 1; 9106 } 9107 }else 9108 9109 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){ 9110 ShellText sSelect; 9111 ShellState data; 9112 char *zErrMsg = 0; 9113 const char *zDiv = "("; 9114 const char *zName = 0; 9115 int iSchema = 0; 9116 int bDebug = 0; 9117 int bNoSystemTabs = 0; 9118 int ii; 9119 9120 open_db(p, 0); 9121 memcpy(&data, p, sizeof(data)); 9122 data.showHeader = 0; 9123 data.cMode = data.mode = MODE_Semi; 9124 initText(&sSelect); 9125 for(ii=1; ii<nArg; ii++){ 9126 if( optionMatch(azArg[ii],"indent") ){ 9127 data.cMode = data.mode = MODE_Pretty; 9128 }else if( optionMatch(azArg[ii],"debug") ){ 9129 bDebug = 1; 9130 }else if( optionMatch(azArg[ii],"nosys") ){ 9131 bNoSystemTabs = 1; 9132 }else if( azArg[ii][0]=='-' ){ 9133 utf8_printf(stderr, "Unknown option: \"%s\"\n", azArg[ii]); 9134 rc = 1; 9135 goto meta_command_exit; 9136 }else if( zName==0 ){ 9137 zName = azArg[ii]; 9138 }else{ 9139 raw_printf(stderr, "Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n"); 9140 rc = 1; 9141 goto meta_command_exit; 9142 } 9143 } 9144 if( zName!=0 ){ 9145 int isSchema = sqlite3_strlike(zName, "sqlite_master", '\\')==0 9146 || sqlite3_strlike(zName, "sqlite_schema", '\\')==0 9147 || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0 9148 || sqlite3_strlike(zName,"sqlite_temp_schema", '\\')==0; 9149 if( isSchema ){ 9150 char *new_argv[2], *new_colv[2]; 9151 new_argv[0] = sqlite3_mprintf( 9152 "CREATE TABLE %s (\n" 9153 " type text,\n" 9154 " name text,\n" 9155 " tbl_name text,\n" 9156 " rootpage integer,\n" 9157 " sql text\n" 9158 ")", zName); 9159 new_argv[1] = 0; 9160 new_colv[0] = "sql"; 9161 new_colv[1] = 0; 9162 callback(&data, 1, new_argv, new_colv); 9163 sqlite3_free(new_argv[0]); 9164 } 9165 } 9166 if( zDiv ){ 9167 sqlite3_stmt *pStmt = 0; 9168 rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list", 9169 -1, &pStmt, 0); 9170 if( rc ){ 9171 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 9172 sqlite3_finalize(pStmt); 9173 rc = 1; 9174 goto meta_command_exit; 9175 } 9176 appendText(&sSelect, "SELECT sql FROM", 0); 9177 iSchema = 0; 9178 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 9179 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0); 9180 char zScNum[30]; 9181 sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema); 9182 appendText(&sSelect, zDiv, 0); 9183 zDiv = " UNION ALL "; 9184 appendText(&sSelect, "SELECT shell_add_schema(sql,", 0); 9185 if( sqlite3_stricmp(zDb, "main")!=0 ){ 9186 appendText(&sSelect, zDb, '\''); 9187 }else{ 9188 appendText(&sSelect, "NULL", 0); 9189 } 9190 appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0); 9191 appendText(&sSelect, zScNum, 0); 9192 appendText(&sSelect, " AS snum, ", 0); 9193 appendText(&sSelect, zDb, '\''); 9194 appendText(&sSelect, " AS sname FROM ", 0); 9195 appendText(&sSelect, zDb, quoteChar(zDb)); 9196 appendText(&sSelect, ".sqlite_schema", 0); 9197 } 9198 sqlite3_finalize(pStmt); 9199#ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS 9200 if( zName ){ 9201 appendText(&sSelect, 9202 " UNION ALL SELECT shell_module_schema(name)," 9203 " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list", 9204 0); 9205 } 9206#endif 9207 appendText(&sSelect, ") WHERE ", 0); 9208 if( zName ){ 9209 char *zQarg = sqlite3_mprintf("%Q", zName); 9210 int bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 || 9211 strchr(zName, '[') != 0; 9212 if( strchr(zName, '.') ){ 9213 appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0); 9214 }else{ 9215 appendText(&sSelect, "lower(tbl_name)", 0); 9216 } 9217 appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0); 9218 appendText(&sSelect, zQarg, 0); 9219 if( !bGlob ){ 9220 appendText(&sSelect, " ESCAPE '\\' ", 0); 9221 } 9222 appendText(&sSelect, " AND ", 0); 9223 sqlite3_free(zQarg); 9224 } 9225 if( bNoSystemTabs ){ 9226 appendText(&sSelect, "name NOT LIKE 'sqlite_%%' AND ", 0); 9227 } 9228 appendText(&sSelect, "sql IS NOT NULL" 9229 " ORDER BY snum, rowid", 0); 9230 if( bDebug ){ 9231 utf8_printf(p->out, "SQL: %s;\n", sSelect.z); 9232 }else{ 9233 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg); 9234 } 9235 freeText(&sSelect); 9236 } 9237 if( zErrMsg ){ 9238 utf8_printf(stderr,"Error: %s\n", zErrMsg); 9239 sqlite3_free(zErrMsg); 9240 rc = 1; 9241 }else if( rc != SQLITE_OK ){ 9242 raw_printf(stderr,"Error: querying schema information\n"); 9243 rc = 1; 9244 }else{ 9245 rc = 0; 9246 } 9247 }else 9248 9249#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 9250 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){ 9251 sqlite3_unsupported_selecttrace = nArg>=2 ? (int)integerValue(azArg[1]) : 0xffff; 9252 }else 9253#endif 9254 9255#if defined(SQLITE_ENABLE_SESSION) 9256 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){ 9257 OpenSession *pSession = &p->aSession[0]; 9258 char **azCmd = &azArg[1]; 9259 int iSes = 0; 9260 int nCmd = nArg - 1; 9261 int i; 9262 if( nArg<=1 ) goto session_syntax_error; 9263 open_db(p, 0); 9264 if( nArg>=3 ){ 9265 for(iSes=0; iSes<p->nSession; iSes++){ 9266 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break; 9267 } 9268 if( iSes<p->nSession ){ 9269 pSession = &p->aSession[iSes]; 9270 azCmd++; 9271 nCmd--; 9272 }else{ 9273 pSession = &p->aSession[0]; 9274 iSes = 0; 9275 } 9276 } 9277 9278 /* .session attach TABLE 9279 ** Invoke the sqlite3session_attach() interface to attach a particular 9280 ** table so that it is never filtered. 9281 */ 9282 if( strcmp(azCmd[0],"attach")==0 ){ 9283 if( nCmd!=2 ) goto session_syntax_error; 9284 if( pSession->p==0 ){ 9285 session_not_open: 9286 raw_printf(stderr, "ERROR: No sessions are open\n"); 9287 }else{ 9288 rc = sqlite3session_attach(pSession->p, azCmd[1]); 9289 if( rc ){ 9290 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc); 9291 rc = 0; 9292 } 9293 } 9294 }else 9295 9296 /* .session changeset FILE 9297 ** .session patchset FILE 9298 ** Write a changeset or patchset into a file. The file is overwritten. 9299 */ 9300 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){ 9301 FILE *out = 0; 9302 if( nCmd!=2 ) goto session_syntax_error; 9303 if( pSession->p==0 ) goto session_not_open; 9304 out = fopen(azCmd[1], "wb"); 9305 if( out==0 ){ 9306 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n", 9307 azCmd[1]); 9308 }else{ 9309 int szChng; 9310 void *pChng; 9311 if( azCmd[0][0]=='c' ){ 9312 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng); 9313 }else{ 9314 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng); 9315 } 9316 if( rc ){ 9317 printf("Error: error code %d\n", rc); 9318 rc = 0; 9319 } 9320 if( pChng 9321 && fwrite(pChng, szChng, 1, out)!=1 ){ 9322 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n", 9323 szChng); 9324 } 9325 sqlite3_free(pChng); 9326 fclose(out); 9327 } 9328 }else 9329 9330 /* .session close 9331 ** Close the identified session 9332 */ 9333 if( strcmp(azCmd[0], "close")==0 ){ 9334 if( nCmd!=1 ) goto session_syntax_error; 9335 if( p->nSession ){ 9336 session_close(pSession); 9337 p->aSession[iSes] = p->aSession[--p->nSession]; 9338 } 9339 }else 9340 9341 /* .session enable ?BOOLEAN? 9342 ** Query or set the enable flag 9343 */ 9344 if( strcmp(azCmd[0], "enable")==0 ){ 9345 int ii; 9346 if( nCmd>2 ) goto session_syntax_error; 9347 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 9348 if( p->nSession ){ 9349 ii = sqlite3session_enable(pSession->p, ii); 9350 utf8_printf(p->out, "session %s enable flag = %d\n", 9351 pSession->zName, ii); 9352 } 9353 }else 9354 9355 /* .session filter GLOB .... 9356 ** Set a list of GLOB patterns of table names to be excluded. 9357 */ 9358 if( strcmp(azCmd[0], "filter")==0 ){ 9359 int ii, nByte; 9360 if( nCmd<2 ) goto session_syntax_error; 9361 if( p->nSession ){ 9362 for(ii=0; ii<pSession->nFilter; ii++){ 9363 sqlite3_free(pSession->azFilter[ii]); 9364 } 9365 sqlite3_free(pSession->azFilter); 9366 nByte = sizeof(pSession->azFilter[0])*(nCmd-1); 9367 pSession->azFilter = sqlite3_malloc( nByte ); 9368 if( pSession->azFilter==0 ){ 9369 raw_printf(stderr, "Error: out or memory\n"); 9370 exit(1); 9371 } 9372 for(ii=1; ii<nCmd; ii++){ 9373 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]); 9374 } 9375 pSession->nFilter = ii-1; 9376 } 9377 }else 9378 9379 /* .session indirect ?BOOLEAN? 9380 ** Query or set the indirect flag 9381 */ 9382 if( strcmp(azCmd[0], "indirect")==0 ){ 9383 int ii; 9384 if( nCmd>2 ) goto session_syntax_error; 9385 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 9386 if( p->nSession ){ 9387 ii = sqlite3session_indirect(pSession->p, ii); 9388 utf8_printf(p->out, "session %s indirect flag = %d\n", 9389 pSession->zName, ii); 9390 } 9391 }else 9392 9393 /* .session isempty 9394 ** Determine if the session is empty 9395 */ 9396 if( strcmp(azCmd[0], "isempty")==0 ){ 9397 int ii; 9398 if( nCmd!=1 ) goto session_syntax_error; 9399 if( p->nSession ){ 9400 ii = sqlite3session_isempty(pSession->p); 9401 utf8_printf(p->out, "session %s isempty flag = %d\n", 9402 pSession->zName, ii); 9403 } 9404 }else 9405 9406 /* .session list 9407 ** List all currently open sessions 9408 */ 9409 if( strcmp(azCmd[0],"list")==0 ){ 9410 for(i=0; i<p->nSession; i++){ 9411 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName); 9412 } 9413 }else 9414 9415 /* .session open DB NAME 9416 ** Open a new session called NAME on the attached database DB. 9417 ** DB is normally "main". 9418 */ 9419 if( strcmp(azCmd[0],"open")==0 ){ 9420 char *zName; 9421 if( nCmd!=3 ) goto session_syntax_error; 9422 zName = azCmd[2]; 9423 if( zName[0]==0 ) goto session_syntax_error; 9424 for(i=0; i<p->nSession; i++){ 9425 if( strcmp(p->aSession[i].zName,zName)==0 ){ 9426 utf8_printf(stderr, "Session \"%s\" already exists\n", zName); 9427 goto meta_command_exit; 9428 } 9429 } 9430 if( p->nSession>=ArraySize(p->aSession) ){ 9431 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession)); 9432 goto meta_command_exit; 9433 } 9434 pSession = &p->aSession[p->nSession]; 9435 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p); 9436 if( rc ){ 9437 raw_printf(stderr, "Cannot open session: error code=%d\n", rc); 9438 rc = 0; 9439 goto meta_command_exit; 9440 } 9441 pSession->nFilter = 0; 9442 sqlite3session_table_filter(pSession->p, session_filter, pSession); 9443 p->nSession++; 9444 pSession->zName = sqlite3_mprintf("%s", zName); 9445 }else 9446 /* If no command name matches, show a syntax error */ 9447 session_syntax_error: 9448 showHelp(p->out, "session"); 9449 }else 9450#endif 9451 9452#ifdef SQLITE_DEBUG 9453 /* Undocumented commands for internal testing. Subject to change 9454 ** without notice. */ 9455 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){ 9456 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){ 9457 int i, v; 9458 for(i=1; i<nArg; i++){ 9459 v = booleanValue(azArg[i]); 9460 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v); 9461 } 9462 } 9463 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){ 9464 int i; sqlite3_int64 v; 9465 for(i=1; i<nArg; i++){ 9466 char zBuf[200]; 9467 v = integerValue(azArg[i]); 9468 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v); 9469 utf8_printf(p->out, "%s", zBuf); 9470 } 9471 } 9472 }else 9473#endif 9474 9475 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){ 9476 int bIsInit = 0; /* True to initialize the SELFTEST table */ 9477 int bVerbose = 0; /* Verbose output */ 9478 int bSelftestExists; /* True if SELFTEST already exists */ 9479 int i, k; /* Loop counters */ 9480 int nTest = 0; /* Number of tests runs */ 9481 int nErr = 0; /* Number of errors seen */ 9482 ShellText str; /* Answer for a query */ 9483 sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */ 9484 9485 open_db(p,0); 9486 for(i=1; i<nArg; i++){ 9487 const char *z = azArg[i]; 9488 if( z[0]=='-' && z[1]=='-' ) z++; 9489 if( strcmp(z,"-init")==0 ){ 9490 bIsInit = 1; 9491 }else 9492 if( strcmp(z,"-v")==0 ){ 9493 bVerbose++; 9494 }else 9495 { 9496 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 9497 azArg[i], azArg[0]); 9498 raw_printf(stderr, "Should be one of: --init -v\n"); 9499 rc = 1; 9500 goto meta_command_exit; 9501 } 9502 } 9503 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0) 9504 != SQLITE_OK ){ 9505 bSelftestExists = 0; 9506 }else{ 9507 bSelftestExists = 1; 9508 } 9509 if( bIsInit ){ 9510 createSelftestTable(p); 9511 bSelftestExists = 1; 9512 } 9513 initText(&str); 9514 appendText(&str, "x", 0); 9515 for(k=bSelftestExists; k>=0; k--){ 9516 if( k==1 ){ 9517 rc = sqlite3_prepare_v2(p->db, 9518 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno", 9519 -1, &pStmt, 0); 9520 }else{ 9521 rc = sqlite3_prepare_v2(p->db, 9522 "VALUES(0,'memo','Missing SELFTEST table - default checks only','')," 9523 " (1,'run','PRAGMA integrity_check','ok')", 9524 -1, &pStmt, 0); 9525 } 9526 if( rc ){ 9527 raw_printf(stderr, "Error querying the selftest table\n"); 9528 rc = 1; 9529 sqlite3_finalize(pStmt); 9530 goto meta_command_exit; 9531 } 9532 for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){ 9533 int tno = sqlite3_column_int(pStmt, 0); 9534 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1); 9535 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2); 9536 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3); 9537 9538 k = 0; 9539 if( bVerbose>0 ){ 9540 char *zQuote = sqlite3_mprintf("%q", zSql); 9541 printf("%d: %s %s\n", tno, zOp, zSql); 9542 sqlite3_free(zQuote); 9543 } 9544 if( strcmp(zOp,"memo")==0 ){ 9545 utf8_printf(p->out, "%s\n", zSql); 9546 }else 9547 if( strcmp(zOp,"run")==0 ){ 9548 char *zErrMsg = 0; 9549 str.n = 0; 9550 str.z[0] = 0; 9551 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg); 9552 nTest++; 9553 if( bVerbose ){ 9554 utf8_printf(p->out, "Result: %s\n", str.z); 9555 } 9556 if( rc || zErrMsg ){ 9557 nErr++; 9558 rc = 1; 9559 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg); 9560 sqlite3_free(zErrMsg); 9561 }else if( strcmp(zAns,str.z)!=0 ){ 9562 nErr++; 9563 rc = 1; 9564 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns); 9565 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z); 9566 } 9567 }else 9568 { 9569 utf8_printf(stderr, 9570 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno); 9571 rc = 1; 9572 break; 9573 } 9574 } /* End loop over rows of content from SELFTEST */ 9575 sqlite3_finalize(pStmt); 9576 } /* End loop over k */ 9577 freeText(&str); 9578 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest); 9579 }else 9580 9581 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){ 9582 if( nArg<2 || nArg>3 ){ 9583 raw_printf(stderr, "Usage: .separator COL ?ROW?\n"); 9584 rc = 1; 9585 } 9586 if( nArg>=2 ){ 9587 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, 9588 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]); 9589 } 9590 if( nArg>=3 ){ 9591 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, 9592 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]); 9593 } 9594 }else 9595 9596 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){ 9597 const char *zLike = 0; /* Which table to checksum. 0 means everything */ 9598 int i; /* Loop counter */ 9599 int bSchema = 0; /* Also hash the schema */ 9600 int bSeparate = 0; /* Hash each table separately */ 9601 int iSize = 224; /* Hash algorithm to use */ 9602 int bDebug = 0; /* Only show the query that would have run */ 9603 sqlite3_stmt *pStmt; /* For querying tables names */ 9604 char *zSql; /* SQL to be run */ 9605 char *zSep; /* Separator */ 9606 ShellText sSql; /* Complete SQL for the query to run the hash */ 9607 ShellText sQuery; /* Set of queries used to read all content */ 9608 open_db(p, 0); 9609 for(i=1; i<nArg; i++){ 9610 const char *z = azArg[i]; 9611 if( z[0]=='-' ){ 9612 z++; 9613 if( z[0]=='-' ) z++; 9614 if( strcmp(z,"schema")==0 ){ 9615 bSchema = 1; 9616 }else 9617 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0 9618 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0 9619 ){ 9620 iSize = atoi(&z[5]); 9621 }else 9622 if( strcmp(z,"debug")==0 ){ 9623 bDebug = 1; 9624 }else 9625 { 9626 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 9627 azArg[i], azArg[0]); 9628 showHelp(p->out, azArg[0]); 9629 rc = 1; 9630 goto meta_command_exit; 9631 } 9632 }else if( zLike ){ 9633 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n"); 9634 rc = 1; 9635 goto meta_command_exit; 9636 }else{ 9637 zLike = z; 9638 bSeparate = 1; 9639 if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1; 9640 } 9641 } 9642 if( bSchema ){ 9643 zSql = "SELECT lower(name) FROM sqlite_schema" 9644 " WHERE type='table' AND coalesce(rootpage,0)>1" 9645 " UNION ALL SELECT 'sqlite_schema'" 9646 " ORDER BY 1 collate nocase"; 9647 }else{ 9648 zSql = "SELECT lower(name) FROM sqlite_schema" 9649 " WHERE type='table' AND coalesce(rootpage,0)>1" 9650 " AND name NOT LIKE 'sqlite_%'" 9651 " ORDER BY 1 collate nocase"; 9652 } 9653 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 9654 initText(&sQuery); 9655 initText(&sSql); 9656 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0); 9657 zSep = "VALUES("; 9658 while( SQLITE_ROW==sqlite3_step(pStmt) ){ 9659 const char *zTab = (const char*)sqlite3_column_text(pStmt,0); 9660 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue; 9661 if( strncmp(zTab, "sqlite_",7)!=0 ){ 9662 appendText(&sQuery,"SELECT * FROM ", 0); 9663 appendText(&sQuery,zTab,'"'); 9664 appendText(&sQuery," NOT INDEXED;", 0); 9665 }else if( strcmp(zTab, "sqlite_schema")==0 ){ 9666 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_schema" 9667 " ORDER BY name;", 0); 9668 }else if( strcmp(zTab, "sqlite_sequence")==0 ){ 9669 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence" 9670 " ORDER BY name;", 0); 9671 }else if( strcmp(zTab, "sqlite_stat1")==0 ){ 9672 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1" 9673 " ORDER BY tbl,idx;", 0); 9674 }else if( strcmp(zTab, "sqlite_stat4")==0 ){ 9675 appendText(&sQuery, "SELECT * FROM ", 0); 9676 appendText(&sQuery, zTab, 0); 9677 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0); 9678 } 9679 appendText(&sSql, zSep, 0); 9680 appendText(&sSql, sQuery.z, '\''); 9681 sQuery.n = 0; 9682 appendText(&sSql, ",", 0); 9683 appendText(&sSql, zTab, '\''); 9684 zSep = "),("; 9685 } 9686 sqlite3_finalize(pStmt); 9687 if( bSeparate ){ 9688 zSql = sqlite3_mprintf( 9689 "%s))" 9690 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label" 9691 " FROM [sha3sum$query]", 9692 sSql.z, iSize); 9693 }else{ 9694 zSql = sqlite3_mprintf( 9695 "%s))" 9696 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash" 9697 " FROM [sha3sum$query]", 9698 sSql.z, iSize); 9699 } 9700 freeText(&sQuery); 9701 freeText(&sSql); 9702 if( bDebug ){ 9703 utf8_printf(p->out, "%s\n", zSql); 9704 }else{ 9705 shell_exec(p, zSql, 0); 9706 } 9707 sqlite3_free(zSql); 9708 }else 9709 9710#ifndef SQLITE_NOHAVE_SYSTEM 9711 if( c=='s' 9712 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0) 9713 ){ 9714 char *zCmd; 9715 int i, x; 9716 if( nArg<2 ){ 9717 raw_printf(stderr, "Usage: .system COMMAND\n"); 9718 rc = 1; 9719 goto meta_command_exit; 9720 } 9721 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]); 9722 for(i=2; i<nArg; i++){ 9723 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"", 9724 zCmd, azArg[i]); 9725 } 9726 x = system(zCmd); 9727 sqlite3_free(zCmd); 9728 if( x ) raw_printf(stderr, "System command returns %d\n", x); 9729 }else 9730#endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 9731 9732 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){ 9733 static const char *azBool[] = { "off", "on", "trigger", "full"}; 9734 int i; 9735 if( nArg!=1 ){ 9736 raw_printf(stderr, "Usage: .show\n"); 9737 rc = 1; 9738 goto meta_command_exit; 9739 } 9740 utf8_printf(p->out, "%12.12s: %s\n","echo", 9741 azBool[ShellHasFlag(p, SHFLG_Echo)]); 9742 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]); 9743 utf8_printf(p->out, "%12.12s: %s\n","explain", 9744 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off"); 9745 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]); 9746 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]); 9747 utf8_printf(p->out, "%12.12s: ", "nullvalue"); 9748 output_c_string(p->out, p->nullValue); 9749 raw_printf(p->out, "\n"); 9750 utf8_printf(p->out,"%12.12s: %s\n","output", 9751 strlen30(p->outfile) ? p->outfile : "stdout"); 9752 utf8_printf(p->out,"%12.12s: ", "colseparator"); 9753 output_c_string(p->out, p->colSeparator); 9754 raw_printf(p->out, "\n"); 9755 utf8_printf(p->out,"%12.12s: ", "rowseparator"); 9756 output_c_string(p->out, p->rowSeparator); 9757 raw_printf(p->out, "\n"); 9758 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]); 9759 utf8_printf(p->out, "%12.12s: ", "width"); 9760 for (i=0;i<p->nWidth;i++) { 9761 raw_printf(p->out, "%d ", p->colWidth[i]); 9762 } 9763 raw_printf(p->out, "\n"); 9764 utf8_printf(p->out, "%12.12s: %s\n", "filename", 9765 p->zDbFilename ? p->zDbFilename : ""); 9766 }else 9767 9768 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){ 9769 if( nArg==2 ){ 9770 p->statsOn = (u8)booleanValue(azArg[1]); 9771 }else if( nArg==1 ){ 9772 display_stats(p->db, p, 0); 9773 }else{ 9774 raw_printf(stderr, "Usage: .stats ?on|off?\n"); 9775 rc = 1; 9776 } 9777 }else 9778 9779 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0) 9780 || (c=='i' && (strncmp(azArg[0], "indices", n)==0 9781 || strncmp(azArg[0], "indexes", n)==0) ) 9782 ){ 9783 sqlite3_stmt *pStmt; 9784 char **azResult; 9785 int nRow, nAlloc; 9786 int ii; 9787 ShellText s; 9788 initText(&s); 9789 open_db(p, 0); 9790 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); 9791 if( rc ){ 9792 sqlite3_finalize(pStmt); 9793 return shellDatabaseError(p->db); 9794 } 9795 9796 if( nArg>2 && c=='i' ){ 9797 /* It is an historical accident that the .indexes command shows an error 9798 ** when called with the wrong number of arguments whereas the .tables 9799 ** command does not. */ 9800 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n"); 9801 rc = 1; 9802 sqlite3_finalize(pStmt); 9803 goto meta_command_exit; 9804 } 9805 for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){ 9806 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1); 9807 if( zDbName==0 ) continue; 9808 if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0); 9809 if( sqlite3_stricmp(zDbName, "main")==0 ){ 9810 appendText(&s, "SELECT name FROM ", 0); 9811 }else{ 9812 appendText(&s, "SELECT ", 0); 9813 appendText(&s, zDbName, '\''); 9814 appendText(&s, "||'.'||name FROM ", 0); 9815 } 9816 appendText(&s, zDbName, '"'); 9817 appendText(&s, ".sqlite_schema ", 0); 9818 if( c=='t' ){ 9819 appendText(&s," WHERE type IN ('table','view')" 9820 " AND name NOT LIKE 'sqlite_%'" 9821 " AND name LIKE ?1", 0); 9822 }else{ 9823 appendText(&s," WHERE type='index'" 9824 " AND tbl_name LIKE ?1", 0); 9825 } 9826 } 9827 rc = sqlite3_finalize(pStmt); 9828 appendText(&s, " ORDER BY 1", 0); 9829 rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0); 9830 freeText(&s); 9831 if( rc ) return shellDatabaseError(p->db); 9832 9833 /* Run the SQL statement prepared by the above block. Store the results 9834 ** as an array of nul-terminated strings in azResult[]. */ 9835 nRow = nAlloc = 0; 9836 azResult = 0; 9837 if( nArg>1 ){ 9838 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT); 9839 }else{ 9840 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC); 9841 } 9842 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 9843 if( nRow>=nAlloc ){ 9844 char **azNew; 9845 int n2 = nAlloc*2 + 10; 9846 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2); 9847 if( azNew==0 ) shell_out_of_memory(); 9848 nAlloc = n2; 9849 azResult = azNew; 9850 } 9851 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0)); 9852 if( 0==azResult[nRow] ) shell_out_of_memory(); 9853 nRow++; 9854 } 9855 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){ 9856 rc = shellDatabaseError(p->db); 9857 } 9858 9859 /* Pretty-print the contents of array azResult[] to the output */ 9860 if( rc==0 && nRow>0 ){ 9861 int len, maxlen = 0; 9862 int i, j; 9863 int nPrintCol, nPrintRow; 9864 for(i=0; i<nRow; i++){ 9865 len = strlen30(azResult[i]); 9866 if( len>maxlen ) maxlen = len; 9867 } 9868 nPrintCol = 80/(maxlen+2); 9869 if( nPrintCol<1 ) nPrintCol = 1; 9870 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; 9871 for(i=0; i<nPrintRow; i++){ 9872 for(j=i; j<nRow; j+=nPrintRow){ 9873 char *zSp = j<nPrintRow ? "" : " "; 9874 utf8_printf(p->out, "%s%-*s", zSp, maxlen, 9875 azResult[j] ? azResult[j]:""); 9876 } 9877 raw_printf(p->out, "\n"); 9878 } 9879 } 9880 9881 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]); 9882 sqlite3_free(azResult); 9883 }else 9884 9885 /* Begin redirecting output to the file "testcase-out.txt" */ 9886 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){ 9887 output_reset(p); 9888 p->out = output_file_open("testcase-out.txt", 0); 9889 if( p->out==0 ){ 9890 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n"); 9891 } 9892 if( nArg>=2 ){ 9893 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]); 9894 }else{ 9895 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?"); 9896 } 9897 }else 9898 9899#ifndef SQLITE_UNTESTABLE 9900 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 ){ 9901 static const struct { 9902 const char *zCtrlName; /* Name of a test-control option */ 9903 int ctrlCode; /* Integer code for that option */ 9904 const char *zUsage; /* Usage notes */ 9905 } aCtrl[] = { 9906 { "always", SQLITE_TESTCTRL_ALWAYS, "BOOLEAN" }, 9907 { "assert", SQLITE_TESTCTRL_ASSERT, "BOOLEAN" }, 9908 /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, "" },*/ 9909 /*{ "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST, "" },*/ 9910 { "byteorder", SQLITE_TESTCTRL_BYTEORDER, "" }, 9911 { "extra_schema_checks",SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS,"BOOLEAN" }, 9912 /*{ "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL, "" },*/ 9913 { "imposter", SQLITE_TESTCTRL_IMPOSTER, "SCHEMA ON/OFF ROOTPAGE"}, 9914 { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "" }, 9915 { "localtime_fault", SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN" }, 9916 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN" }, 9917 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK" }, 9918#ifdef YYCOVERAGE 9919 { "parser_coverage", SQLITE_TESTCTRL_PARSER_COVERAGE, "" }, 9920#endif 9921 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE, "OFFSET " }, 9922 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE, "" }, 9923 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE, "" }, 9924 { "prng_seed", SQLITE_TESTCTRL_PRNG_SEED, "SEED ?db?" }, 9925 { "seek_count", SQLITE_TESTCTRL_SEEK_COUNT, "" }, 9926 }; 9927 int testctrl = -1; 9928 int iCtrl = -1; 9929 int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */ 9930 int isOk = 0; 9931 int i, n2; 9932 const char *zCmd = 0; 9933 9934 open_db(p, 0); 9935 zCmd = nArg>=2 ? azArg[1] : "help"; 9936 9937 /* The argument can optionally begin with "-" or "--" */ 9938 if( zCmd[0]=='-' && zCmd[1] ){ 9939 zCmd++; 9940 if( zCmd[0]=='-' && zCmd[1] ) zCmd++; 9941 } 9942 9943 /* --help lists all test-controls */ 9944 if( strcmp(zCmd,"help")==0 ){ 9945 utf8_printf(p->out, "Available test-controls:\n"); 9946 for(i=0; i<ArraySize(aCtrl); i++){ 9947 utf8_printf(p->out, " .testctrl %s %s\n", 9948 aCtrl[i].zCtrlName, aCtrl[i].zUsage); 9949 } 9950 rc = 1; 9951 goto meta_command_exit; 9952 } 9953 9954 /* convert testctrl text option to value. allow any unique prefix 9955 ** of the option name, or a numerical value. */ 9956 n2 = strlen30(zCmd); 9957 for(i=0; i<ArraySize(aCtrl); i++){ 9958 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){ 9959 if( testctrl<0 ){ 9960 testctrl = aCtrl[i].ctrlCode; 9961 iCtrl = i; 9962 }else{ 9963 utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n" 9964 "Use \".testctrl --help\" for help\n", zCmd); 9965 rc = 1; 9966 goto meta_command_exit; 9967 } 9968 } 9969 } 9970 if( testctrl<0 ){ 9971 utf8_printf(stderr,"Error: unknown test-control: %s\n" 9972 "Use \".testctrl --help\" for help\n", zCmd); 9973 }else{ 9974 switch(testctrl){ 9975 9976 /* sqlite3_test_control(int, db, int) */ 9977 case SQLITE_TESTCTRL_OPTIMIZATIONS: 9978 if( nArg==3 ){ 9979 int opt = (int)strtol(azArg[2], 0, 0); 9980 rc2 = sqlite3_test_control(testctrl, p->db, opt); 9981 isOk = 3; 9982 } 9983 break; 9984 9985 /* sqlite3_test_control(int) */ 9986 case SQLITE_TESTCTRL_PRNG_SAVE: 9987 case SQLITE_TESTCTRL_PRNG_RESTORE: 9988 case SQLITE_TESTCTRL_BYTEORDER: 9989 if( nArg==2 ){ 9990 rc2 = sqlite3_test_control(testctrl); 9991 isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3; 9992 } 9993 break; 9994 9995 /* sqlite3_test_control(int, uint) */ 9996 case SQLITE_TESTCTRL_PENDING_BYTE: 9997 if( nArg==3 ){ 9998 unsigned int opt = (unsigned int)integerValue(azArg[2]); 9999 rc2 = sqlite3_test_control(testctrl, opt); 10000 isOk = 3; 10001 } 10002 break; 10003 10004 /* sqlite3_test_control(int, int, sqlite3*) */ 10005 case SQLITE_TESTCTRL_PRNG_SEED: 10006 if( nArg==3 || nArg==4 ){ 10007 int ii = (int)integerValue(azArg[2]); 10008 sqlite3 *db; 10009 if( ii==0 && strcmp(azArg[2],"random")==0 ){ 10010 sqlite3_randomness(sizeof(ii),&ii); 10011 printf("-- random seed: %d\n", ii); 10012 } 10013 if( nArg==3 ){ 10014 db = 0; 10015 }else{ 10016 db = p->db; 10017 /* Make sure the schema has been loaded */ 10018 sqlite3_table_column_metadata(db, 0, "x", 0, 0, 0, 0, 0, 0); 10019 } 10020 rc2 = sqlite3_test_control(testctrl, ii, db); 10021 isOk = 3; 10022 } 10023 break; 10024 10025 /* sqlite3_test_control(int, int) */ 10026 case SQLITE_TESTCTRL_ASSERT: 10027 case SQLITE_TESTCTRL_ALWAYS: 10028 if( nArg==3 ){ 10029 int opt = booleanValue(azArg[2]); 10030 rc2 = sqlite3_test_control(testctrl, opt); 10031 isOk = 1; 10032 } 10033 break; 10034 10035 /* sqlite3_test_control(int, int) */ 10036 case SQLITE_TESTCTRL_LOCALTIME_FAULT: 10037 case SQLITE_TESTCTRL_NEVER_CORRUPT: 10038 if( nArg==3 ){ 10039 int opt = booleanValue(azArg[2]); 10040 rc2 = sqlite3_test_control(testctrl, opt); 10041 isOk = 3; 10042 } 10043 break; 10044 10045 /* sqlite3_test_control(sqlite3*) */ 10046 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: 10047 rc2 = sqlite3_test_control(testctrl, p->db); 10048 isOk = 3; 10049 break; 10050 10051 case SQLITE_TESTCTRL_IMPOSTER: 10052 if( nArg==5 ){ 10053 rc2 = sqlite3_test_control(testctrl, p->db, 10054 azArg[2], 10055 integerValue(azArg[3]), 10056 integerValue(azArg[4])); 10057 isOk = 3; 10058 } 10059 break; 10060 10061 case SQLITE_TESTCTRL_SEEK_COUNT: { 10062 u64 x = 0; 10063 rc2 = sqlite3_test_control(testctrl, p->db, &x); 10064 utf8_printf(p->out, "%llu\n", x); 10065 isOk = 3; 10066 break; 10067 } 10068 10069#ifdef YYCOVERAGE 10070 case SQLITE_TESTCTRL_PARSER_COVERAGE: 10071 if( nArg==2 ){ 10072 sqlite3_test_control(testctrl, p->out); 10073 isOk = 3; 10074 } 10075#endif 10076 } 10077 } 10078 if( isOk==0 && iCtrl>=0 ){ 10079 utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage); 10080 rc = 1; 10081 }else if( isOk==1 ){ 10082 raw_printf(p->out, "%d\n", rc2); 10083 }else if( isOk==2 ){ 10084 raw_printf(p->out, "0x%08x\n", rc2); 10085 } 10086 }else 10087#endif /* !defined(SQLITE_UNTESTABLE) */ 10088 10089 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){ 10090 open_db(p, 0); 10091 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0); 10092 }else 10093 10094 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){ 10095 if( nArg==2 ){ 10096 enableTimer = booleanValue(azArg[1]); 10097 if( enableTimer && !HAS_TIMER ){ 10098 raw_printf(stderr, "Error: timer not available on this system.\n"); 10099 enableTimer = 0; 10100 } 10101 }else{ 10102 raw_printf(stderr, "Usage: .timer on|off\n"); 10103 rc = 1; 10104 } 10105 }else 10106 10107#ifndef SQLITE_OMIT_TRACE 10108 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){ 10109 int mType = 0; 10110 int jj; 10111 open_db(p, 0); 10112 for(jj=1; jj<nArg; jj++){ 10113 const char *z = azArg[jj]; 10114 if( z[0]=='-' ){ 10115 if( optionMatch(z, "expanded") ){ 10116 p->eTraceType = SHELL_TRACE_EXPANDED; 10117 } 10118#ifdef SQLITE_ENABLE_NORMALIZE 10119 else if( optionMatch(z, "normalized") ){ 10120 p->eTraceType = SHELL_TRACE_NORMALIZED; 10121 } 10122#endif 10123 else if( optionMatch(z, "plain") ){ 10124 p->eTraceType = SHELL_TRACE_PLAIN; 10125 } 10126 else if( optionMatch(z, "profile") ){ 10127 mType |= SQLITE_TRACE_PROFILE; 10128 } 10129 else if( optionMatch(z, "row") ){ 10130 mType |= SQLITE_TRACE_ROW; 10131 } 10132 else if( optionMatch(z, "stmt") ){ 10133 mType |= SQLITE_TRACE_STMT; 10134 } 10135 else if( optionMatch(z, "close") ){ 10136 mType |= SQLITE_TRACE_CLOSE; 10137 } 10138 else { 10139 raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z); 10140 rc = 1; 10141 goto meta_command_exit; 10142 } 10143 }else{ 10144 output_file_close(p->traceOut); 10145 p->traceOut = output_file_open(azArg[1], 0); 10146 } 10147 } 10148 if( p->traceOut==0 ){ 10149 sqlite3_trace_v2(p->db, 0, 0, 0); 10150 }else{ 10151 if( mType==0 ) mType = SQLITE_TRACE_STMT; 10152 sqlite3_trace_v2(p->db, mType, sql_trace_callback, p); 10153 } 10154 }else 10155#endif /* !defined(SQLITE_OMIT_TRACE) */ 10156 10157#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_VIRTUALTABLE) 10158 if( c=='u' && strncmp(azArg[0], "unmodule", n)==0 ){ 10159 int ii; 10160 int lenOpt; 10161 char *zOpt; 10162 if( nArg<2 ){ 10163 raw_printf(stderr, "Usage: .unmodule [--allexcept] NAME ...\n"); 10164 rc = 1; 10165 goto meta_command_exit; 10166 } 10167 open_db(p, 0); 10168 zOpt = azArg[1]; 10169 if( zOpt[0]=='-' && zOpt[1]=='-' && zOpt[2]!=0 ) zOpt++; 10170 lenOpt = (int)strlen(zOpt); 10171 if( lenOpt>=3 && strncmp(zOpt, "-allexcept",lenOpt)==0 ){ 10172 assert( azArg[nArg]==0 ); 10173 sqlite3_drop_modules(p->db, nArg>2 ? (const char**)(azArg+2) : 0); 10174 }else{ 10175 for(ii=1; ii<nArg; ii++){ 10176 sqlite3_create_module(p->db, azArg[ii], 0, 0); 10177 } 10178 } 10179 }else 10180#endif 10181 10182#if SQLITE_USER_AUTHENTICATION 10183 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){ 10184 if( nArg<2 ){ 10185 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n"); 10186 rc = 1; 10187 goto meta_command_exit; 10188 } 10189 open_db(p, 0); 10190 if( strcmp(azArg[1],"login")==0 ){ 10191 if( nArg!=4 ){ 10192 raw_printf(stderr, "Usage: .user login USER PASSWORD\n"); 10193 rc = 1; 10194 goto meta_command_exit; 10195 } 10196 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3], 10197 strlen30(azArg[3])); 10198 if( rc ){ 10199 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]); 10200 rc = 1; 10201 } 10202 }else if( strcmp(azArg[1],"add")==0 ){ 10203 if( nArg!=5 ){ 10204 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n"); 10205 rc = 1; 10206 goto meta_command_exit; 10207 } 10208 rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 10209 booleanValue(azArg[4])); 10210 if( rc ){ 10211 raw_printf(stderr, "User-Add failed: %d\n", rc); 10212 rc = 1; 10213 } 10214 }else if( strcmp(azArg[1],"edit")==0 ){ 10215 if( nArg!=5 ){ 10216 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n"); 10217 rc = 1; 10218 goto meta_command_exit; 10219 } 10220 rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 10221 booleanValue(azArg[4])); 10222 if( rc ){ 10223 raw_printf(stderr, "User-Edit failed: %d\n", rc); 10224 rc = 1; 10225 } 10226 }else if( strcmp(azArg[1],"delete")==0 ){ 10227 if( nArg!=3 ){ 10228 raw_printf(stderr, "Usage: .user delete USER\n"); 10229 rc = 1; 10230 goto meta_command_exit; 10231 } 10232 rc = sqlite3_user_delete(p->db, azArg[2]); 10233 if( rc ){ 10234 raw_printf(stderr, "User-Delete failed: %d\n", rc); 10235 rc = 1; 10236 } 10237 }else{ 10238 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n"); 10239 rc = 1; 10240 goto meta_command_exit; 10241 } 10242 }else 10243#endif /* SQLITE_USER_AUTHENTICATION */ 10244 10245 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){ 10246 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/, 10247 sqlite3_libversion(), sqlite3_sourceid()); 10248#if SQLITE_HAVE_ZLIB 10249 utf8_printf(p->out, "zlib version %s\n", zlibVersion()); 10250#endif 10251#define CTIMEOPT_VAL_(opt) #opt 10252#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) 10253#if defined(__clang__) && defined(__clang_major__) 10254 utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "." 10255 CTIMEOPT_VAL(__clang_minor__) "." 10256 CTIMEOPT_VAL(__clang_patchlevel__) "\n"); 10257#elif defined(_MSC_VER) 10258 utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) "\n"); 10259#elif defined(__GNUC__) && defined(__VERSION__) 10260 utf8_printf(p->out, "gcc-" __VERSION__ "\n"); 10261#endif 10262 }else 10263 10264 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){ 10265 const char *zDbName = nArg==2 ? azArg[1] : "main"; 10266 sqlite3_vfs *pVfs = 0; 10267 if( p->db ){ 10268 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs); 10269 if( pVfs ){ 10270 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName); 10271 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 10272 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 10273 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 10274 } 10275 } 10276 }else 10277 10278 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){ 10279 sqlite3_vfs *pVfs; 10280 sqlite3_vfs *pCurrent = 0; 10281 if( p->db ){ 10282 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent); 10283 } 10284 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){ 10285 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName, 10286 pVfs==pCurrent ? " <--- CURRENT" : ""); 10287 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 10288 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 10289 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 10290 if( pVfs->pNext ){ 10291 raw_printf(p->out, "-----------------------------------\n"); 10292 } 10293 } 10294 }else 10295 10296 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){ 10297 const char *zDbName = nArg==2 ? azArg[1] : "main"; 10298 char *zVfsName = 0; 10299 if( p->db ){ 10300 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName); 10301 if( zVfsName ){ 10302 utf8_printf(p->out, "%s\n", zVfsName); 10303 sqlite3_free(zVfsName); 10304 } 10305 } 10306 }else 10307 10308#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 10309 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){ 10310 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff; 10311 }else 10312#endif 10313 10314 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ 10315 int j; 10316 assert( nArg<=ArraySize(azArg) ); 10317 p->nWidth = nArg-1; 10318 p->colWidth = realloc(p->colWidth, p->nWidth*sizeof(int)*2); 10319 if( p->colWidth==0 && p->nWidth>0 ) shell_out_of_memory(); 10320 if( p->nWidth ) p->actualWidth = &p->colWidth[p->nWidth]; 10321 for(j=1; j<nArg; j++){ 10322 p->colWidth[j-1] = (int)integerValue(azArg[j]); 10323 } 10324 }else 10325 10326 { 10327 utf8_printf(stderr, "Error: unknown command or invalid arguments: " 10328 " \"%s\". Enter \".help\" for help\n", azArg[0]); 10329 rc = 1; 10330 } 10331 10332meta_command_exit: 10333 if( p->outCount ){ 10334 p->outCount--; 10335 if( p->outCount==0 ) output_reset(p); 10336 } 10337 return rc; 10338} 10339 10340/* 10341** Return TRUE if a semicolon occurs anywhere in the first N characters 10342** of string z[]. 10343*/ 10344static int line_contains_semicolon(const char *z, int N){ 10345 int i; 10346 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; } 10347 return 0; 10348} 10349 10350/* 10351** Test to see if a line consists entirely of whitespace. 10352*/ 10353static int _all_whitespace(const char *z){ 10354 for(; *z; z++){ 10355 if( IsSpace(z[0]) ) continue; 10356 if( *z=='/' && z[1]=='*' ){ 10357 z += 2; 10358 while( *z && (*z!='*' || z[1]!='/') ){ z++; } 10359 if( *z==0 ) return 0; 10360 z++; 10361 continue; 10362 } 10363 if( *z=='-' && z[1]=='-' ){ 10364 z += 2; 10365 while( *z && *z!='\n' ){ z++; } 10366 if( *z==0 ) return 1; 10367 continue; 10368 } 10369 return 0; 10370 } 10371 return 1; 10372} 10373 10374/* 10375** Return TRUE if the line typed in is an SQL command terminator other 10376** than a semi-colon. The SQL Server style "go" command is understood 10377** as is the Oracle "/". 10378*/ 10379static int line_is_command_terminator(const char *zLine){ 10380 while( IsSpace(zLine[0]) ){ zLine++; }; 10381 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){ 10382 return 1; /* Oracle */ 10383 } 10384 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' 10385 && _all_whitespace(&zLine[2]) ){ 10386 return 1; /* SQL Server */ 10387 } 10388 return 0; 10389} 10390 10391/* 10392** We need a default sqlite3_complete() implementation to use in case 10393** the shell is compiled with SQLITE_OMIT_COMPLETE. The default assumes 10394** any arbitrary text is a complete SQL statement. This is not very 10395** user-friendly, but it does seem to work. 10396*/ 10397#ifdef SQLITE_OMIT_COMPLETE 10398#define sqlite3_complete(x) 1 10399#endif 10400 10401/* 10402** Return true if zSql is a complete SQL statement. Return false if it 10403** ends in the middle of a string literal or C-style comment. 10404*/ 10405static int line_is_complete(char *zSql, int nSql){ 10406 int rc; 10407 if( zSql==0 ) return 1; 10408 zSql[nSql] = ';'; 10409 zSql[nSql+1] = 0; 10410 rc = sqlite3_complete(zSql); 10411 zSql[nSql] = 0; 10412 return rc; 10413} 10414 10415/* 10416** Run a single line of SQL. Return the number of errors. 10417*/ 10418static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){ 10419 int rc; 10420 char *zErrMsg = 0; 10421 10422 open_db(p, 0); 10423 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql); 10424 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 10425 BEGIN_TIMER; 10426 rc = shell_exec(p, zSql, &zErrMsg); 10427 END_TIMER; 10428 if( rc || zErrMsg ){ 10429 char zPrefix[100]; 10430 if( in!=0 || !stdin_is_interactive ){ 10431 sqlite3_snprintf(sizeof(zPrefix), zPrefix, 10432 "Error: near line %d:", startline); 10433 }else{ 10434 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); 10435 } 10436 if( zErrMsg!=0 ){ 10437 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg); 10438 sqlite3_free(zErrMsg); 10439 zErrMsg = 0; 10440 }else{ 10441 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); 10442 } 10443 return 1; 10444 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){ 10445 raw_printf(p->out, "changes: %3d total_changes: %d\n", 10446 sqlite3_changes(p->db), sqlite3_total_changes(p->db)); 10447 } 10448 return 0; 10449} 10450 10451 10452/* 10453** Read input from *in and process it. If *in==0 then input 10454** is interactive - the user is typing it it. Otherwise, input 10455** is coming from a file or device. A prompt is issued and history 10456** is saved only if input is interactive. An interrupt signal will 10457** cause this routine to exit immediately, unless input is interactive. 10458** 10459** Return the number of errors. 10460*/ 10461static int process_input(ShellState *p){ 10462 char *zLine = 0; /* A single input line */ 10463 char *zSql = 0; /* Accumulated SQL text */ 10464 int nLine; /* Length of current line */ 10465 int nSql = 0; /* Bytes of zSql[] used */ 10466 int nAlloc = 0; /* Allocated zSql[] space */ 10467 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */ 10468 int rc; /* Error code */ 10469 int errCnt = 0; /* Number of errors seen */ 10470 int startline = 0; /* Line number for start of current input */ 10471 10472 p->lineno = 0; 10473 while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){ 10474 fflush(p->out); 10475 zLine = one_input_line(p->in, zLine, nSql>0); 10476 if( zLine==0 ){ 10477 /* End of input */ 10478 if( p->in==0 && stdin_is_interactive ) printf("\n"); 10479 break; 10480 } 10481 if( seenInterrupt ){ 10482 if( p->in!=0 ) break; 10483 seenInterrupt = 0; 10484 } 10485 p->lineno++; 10486 if( nSql==0 && _all_whitespace(zLine) ){ 10487 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 10488 continue; 10489 } 10490 if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){ 10491 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 10492 if( zLine[0]=='.' ){ 10493 rc = do_meta_command(zLine, p); 10494 if( rc==2 ){ /* exit requested */ 10495 break; 10496 }else if( rc ){ 10497 errCnt++; 10498 } 10499 } 10500 continue; 10501 } 10502 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){ 10503 memcpy(zLine,";",2); 10504 } 10505 nLine = strlen30(zLine); 10506 if( nSql+nLine+2>=nAlloc ){ 10507 nAlloc = nSql+nLine+100; 10508 zSql = realloc(zSql, nAlloc); 10509 if( zSql==0 ) shell_out_of_memory(); 10510 } 10511 nSqlPrior = nSql; 10512 if( nSql==0 ){ 10513 int i; 10514 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){} 10515 assert( nAlloc>0 && zSql!=0 ); 10516 memcpy(zSql, zLine+i, nLine+1-i); 10517 startline = p->lineno; 10518 nSql = nLine-i; 10519 }else{ 10520 zSql[nSql++] = '\n'; 10521 memcpy(zSql+nSql, zLine, nLine+1); 10522 nSql += nLine; 10523 } 10524 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) 10525 && sqlite3_complete(zSql) ){ 10526 errCnt += runOneSqlLine(p, zSql, p->in, startline); 10527 nSql = 0; 10528 if( p->outCount ){ 10529 output_reset(p); 10530 p->outCount = 0; 10531 }else{ 10532 clearTempFile(p); 10533 } 10534 }else if( nSql && _all_whitespace(zSql) ){ 10535 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql); 10536 nSql = 0; 10537 } 10538 } 10539 if( nSql && !_all_whitespace(zSql) ){ 10540 errCnt += runOneSqlLine(p, zSql, p->in, startline); 10541 } 10542 free(zSql); 10543 free(zLine); 10544 return errCnt>0; 10545} 10546 10547/* 10548** Return a pathname which is the user's home directory. A 10549** 0 return indicates an error of some kind. 10550*/ 10551static char *find_home_dir(int clearFlag){ 10552 static char *home_dir = NULL; 10553 if( clearFlag ){ 10554 free(home_dir); 10555 home_dir = 0; 10556 return 0; 10557 } 10558 if( home_dir ) return home_dir; 10559 10560#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \ 10561 && !defined(__RTP__) && !defined(_WRS_KERNEL) 10562 { 10563 struct passwd *pwent; 10564 uid_t uid = getuid(); 10565 if( (pwent=getpwuid(uid)) != NULL) { 10566 home_dir = pwent->pw_dir; 10567 } 10568 } 10569#endif 10570 10571#if defined(_WIN32_WCE) 10572 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() 10573 */ 10574 home_dir = "/"; 10575#else 10576 10577#if defined(_WIN32) || defined(WIN32) 10578 if (!home_dir) { 10579 home_dir = getenv("USERPROFILE"); 10580 } 10581#endif 10582 10583 if (!home_dir) { 10584 home_dir = getenv("HOME"); 10585 } 10586 10587#if defined(_WIN32) || defined(WIN32) 10588 if (!home_dir) { 10589 char *zDrive, *zPath; 10590 int n; 10591 zDrive = getenv("HOMEDRIVE"); 10592 zPath = getenv("HOMEPATH"); 10593 if( zDrive && zPath ){ 10594 n = strlen30(zDrive) + strlen30(zPath) + 1; 10595 home_dir = malloc( n ); 10596 if( home_dir==0 ) return 0; 10597 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); 10598 return home_dir; 10599 } 10600 home_dir = "c:\\"; 10601 } 10602#endif 10603 10604#endif /* !_WIN32_WCE */ 10605 10606 if( home_dir ){ 10607 int n = strlen30(home_dir) + 1; 10608 char *z = malloc( n ); 10609 if( z ) memcpy(z, home_dir, n); 10610 home_dir = z; 10611 } 10612 10613 return home_dir; 10614} 10615 10616/* 10617** Read input from the file given by sqliterc_override. Or if that 10618** parameter is NULL, take input from ~/.sqliterc 10619** 10620** Returns the number of errors. 10621*/ 10622static void process_sqliterc( 10623 ShellState *p, /* Configuration data */ 10624 const char *sqliterc_override /* Name of config file. NULL to use default */ 10625){ 10626 char *home_dir = NULL; 10627 const char *sqliterc = sqliterc_override; 10628 char *zBuf = 0; 10629 FILE *inSaved = p->in; 10630 int savedLineno = p->lineno; 10631 10632 if (sqliterc == NULL) { 10633 home_dir = find_home_dir(0); 10634 if( home_dir==0 ){ 10635 raw_printf(stderr, "-- warning: cannot find home directory;" 10636 " cannot read ~/.sqliterc\n"); 10637 return; 10638 } 10639 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir); 10640 sqliterc = zBuf; 10641 } 10642 p->in = fopen(sqliterc,"rb"); 10643 if( p->in ){ 10644 if( stdin_is_interactive ){ 10645 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc); 10646 } 10647 if( process_input(p) && bail_on_error ) exit(1); 10648 fclose(p->in); 10649 }else if( sqliterc_override!=0 ){ 10650 utf8_printf(stderr,"cannot open: \"%s\"\n", sqliterc); 10651 if( bail_on_error ) exit(1); 10652 } 10653 p->in = inSaved; 10654 p->lineno = savedLineno; 10655 sqlite3_free(zBuf); 10656} 10657 10658/* 10659** Show available command line options 10660*/ 10661static const char zOptions[] = 10662#if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 10663 " -A ARGS... run \".archive ARGS\" and exit\n" 10664#endif 10665 " -append append the database to the end of the file\n" 10666 " -ascii set output mode to 'ascii'\n" 10667 " -bail stop after hitting an error\n" 10668 " -batch force batch I/O\n" 10669 " -box set output mode to 'box'\n" 10670 " -column set output mode to 'column'\n" 10671 " -cmd COMMAND run \"COMMAND\" before reading stdin\n" 10672 " -csv set output mode to 'csv'\n" 10673#if defined(SQLITE_ENABLE_DESERIALIZE) 10674 " -deserialize open the database using sqlite3_deserialize()\n" 10675#endif 10676 " -echo print commands before execution\n" 10677 " -init FILENAME read/process named file\n" 10678 " -[no]header turn headers on or off\n" 10679#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 10680 " -heap SIZE Size of heap for memsys3 or memsys5\n" 10681#endif 10682 " -help show this message\n" 10683 " -html set output mode to HTML\n" 10684 " -interactive force interactive I/O\n" 10685 " -json set output mode to 'json'\n" 10686 " -line set output mode to 'line'\n" 10687 " -list set output mode to 'list'\n" 10688 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n" 10689 " -markdown set output mode to 'markdown'\n" 10690#if defined(SQLITE_ENABLE_DESERIALIZE) 10691 " -maxsize N maximum size for a --deserialize database\n" 10692#endif 10693 " -memtrace trace all memory allocations and deallocations\n" 10694 " -mmap N default mmap size set to N\n" 10695#ifdef SQLITE_ENABLE_MULTIPLEX 10696 " -multiplex enable the multiplexor VFS\n" 10697#endif 10698 " -newline SEP set output row separator. Default: '\\n'\n" 10699 " -nofollow refuse to open symbolic links to database files\n" 10700 " -nullvalue TEXT set text string for NULL values. Default ''\n" 10701 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n" 10702 " -quote set output mode to 'quote'\n" 10703 " -readonly open the database read-only\n" 10704 " -separator SEP set output column separator. Default: '|'\n" 10705#ifdef SQLITE_ENABLE_SORTER_REFERENCES 10706 " -sorterref SIZE sorter references threshold size\n" 10707#endif 10708 " -stats print memory stats before each finalize\n" 10709 " -table set output mode to 'table'\n" 10710 " -tabs set output mode to 'tabs'\n" 10711 " -version show SQLite version\n" 10712 " -vfs NAME use NAME as the default VFS\n" 10713#ifdef SQLITE_ENABLE_VFSTRACE 10714 " -vfstrace enable tracing of all VFS calls\n" 10715#endif 10716#ifdef SQLITE_HAVE_ZLIB 10717 " -zip open the file as a ZIP Archive\n" 10718#endif 10719; 10720static void usage(int showDetail){ 10721 utf8_printf(stderr, 10722 "Usage: %s [OPTIONS] FILENAME [SQL]\n" 10723 "FILENAME is the name of an SQLite database. A new database is created\n" 10724 "if the file does not previously exist.\n", Argv0); 10725 if( showDetail ){ 10726 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions); 10727 }else{ 10728 raw_printf(stderr, "Use the -help option for additional information\n"); 10729 } 10730 exit(1); 10731} 10732 10733/* 10734** Internal check: Verify that the SQLite is uninitialized. Print a 10735** error message if it is initialized. 10736*/ 10737static void verify_uninitialized(void){ 10738 if( sqlite3_config(-1)==SQLITE_MISUSE ){ 10739 utf8_printf(stdout, "WARNING: attempt to configure SQLite after" 10740 " initialization.\n"); 10741 } 10742} 10743 10744/* 10745** Initialize the state information in data 10746*/ 10747static void main_init(ShellState *data) { 10748 memset(data, 0, sizeof(*data)); 10749 data->normalMode = data->cMode = data->mode = MODE_List; 10750 data->autoExplain = 1; 10751 memcpy(data->colSeparator,SEP_Column, 2); 10752 memcpy(data->rowSeparator,SEP_Row, 2); 10753 data->showHeader = 0; 10754 data->shellFlgs = SHFLG_Lookaside; 10755 verify_uninitialized(); 10756 sqlite3_config(SQLITE_CONFIG_URI, 1); 10757 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); 10758 sqlite3_config(SQLITE_CONFIG_MULTITHREAD); 10759 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); 10760 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); 10761} 10762 10763/* 10764** Output text to the console in a font that attracts extra attention. 10765*/ 10766#ifdef _WIN32 10767static void printBold(const char *zText){ 10768#if !SQLITE_OS_WINRT 10769 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); 10770 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo; 10771 GetConsoleScreenBufferInfo(out, &defaultScreenInfo); 10772 SetConsoleTextAttribute(out, 10773 FOREGROUND_RED|FOREGROUND_INTENSITY 10774 ); 10775#endif 10776 printf("%s", zText); 10777#if !SQLITE_OS_WINRT 10778 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes); 10779#endif 10780} 10781#else 10782static void printBold(const char *zText){ 10783 printf("\033[1m%s\033[0m", zText); 10784} 10785#endif 10786 10787/* 10788** Get the argument to an --option. Throw an error and die if no argument 10789** is available. 10790*/ 10791static char *cmdline_option_value(int argc, char **argv, int i){ 10792 if( i==argc ){ 10793 utf8_printf(stderr, "%s: Error: missing argument to %s\n", 10794 argv[0], argv[argc-1]); 10795 exit(1); 10796 } 10797 return argv[i]; 10798} 10799 10800#ifndef SQLITE_SHELL_IS_UTF8 10801# if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER) 10802# define SQLITE_SHELL_IS_UTF8 (0) 10803# else 10804# define SQLITE_SHELL_IS_UTF8 (1) 10805# endif 10806#endif 10807 10808#if SQLITE_SHELL_IS_UTF8 10809int SQLITE_CDECL main(int argc, char **argv){ 10810#else 10811int SQLITE_CDECL wmain(int argc, wchar_t **wargv){ 10812 char **argv; 10813#endif 10814 char *zErrMsg = 0; 10815 ShellState data; 10816 const char *zInitFile = 0; 10817 int i; 10818 int rc = 0; 10819 int warnInmemoryDb = 0; 10820 int readStdin = 1; 10821 int nCmd = 0; 10822 char **azCmd = 0; 10823 const char *zVfs = 0; /* Value of -vfs command-line option */ 10824#if !SQLITE_SHELL_IS_UTF8 10825 char **argvToFree = 0; 10826 int argcToFree = 0; 10827#endif 10828 10829 setBinaryMode(stdin, 0); 10830 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */ 10831 stdin_is_interactive = isatty(0); 10832 stdout_is_console = isatty(1); 10833 10834#ifdef SQLITE_DEBUG 10835 registerOomSimulator(); 10836#endif 10837 10838#if !defined(_WIN32_WCE) 10839 if( getenv("SQLITE_DEBUG_BREAK") ){ 10840 if( isatty(0) && isatty(2) ){ 10841 fprintf(stderr, 10842 "attach debugger to process %d and press any key to continue.\n", 10843 GETPID()); 10844 fgetc(stdin); 10845 }else{ 10846#if defined(_WIN32) || defined(WIN32) 10847#if SQLITE_OS_WINRT 10848 __debugbreak(); 10849#else 10850 DebugBreak(); 10851#endif 10852#elif defined(SIGTRAP) 10853 raise(SIGTRAP); 10854#endif 10855 } 10856 } 10857#endif 10858 10859#if USE_SYSTEM_SQLITE+0!=1 10860 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){ 10861 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n", 10862 sqlite3_sourceid(), SQLITE_SOURCE_ID); 10863 exit(1); 10864 } 10865#endif 10866 main_init(&data); 10867 10868 /* On Windows, we must translate command-line arguments into UTF-8. 10869 ** The SQLite memory allocator subsystem has to be enabled in order to 10870 ** do this. But we want to run an sqlite3_shutdown() afterwards so that 10871 ** subsequent sqlite3_config() calls will work. So copy all results into 10872 ** memory that does not come from the SQLite memory allocator. 10873 */ 10874#if !SQLITE_SHELL_IS_UTF8 10875 sqlite3_initialize(); 10876 argvToFree = malloc(sizeof(argv[0])*argc*2); 10877 argcToFree = argc; 10878 argv = argvToFree + argc; 10879 if( argv==0 ) shell_out_of_memory(); 10880 for(i=0; i<argc; i++){ 10881 char *z = sqlite3_win32_unicode_to_utf8(wargv[i]); 10882 int n; 10883 if( z==0 ) shell_out_of_memory(); 10884 n = (int)strlen(z); 10885 argv[i] = malloc( n+1 ); 10886 if( argv[i]==0 ) shell_out_of_memory(); 10887 memcpy(argv[i], z, n+1); 10888 argvToFree[i] = argv[i]; 10889 sqlite3_free(z); 10890 } 10891 sqlite3_shutdown(); 10892#endif 10893 10894 assert( argc>=1 && argv && argv[0] ); 10895 Argv0 = argv[0]; 10896 10897 /* Make sure we have a valid signal handler early, before anything 10898 ** else is done. 10899 */ 10900#ifdef SIGINT 10901 signal(SIGINT, interrupt_handler); 10902#elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 10903 SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE); 10904#endif 10905 10906#ifdef SQLITE_SHELL_DBNAME_PROC 10907 { 10908 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name 10909 ** of a C-function that will provide the name of the database file. Use 10910 ** this compile-time option to embed this shell program in larger 10911 ** applications. */ 10912 extern void SQLITE_SHELL_DBNAME_PROC(const char**); 10913 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename); 10914 warnInmemoryDb = 0; 10915 } 10916#endif 10917 10918 /* Do an initial pass through the command-line argument to locate 10919 ** the name of the database file, the name of the initialization file, 10920 ** the size of the alternative malloc heap, 10921 ** and the first command to execute. 10922 */ 10923 verify_uninitialized(); 10924 for(i=1; i<argc; i++){ 10925 char *z; 10926 z = argv[i]; 10927 if( z[0]!='-' ){ 10928 if( data.zDbFilename==0 ){ 10929 data.zDbFilename = z; 10930 }else{ 10931 /* Excesss arguments are interpreted as SQL (or dot-commands) and 10932 ** mean that nothing is read from stdin */ 10933 readStdin = 0; 10934 nCmd++; 10935 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd); 10936 if( azCmd==0 ) shell_out_of_memory(); 10937 azCmd[nCmd-1] = z; 10938 } 10939 } 10940 if( z[1]=='-' ) z++; 10941 if( strcmp(z,"-separator")==0 10942 || strcmp(z,"-nullvalue")==0 10943 || strcmp(z,"-newline")==0 10944 || strcmp(z,"-cmd")==0 10945 ){ 10946 (void)cmdline_option_value(argc, argv, ++i); 10947 }else if( strcmp(z,"-init")==0 ){ 10948 zInitFile = cmdline_option_value(argc, argv, ++i); 10949 }else if( strcmp(z,"-batch")==0 ){ 10950 /* Need to check for batch mode here to so we can avoid printing 10951 ** informational messages (like from process_sqliterc) before 10952 ** we do the actual processing of arguments later in a second pass. 10953 */ 10954 stdin_is_interactive = 0; 10955 }else if( strcmp(z,"-heap")==0 ){ 10956#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 10957 const char *zSize; 10958 sqlite3_int64 szHeap; 10959 10960 zSize = cmdline_option_value(argc, argv, ++i); 10961 szHeap = integerValue(zSize); 10962 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000; 10963 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64); 10964#else 10965 (void)cmdline_option_value(argc, argv, ++i); 10966#endif 10967 }else if( strcmp(z,"-pagecache")==0 ){ 10968 sqlite3_int64 n, sz; 10969 sz = integerValue(cmdline_option_value(argc,argv,++i)); 10970 if( sz>70000 ) sz = 70000; 10971 if( sz<0 ) sz = 0; 10972 n = integerValue(cmdline_option_value(argc,argv,++i)); 10973 if( sz>0 && n>0 && 0xffffffffffffLL/sz<n ){ 10974 n = 0xffffffffffffLL/sz; 10975 } 10976 sqlite3_config(SQLITE_CONFIG_PAGECACHE, 10977 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n); 10978 data.shellFlgs |= SHFLG_Pagecache; 10979 }else if( strcmp(z,"-lookaside")==0 ){ 10980 int n, sz; 10981 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 10982 if( sz<0 ) sz = 0; 10983 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 10984 if( n<0 ) n = 0; 10985 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n); 10986 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside; 10987#ifdef SQLITE_ENABLE_VFSTRACE 10988 }else if( strcmp(z,"-vfstrace")==0 ){ 10989 extern int vfstrace_register( 10990 const char *zTraceName, 10991 const char *zOldVfsName, 10992 int (*xOut)(const char*,void*), 10993 void *pOutArg, 10994 int makeDefault 10995 ); 10996 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1); 10997#endif 10998#ifdef SQLITE_ENABLE_MULTIPLEX 10999 }else if( strcmp(z,"-multiplex")==0 ){ 11000 extern int sqlite3_multiple_initialize(const char*,int); 11001 sqlite3_multiplex_initialize(0, 1); 11002#endif 11003 }else if( strcmp(z,"-mmap")==0 ){ 11004 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 11005 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz); 11006#ifdef SQLITE_ENABLE_SORTER_REFERENCES 11007 }else if( strcmp(z,"-sorterref")==0 ){ 11008 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 11009 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz); 11010#endif 11011 }else if( strcmp(z,"-vfs")==0 ){ 11012 zVfs = cmdline_option_value(argc, argv, ++i); 11013#ifdef SQLITE_HAVE_ZLIB 11014 }else if( strcmp(z,"-zip")==0 ){ 11015 data.openMode = SHELL_OPEN_ZIPFILE; 11016#endif 11017 }else if( strcmp(z,"-append")==0 ){ 11018 data.openMode = SHELL_OPEN_APPENDVFS; 11019#ifdef SQLITE_ENABLE_DESERIALIZE 11020 }else if( strcmp(z,"-deserialize")==0 ){ 11021 data.openMode = SHELL_OPEN_DESERIALIZE; 11022 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 11023 data.szMax = integerValue(argv[++i]); 11024#endif 11025 }else if( strcmp(z,"-readonly")==0 ){ 11026 data.openMode = SHELL_OPEN_READONLY; 11027 }else if( strcmp(z,"-nofollow")==0 ){ 11028 data.openFlags = SQLITE_OPEN_NOFOLLOW; 11029#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 11030 }else if( strncmp(z, "-A",2)==0 ){ 11031 /* All remaining command-line arguments are passed to the ".archive" 11032 ** command, so ignore them */ 11033 break; 11034#endif 11035 }else if( strcmp(z, "-memtrace")==0 ){ 11036 sqlite3MemTraceActivate(stderr); 11037 }else if( strcmp(z,"-bail")==0 ){ 11038 bail_on_error = 1; 11039 } 11040 } 11041 verify_uninitialized(); 11042 11043 11044#ifdef SQLITE_SHELL_INIT_PROC 11045 { 11046 /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name 11047 ** of a C-function that will perform initialization actions on SQLite that 11048 ** occur just before or after sqlite3_initialize(). Use this compile-time 11049 ** option to embed this shell program in larger applications. */ 11050 extern void SQLITE_SHELL_INIT_PROC(void); 11051 SQLITE_SHELL_INIT_PROC(); 11052 } 11053#else 11054 /* All the sqlite3_config() calls have now been made. So it is safe 11055 ** to call sqlite3_initialize() and process any command line -vfs option. */ 11056 sqlite3_initialize(); 11057#endif 11058 11059 if( zVfs ){ 11060 sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs); 11061 if( pVfs ){ 11062 sqlite3_vfs_register(pVfs, 1); 11063 }else{ 11064 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]); 11065 exit(1); 11066 } 11067 } 11068 11069 if( data.zDbFilename==0 ){ 11070#ifndef SQLITE_OMIT_MEMORYDB 11071 data.zDbFilename = ":memory:"; 11072 warnInmemoryDb = argc==1; 11073#else 11074 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0); 11075 return 1; 11076#endif 11077 } 11078 data.out = stdout; 11079 sqlite3_appendvfs_init(0,0,0); 11080 11081 /* Go ahead and open the database file if it already exists. If the 11082 ** file does not exist, delay opening it. This prevents empty database 11083 ** files from being created if a user mistypes the database name argument 11084 ** to the sqlite command-line tool. 11085 */ 11086 if( access(data.zDbFilename, 0)==0 ){ 11087 open_db(&data, 0); 11088 } 11089 11090 /* Process the initialization file if there is one. If no -init option 11091 ** is given on the command line, look for a file named ~/.sqliterc and 11092 ** try to process it. 11093 */ 11094 process_sqliterc(&data,zInitFile); 11095 11096 /* Make a second pass through the command-line argument and set 11097 ** options. This second pass is delayed until after the initialization 11098 ** file is processed so that the command-line arguments will override 11099 ** settings in the initialization file. 11100 */ 11101 for(i=1; i<argc; i++){ 11102 char *z = argv[i]; 11103 if( z[0]!='-' ) continue; 11104 if( z[1]=='-' ){ z++; } 11105 if( strcmp(z,"-init")==0 ){ 11106 i++; 11107 }else if( strcmp(z,"-html")==0 ){ 11108 data.mode = MODE_Html; 11109 }else if( strcmp(z,"-list")==0 ){ 11110 data.mode = MODE_List; 11111 }else if( strcmp(z,"-quote")==0 ){ 11112 data.mode = MODE_Quote; 11113 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Comma); 11114 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Row); 11115 }else if( strcmp(z,"-line")==0 ){ 11116 data.mode = MODE_Line; 11117 }else if( strcmp(z,"-column")==0 ){ 11118 data.mode = MODE_Column; 11119 }else if( strcmp(z,"-json")==0 ){ 11120 data.mode = MODE_Json; 11121 }else if( strcmp(z,"-markdown")==0 ){ 11122 data.mode = MODE_Markdown; 11123 }else if( strcmp(z,"-table")==0 ){ 11124 data.mode = MODE_Table; 11125 }else if( strcmp(z,"-box")==0 ){ 11126 data.mode = MODE_Box; 11127 }else if( strcmp(z,"-csv")==0 ){ 11128 data.mode = MODE_Csv; 11129 memcpy(data.colSeparator,",",2); 11130#ifdef SQLITE_HAVE_ZLIB 11131 }else if( strcmp(z,"-zip")==0 ){ 11132 data.openMode = SHELL_OPEN_ZIPFILE; 11133#endif 11134 }else if( strcmp(z,"-append")==0 ){ 11135 data.openMode = SHELL_OPEN_APPENDVFS; 11136#ifdef SQLITE_ENABLE_DESERIALIZE 11137 }else if( strcmp(z,"-deserialize")==0 ){ 11138 data.openMode = SHELL_OPEN_DESERIALIZE; 11139 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 11140 data.szMax = integerValue(argv[++i]); 11141#endif 11142 }else if( strcmp(z,"-readonly")==0 ){ 11143 data.openMode = SHELL_OPEN_READONLY; 11144 }else if( strcmp(z,"-nofollow")==0 ){ 11145 data.openFlags |= SQLITE_OPEN_NOFOLLOW; 11146 }else if( strcmp(z,"-ascii")==0 ){ 11147 data.mode = MODE_Ascii; 11148 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Unit); 11149 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Record); 11150 }else if( strcmp(z,"-tabs")==0 ){ 11151 data.mode = MODE_List; 11152 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Tab); 11153 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Row); 11154 }else if( strcmp(z,"-separator")==0 ){ 11155 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 11156 "%s",cmdline_option_value(argc,argv,++i)); 11157 }else if( strcmp(z,"-newline")==0 ){ 11158 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 11159 "%s",cmdline_option_value(argc,argv,++i)); 11160 }else if( strcmp(z,"-nullvalue")==0 ){ 11161 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue, 11162 "%s",cmdline_option_value(argc,argv,++i)); 11163 }else if( strcmp(z,"-header")==0 ){ 11164 data.showHeader = 1; 11165 }else if( strcmp(z,"-noheader")==0 ){ 11166 data.showHeader = 0; 11167 }else if( strcmp(z,"-echo")==0 ){ 11168 ShellSetFlag(&data, SHFLG_Echo); 11169 }else if( strcmp(z,"-eqp")==0 ){ 11170 data.autoEQP = AUTOEQP_on; 11171 }else if( strcmp(z,"-eqpfull")==0 ){ 11172 data.autoEQP = AUTOEQP_full; 11173 }else if( strcmp(z,"-stats")==0 ){ 11174 data.statsOn = 1; 11175 }else if( strcmp(z,"-scanstats")==0 ){ 11176 data.scanstatsOn = 1; 11177 }else if( strcmp(z,"-backslash")==0 ){ 11178 /* Undocumented command-line option: -backslash 11179 ** Causes C-style backslash escapes to be evaluated in SQL statements 11180 ** prior to sending the SQL into SQLite. Useful for injecting 11181 ** crazy bytes in the middle of SQL statements for testing and debugging. 11182 */ 11183 ShellSetFlag(&data, SHFLG_Backslash); 11184 }else if( strcmp(z,"-bail")==0 ){ 11185 /* No-op. The bail_on_error flag should already be set. */ 11186 }else if( strcmp(z,"-version")==0 ){ 11187 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid()); 11188 return 0; 11189 }else if( strcmp(z,"-interactive")==0 ){ 11190 stdin_is_interactive = 1; 11191 }else if( strcmp(z,"-batch")==0 ){ 11192 stdin_is_interactive = 0; 11193 }else if( strcmp(z,"-heap")==0 ){ 11194 i++; 11195 }else if( strcmp(z,"-pagecache")==0 ){ 11196 i+=2; 11197 }else if( strcmp(z,"-lookaside")==0 ){ 11198 i+=2; 11199 }else if( strcmp(z,"-mmap")==0 ){ 11200 i++; 11201 }else if( strcmp(z,"-memtrace")==0 ){ 11202 i++; 11203#ifdef SQLITE_ENABLE_SORTER_REFERENCES 11204 }else if( strcmp(z,"-sorterref")==0 ){ 11205 i++; 11206#endif 11207 }else if( strcmp(z,"-vfs")==0 ){ 11208 i++; 11209#ifdef SQLITE_ENABLE_VFSTRACE 11210 }else if( strcmp(z,"-vfstrace")==0 ){ 11211 i++; 11212#endif 11213#ifdef SQLITE_ENABLE_MULTIPLEX 11214 }else if( strcmp(z,"-multiplex")==0 ){ 11215 i++; 11216#endif 11217 }else if( strcmp(z,"-help")==0 ){ 11218 usage(1); 11219 }else if( strcmp(z,"-cmd")==0 ){ 11220 /* Run commands that follow -cmd first and separately from commands 11221 ** that simply appear on the command-line. This seems goofy. It would 11222 ** be better if all commands ran in the order that they appear. But 11223 ** we retain the goofy behavior for historical compatibility. */ 11224 if( i==argc-1 ) break; 11225 z = cmdline_option_value(argc,argv,++i); 11226 if( z[0]=='.' ){ 11227 rc = do_meta_command(z, &data); 11228 if( rc && bail_on_error ) return rc==2 ? 0 : rc; 11229 }else{ 11230 open_db(&data, 0); 11231 rc = shell_exec(&data, z, &zErrMsg); 11232 if( zErrMsg!=0 ){ 11233 utf8_printf(stderr,"Error: %s\n", zErrMsg); 11234 if( bail_on_error ) return rc!=0 ? rc : 1; 11235 }else if( rc!=0 ){ 11236 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z); 11237 if( bail_on_error ) return rc; 11238 } 11239 } 11240#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 11241 }else if( strncmp(z, "-A", 2)==0 ){ 11242 if( nCmd>0 ){ 11243 utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands" 11244 " with \"%s\"\n", z); 11245 return 1; 11246 } 11247 open_db(&data, OPEN_DB_ZIPFILE); 11248 if( z[2] ){ 11249 argv[i] = &z[2]; 11250 arDotCommand(&data, 1, argv+(i-1), argc-(i-1)); 11251 }else{ 11252 arDotCommand(&data, 1, argv+i, argc-i); 11253 } 11254 readStdin = 0; 11255 break; 11256#endif 11257 }else{ 11258 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z); 11259 raw_printf(stderr,"Use -help for a list of options.\n"); 11260 return 1; 11261 } 11262 data.cMode = data.mode; 11263 } 11264 11265 if( !readStdin ){ 11266 /* Run all arguments that do not begin with '-' as if they were separate 11267 ** command-line inputs, except for the argToSkip argument which contains 11268 ** the database filename. 11269 */ 11270 for(i=0; i<nCmd; i++){ 11271 if( azCmd[i][0]=='.' ){ 11272 rc = do_meta_command(azCmd[i], &data); 11273 if( rc ){ 11274 free(azCmd); 11275 return rc==2 ? 0 : rc; 11276 } 11277 }else{ 11278 open_db(&data, 0); 11279 rc = shell_exec(&data, azCmd[i], &zErrMsg); 11280 if( zErrMsg || rc ){ 11281 if( zErrMsg!=0 ){ 11282 utf8_printf(stderr,"Error: %s\n", zErrMsg); 11283 }else{ 11284 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]); 11285 } 11286 sqlite3_free(zErrMsg); 11287 free(azCmd); 11288 return rc!=0 ? rc : 1; 11289 } 11290 } 11291 } 11292 }else{ 11293 /* Run commands received from standard input 11294 */ 11295 if( stdin_is_interactive ){ 11296 char *zHome; 11297 char *zHistory; 11298 int nHistory; 11299 printf( 11300 "SQLite version %s %.19s\n" /*extra-version-info*/ 11301 "Enter \".help\" for usage hints.\n", 11302 sqlite3_libversion(), sqlite3_sourceid() 11303 ); 11304 if( warnInmemoryDb ){ 11305 printf("Connected to a "); 11306 printBold("transient in-memory database"); 11307 printf(".\nUse \".open FILENAME\" to reopen on a " 11308 "persistent database.\n"); 11309 } 11310 zHistory = getenv("SQLITE_HISTORY"); 11311 if( zHistory ){ 11312 zHistory = strdup(zHistory); 11313 }else if( (zHome = find_home_dir(0))!=0 ){ 11314 nHistory = strlen30(zHome) + 20; 11315 if( (zHistory = malloc(nHistory))!=0 ){ 11316 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome); 11317 } 11318 } 11319 if( zHistory ){ shell_read_history(zHistory); } 11320#if HAVE_READLINE || HAVE_EDITLINE 11321 rl_attempted_completion_function = readline_completion; 11322#elif HAVE_LINENOISE 11323 linenoiseSetCompletionCallback(linenoise_completion); 11324#endif 11325 data.in = 0; 11326 rc = process_input(&data); 11327 if( zHistory ){ 11328 shell_stifle_history(2000); 11329 shell_write_history(zHistory); 11330 free(zHistory); 11331 } 11332 }else{ 11333 data.in = stdin; 11334 rc = process_input(&data); 11335 } 11336 } 11337 free(azCmd); 11338 set_table_name(&data, 0); 11339 if( data.db ){ 11340 session_close_all(&data); 11341 close_db(data.db); 11342 } 11343 sqlite3_free(data.zFreeOnClose); 11344 find_home_dir(1); 11345 output_reset(&data); 11346 data.doXdgOpen = 0; 11347 clearTempFile(&data); 11348#if !SQLITE_SHELL_IS_UTF8 11349 for(i=0; i<argcToFree; i++) free(argvToFree[i]); 11350 free(argvToFree); 11351#endif 11352 free(data.colWidth); 11353 /* Clear the global data structure so that valgrind will detect memory 11354 ** leaks */ 11355 memset(&data, 0, sizeof(data)); 11356 return rc; 11357} 11358