1 /* DO NOT EDIT! 2 ** This file is automatically generated by the script in the canonical 3 ** SQLite source tree at tool/mkshellc.tcl. That script combines source 4 ** code from various constituent source files of SQLite into this single 5 ** "shell.c" file used to implement the SQLite command-line shell. 6 ** 7 ** Most of the code found below comes from the "src/shell.c.in" file in 8 ** the canonical SQLite source tree. That main file contains "INCLUDE" 9 ** lines that specify other files in the canonical source tree that are 10 ** inserted to getnerate this complete program source file. 11 ** 12 ** The code from multiple files is combined into this single "shell.c" 13 ** source file to help make the command-line program easier to compile. 14 ** 15 ** To modify this program, get a copy of the canonical SQLite source tree, 16 ** edit the src/shell.c.in" and/or some of the other files that are included 17 ** by "src/shell.c.in", then rerun the tool/mkshellc.tcl script. 18 */ 19 /* 20 ** 2001 September 15 21 ** 22 ** The author disclaims copyright to this source code. In place of 23 ** a legal notice, here is a blessing: 24 ** 25 ** May you do good and not evil. 26 ** May you find forgiveness for yourself and forgive others. 27 ** May you share freely, never taking more than you give. 28 ** 29 ************************************************************************* 30 ** This file contains code to implement the "sqlite" command line 31 ** utility for accessing SQLite databases. 32 */ 33 #if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS) 34 /* This needs to come before any includes for MSVC compiler */ 35 #define _CRT_SECURE_NO_WARNINGS 36 #endif 37 38 /* 39 ** Warning pragmas copied from msvc.h in the core. 40 */ 41 #if defined(_MSC_VER) 42 #pragma warning(disable : 4054) 43 #pragma warning(disable : 4055) 44 #pragma warning(disable : 4100) 45 #pragma warning(disable : 4127) 46 #pragma warning(disable : 4130) 47 #pragma warning(disable : 4152) 48 #pragma warning(disable : 4189) 49 #pragma warning(disable : 4206) 50 #pragma warning(disable : 4210) 51 #pragma warning(disable : 4232) 52 #pragma warning(disable : 4244) 53 #pragma warning(disable : 4305) 54 #pragma warning(disable : 4306) 55 #pragma warning(disable : 4702) 56 #pragma warning(disable : 4706) 57 #endif /* defined(_MSC_VER) */ 58 59 /* 60 ** No support for loadable extensions in VxWorks. 61 */ 62 #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION 63 # define SQLITE_OMIT_LOAD_EXTENSION 1 64 #endif 65 66 /* 67 ** Enable large-file support for fopen() and friends on unix. 68 */ 69 #ifndef SQLITE_DISABLE_LFS 70 # define _LARGE_FILE 1 71 # ifndef _FILE_OFFSET_BITS 72 # define _FILE_OFFSET_BITS 64 73 # endif 74 # define _LARGEFILE_SOURCE 1 75 #endif 76 77 #include <stdlib.h> 78 #include <string.h> 79 #include <stdio.h> 80 #include <assert.h> 81 #include "sqlite3.h" 82 typedef sqlite3_int64 i64; 83 typedef sqlite3_uint64 u64; 84 typedef unsigned char u8; 85 #if SQLITE_USER_AUTHENTICATION 86 # include "sqlite3userauth.h" 87 #endif 88 #include <ctype.h> 89 #include <stdarg.h> 90 91 #if !defined(_WIN32) && !defined(WIN32) 92 # include <signal.h> 93 # if !defined(__RTP__) && !defined(_WRS_KERNEL) 94 # include <pwd.h> 95 # endif 96 #endif 97 #if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__) 98 # include <unistd.h> 99 # include <dirent.h> 100 # define GETPID getpid 101 # if defined(__MINGW32__) 102 # define DIRENT dirent 103 # ifndef S_ISLNK 104 # define S_ISLNK(mode) (0) 105 # endif 106 # endif 107 #else 108 # define GETPID (int)GetCurrentProcessId 109 #endif 110 #include <sys/types.h> 111 #include <sys/stat.h> 112 113 #if HAVE_READLINE 114 # include <readline/readline.h> 115 # include <readline/history.h> 116 #endif 117 118 #if HAVE_EDITLINE 119 # include <editline/readline.h> 120 #endif 121 122 #if HAVE_EDITLINE || HAVE_READLINE 123 124 # define shell_add_history(X) add_history(X) 125 # define shell_read_history(X) read_history(X) 126 # define shell_write_history(X) write_history(X) 127 # define shell_stifle_history(X) stifle_history(X) 128 # define shell_readline(X) readline(X) 129 130 #elif HAVE_LINENOISE 131 132 # include "linenoise.h" 133 # define shell_add_history(X) linenoiseHistoryAdd(X) 134 # define shell_read_history(X) linenoiseHistoryLoad(X) 135 # define shell_write_history(X) linenoiseHistorySave(X) 136 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X) 137 # define shell_readline(X) linenoise(X) 138 139 #else 140 141 # define shell_read_history(X) 142 # define shell_write_history(X) 143 # define shell_stifle_history(X) 144 145 # define SHELL_USE_LOCAL_GETLINE 1 146 #endif 147 148 149 #if defined(_WIN32) || defined(WIN32) 150 # include <io.h> 151 # include <fcntl.h> 152 # define isatty(h) _isatty(h) 153 # ifndef access 154 # define access(f,m) _access((f),(m)) 155 # endif 156 # ifndef unlink 157 # define unlink _unlink 158 # endif 159 # ifndef strdup 160 # define strdup _strdup 161 # endif 162 # undef popen 163 # define popen _popen 164 # undef pclose 165 # define pclose _pclose 166 #else 167 /* Make sure isatty() has a prototype. */ 168 extern int isatty(int); 169 170 # if !defined(__RTP__) && !defined(_WRS_KERNEL) 171 /* popen and pclose are not C89 functions and so are 172 ** sometimes omitted from the <stdio.h> header */ 173 extern FILE *popen(const char*,const char*); 174 extern int pclose(FILE*); 175 # else 176 # define SQLITE_OMIT_POPEN 1 177 # endif 178 #endif 179 180 #if defined(_WIN32_WCE) 181 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() 182 * thus we always assume that we have a console. That can be 183 * overridden with the -batch command line option. 184 */ 185 #define isatty(x) 1 186 #endif 187 188 /* ctype macros that work with signed characters */ 189 #define IsSpace(X) isspace((unsigned char)X) 190 #define IsDigit(X) isdigit((unsigned char)X) 191 #define ToLower(X) (char)tolower((unsigned char)X) 192 193 #if defined(_WIN32) || defined(WIN32) 194 #include <windows.h> 195 196 /* string conversion routines only needed on Win32 */ 197 extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR); 198 extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int); 199 extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int); 200 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText); 201 #endif 202 203 /* On Windows, we normally run with output mode of TEXT so that \n characters 204 ** are automatically translated into \r\n. However, this behavior needs 205 ** to be disabled in some cases (ex: when generating CSV output and when 206 ** rendering quoted strings that contain \n characters). The following 207 ** routines take care of that. 208 */ 209 #if defined(_WIN32) || defined(WIN32) 210 static void setBinaryMode(FILE *file, int isOutput){ 211 if( isOutput ) fflush(file); 212 _setmode(_fileno(file), _O_BINARY); 213 } 214 static void setTextMode(FILE *file, int isOutput){ 215 if( isOutput ) fflush(file); 216 _setmode(_fileno(file), _O_TEXT); 217 } 218 #else 219 # define setBinaryMode(X,Y) 220 # define setTextMode(X,Y) 221 #endif 222 223 224 /* True if the timer is enabled */ 225 static int enableTimer = 0; 226 227 /* Return the current wall-clock time */ 228 static sqlite3_int64 timeOfDay(void){ 229 static sqlite3_vfs *clockVfs = 0; 230 sqlite3_int64 t; 231 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0); 232 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){ 233 clockVfs->xCurrentTimeInt64(clockVfs, &t); 234 }else{ 235 double r; 236 clockVfs->xCurrentTime(clockVfs, &r); 237 t = (sqlite3_int64)(r*86400000.0); 238 } 239 return t; 240 } 241 242 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux) 243 #include <sys/time.h> 244 #include <sys/resource.h> 245 246 /* VxWorks does not support getrusage() as far as we can determine */ 247 #if defined(_WRS_KERNEL) || defined(__RTP__) 248 struct rusage { 249 struct timeval ru_utime; /* user CPU time used */ 250 struct timeval ru_stime; /* system CPU time used */ 251 }; 252 #define getrusage(A,B) memset(B,0,sizeof(*B)) 253 #endif 254 255 /* Saved resource information for the beginning of an operation */ 256 static struct rusage sBegin; /* CPU time at start */ 257 static sqlite3_int64 iBegin; /* Wall-clock time at start */ 258 259 /* 260 ** Begin timing an operation 261 */ 262 static void beginTimer(void){ 263 if( enableTimer ){ 264 getrusage(RUSAGE_SELF, &sBegin); 265 iBegin = timeOfDay(); 266 } 267 } 268 269 /* Return the difference of two time_structs in seconds */ 270 static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ 271 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + 272 (double)(pEnd->tv_sec - pStart->tv_sec); 273 } 274 275 /* 276 ** Print the timing results. 277 */ 278 static void endTimer(void){ 279 if( enableTimer ){ 280 sqlite3_int64 iEnd = timeOfDay(); 281 struct rusage sEnd; 282 getrusage(RUSAGE_SELF, &sEnd); 283 printf("Run Time: real %.3f user %f sys %f\n", 284 (iEnd - iBegin)*0.001, 285 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), 286 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); 287 } 288 } 289 290 #define BEGIN_TIMER beginTimer() 291 #define END_TIMER endTimer() 292 #define HAS_TIMER 1 293 294 #elif (defined(_WIN32) || defined(WIN32)) 295 296 /* Saved resource information for the beginning of an operation */ 297 static HANDLE hProcess; 298 static FILETIME ftKernelBegin; 299 static FILETIME ftUserBegin; 300 static sqlite3_int64 ftWallBegin; 301 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, 302 LPFILETIME, LPFILETIME); 303 static GETPROCTIMES getProcessTimesAddr = NULL; 304 305 /* 306 ** Check to see if we have timer support. Return 1 if necessary 307 ** support found (or found previously). 308 */ 309 static int hasTimer(void){ 310 if( getProcessTimesAddr ){ 311 return 1; 312 } else { 313 /* GetProcessTimes() isn't supported in WIN95 and some other Windows 314 ** versions. See if the version we are running on has it, and if it 315 ** does, save off a pointer to it and the current process handle. 316 */ 317 hProcess = GetCurrentProcess(); 318 if( hProcess ){ 319 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); 320 if( NULL != hinstLib ){ 321 getProcessTimesAddr = 322 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); 323 if( NULL != getProcessTimesAddr ){ 324 return 1; 325 } 326 FreeLibrary(hinstLib); 327 } 328 } 329 } 330 return 0; 331 } 332 333 /* 334 ** Begin timing an operation 335 */ 336 static void beginTimer(void){ 337 if( enableTimer && getProcessTimesAddr ){ 338 FILETIME ftCreation, ftExit; 339 getProcessTimesAddr(hProcess,&ftCreation,&ftExit, 340 &ftKernelBegin,&ftUserBegin); 341 ftWallBegin = timeOfDay(); 342 } 343 } 344 345 /* Return the difference of two FILETIME structs in seconds */ 346 static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ 347 sqlite_int64 i64Start = *((sqlite_int64 *) pStart); 348 sqlite_int64 i64End = *((sqlite_int64 *) pEnd); 349 return (double) ((i64End - i64Start) / 10000000.0); 350 } 351 352 /* 353 ** Print the timing results. 354 */ 355 static void endTimer(void){ 356 if( enableTimer && getProcessTimesAddr){ 357 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; 358 sqlite3_int64 ftWallEnd = timeOfDay(); 359 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd); 360 printf("Run Time: real %.3f user %f sys %f\n", 361 (ftWallEnd - ftWallBegin)*0.001, 362 timeDiff(&ftUserBegin, &ftUserEnd), 363 timeDiff(&ftKernelBegin, &ftKernelEnd)); 364 } 365 } 366 367 #define BEGIN_TIMER beginTimer() 368 #define END_TIMER endTimer() 369 #define HAS_TIMER hasTimer() 370 371 #else 372 #define BEGIN_TIMER 373 #define END_TIMER 374 #define HAS_TIMER 0 375 #endif 376 377 /* 378 ** Used to prevent warnings about unused parameters 379 */ 380 #define UNUSED_PARAMETER(x) (void)(x) 381 382 /* 383 ** Number of elements in an array 384 */ 385 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) 386 387 /* 388 ** If the following flag is set, then command execution stops 389 ** at an error if we are not interactive. 390 */ 391 static int bail_on_error = 0; 392 393 /* 394 ** Threat stdin as an interactive input if the following variable 395 ** is true. Otherwise, assume stdin is connected to a file or pipe. 396 */ 397 static int stdin_is_interactive = 1; 398 399 /* 400 ** On Windows systems we have to know if standard output is a console 401 ** in order to translate UTF-8 into MBCS. The following variable is 402 ** true if translation is required. 403 */ 404 static int stdout_is_console = 1; 405 406 /* 407 ** The following is the open SQLite database. We make a pointer 408 ** to this database a static variable so that it can be accessed 409 ** by the SIGINT handler to interrupt database processing. 410 */ 411 static sqlite3 *globalDb = 0; 412 413 /* 414 ** True if an interrupt (Control-C) has been received. 415 */ 416 static volatile int seenInterrupt = 0; 417 418 /* 419 ** This is the name of our program. It is set in main(), used 420 ** in a number of other places, mostly for error messages. 421 */ 422 static char *Argv0; 423 424 /* 425 ** Prompt strings. Initialized in main. Settable with 426 ** .prompt main continue 427 */ 428 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ 429 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ 430 431 /* 432 ** Render output like fprintf(). Except, if the output is going to the 433 ** console and if this is running on a Windows machine, translate the 434 ** output from UTF-8 into MBCS. 435 */ 436 #if defined(_WIN32) || defined(WIN32) 437 void utf8_printf(FILE *out, const char *zFormat, ...){ 438 va_list ap; 439 va_start(ap, zFormat); 440 if( stdout_is_console && (out==stdout || out==stderr) ){ 441 char *z1 = sqlite3_vmprintf(zFormat, ap); 442 char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0); 443 sqlite3_free(z1); 444 fputs(z2, out); 445 sqlite3_free(z2); 446 }else{ 447 vfprintf(out, zFormat, ap); 448 } 449 va_end(ap); 450 } 451 #elif !defined(utf8_printf) 452 # define utf8_printf fprintf 453 #endif 454 455 /* 456 ** Render output like fprintf(). This should not be used on anything that 457 ** includes string formatting (e.g. "%s"). 458 */ 459 #if !defined(raw_printf) 460 # define raw_printf fprintf 461 #endif 462 463 /* Indicate out-of-memory and exit. */ 464 static void shell_out_of_memory(void){ 465 raw_printf(stderr,"Error: out of memory\n"); 466 exit(1); 467 } 468 469 /* 470 ** Write I/O traces to the following stream. 471 */ 472 #ifdef SQLITE_ENABLE_IOTRACE 473 static FILE *iotrace = 0; 474 #endif 475 476 /* 477 ** This routine works like printf in that its first argument is a 478 ** format string and subsequent arguments are values to be substituted 479 ** in place of % fields. The result of formatting this string 480 ** is written to iotrace. 481 */ 482 #ifdef SQLITE_ENABLE_IOTRACE 483 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){ 484 va_list ap; 485 char *z; 486 if( iotrace==0 ) return; 487 va_start(ap, zFormat); 488 z = sqlite3_vmprintf(zFormat, ap); 489 va_end(ap); 490 utf8_printf(iotrace, "%s", z); 491 sqlite3_free(z); 492 } 493 #endif 494 495 /* 496 ** Output string zUtf to stream pOut as w characters. If w is negative, 497 ** then right-justify the text. W is the width in UTF-8 characters, not 498 ** in bytes. This is different from the %*.*s specification in printf 499 ** since with %*.*s the width is measured in bytes, not characters. 500 */ 501 static void utf8_width_print(FILE *pOut, int w, const char *zUtf){ 502 int i; 503 int n; 504 int aw = w<0 ? -w : w; 505 char zBuf[1000]; 506 if( aw>(int)sizeof(zBuf)/3 ) aw = (int)sizeof(zBuf)/3; 507 for(i=n=0; zUtf[i]; i++){ 508 if( (zUtf[i]&0xc0)!=0x80 ){ 509 n++; 510 if( n==aw ){ 511 do{ i++; }while( (zUtf[i]&0xc0)==0x80 ); 512 break; 513 } 514 } 515 } 516 if( n>=aw ){ 517 utf8_printf(pOut, "%.*s", i, zUtf); 518 }else if( w<0 ){ 519 utf8_printf(pOut, "%*s%s", aw-n, "", zUtf); 520 }else{ 521 utf8_printf(pOut, "%s%*s", zUtf, aw-n, ""); 522 } 523 } 524 525 526 /* 527 ** Determines if a string is a number of not. 528 */ 529 static int isNumber(const char *z, int *realnum){ 530 if( *z=='-' || *z=='+' ) z++; 531 if( !IsDigit(*z) ){ 532 return 0; 533 } 534 z++; 535 if( realnum ) *realnum = 0; 536 while( IsDigit(*z) ){ z++; } 537 if( *z=='.' ){ 538 z++; 539 if( !IsDigit(*z) ) return 0; 540 while( IsDigit(*z) ){ z++; } 541 if( realnum ) *realnum = 1; 542 } 543 if( *z=='e' || *z=='E' ){ 544 z++; 545 if( *z=='+' || *z=='-' ) z++; 546 if( !IsDigit(*z) ) return 0; 547 while( IsDigit(*z) ){ z++; } 548 if( realnum ) *realnum = 1; 549 } 550 return *z==0; 551 } 552 553 /* 554 ** Compute a string length that is limited to what can be stored in 555 ** lower 30 bits of a 32-bit signed integer. 556 */ 557 static int strlen30(const char *z){ 558 const char *z2 = z; 559 while( *z2 ){ z2++; } 560 return 0x3fffffff & (int)(z2 - z); 561 } 562 563 /* 564 ** Return the length of a string in characters. Multibyte UTF8 characters 565 ** count as a single character. 566 */ 567 static int strlenChar(const char *z){ 568 int n = 0; 569 while( *z ){ 570 if( (0xc0&*(z++))!=0x80 ) n++; 571 } 572 return n; 573 } 574 575 /* 576 ** This routine reads a line of text from FILE in, stores 577 ** the text in memory obtained from malloc() and returns a pointer 578 ** to the text. NULL is returned at end of file, or if malloc() 579 ** fails. 580 ** 581 ** If zLine is not NULL then it is a malloced buffer returned from 582 ** a previous call to this routine that may be reused. 583 */ 584 static char *local_getline(char *zLine, FILE *in){ 585 int nLine = zLine==0 ? 0 : 100; 586 int n = 0; 587 588 while( 1 ){ 589 if( n+100>nLine ){ 590 nLine = nLine*2 + 100; 591 zLine = realloc(zLine, nLine); 592 if( zLine==0 ) shell_out_of_memory(); 593 } 594 if( fgets(&zLine[n], nLine - n, in)==0 ){ 595 if( n==0 ){ 596 free(zLine); 597 return 0; 598 } 599 zLine[n] = 0; 600 break; 601 } 602 while( zLine[n] ) n++; 603 if( n>0 && zLine[n-1]=='\n' ){ 604 n--; 605 if( n>0 && zLine[n-1]=='\r' ) n--; 606 zLine[n] = 0; 607 break; 608 } 609 } 610 #if defined(_WIN32) || defined(WIN32) 611 /* For interactive input on Windows systems, translate the 612 ** multi-byte characterset characters into UTF-8. */ 613 if( stdin_is_interactive && in==stdin ){ 614 char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0); 615 if( zTrans ){ 616 int nTrans = strlen30(zTrans)+1; 617 if( nTrans>nLine ){ 618 zLine = realloc(zLine, nTrans); 619 if( zLine==0 ) shell_out_of_memory(); 620 } 621 memcpy(zLine, zTrans, nTrans); 622 sqlite3_free(zTrans); 623 } 624 } 625 #endif /* defined(_WIN32) || defined(WIN32) */ 626 return zLine; 627 } 628 629 /* 630 ** Retrieve a single line of input text. 631 ** 632 ** If in==0 then read from standard input and prompt before each line. 633 ** If isContinuation is true, then a continuation prompt is appropriate. 634 ** If isContinuation is zero, then the main prompt should be used. 635 ** 636 ** If zPrior is not NULL then it is a buffer from a prior call to this 637 ** routine that can be reused. 638 ** 639 ** The result is stored in space obtained from malloc() and must either 640 ** be freed by the caller or else passed back into this routine via the 641 ** zPrior argument for reuse. 642 */ 643 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){ 644 char *zPrompt; 645 char *zResult; 646 if( in!=0 ){ 647 zResult = local_getline(zPrior, in); 648 }else{ 649 zPrompt = isContinuation ? continuePrompt : mainPrompt; 650 #if SHELL_USE_LOCAL_GETLINE 651 printf("%s", zPrompt); 652 fflush(stdout); 653 zResult = local_getline(zPrior, stdin); 654 #else 655 free(zPrior); 656 zResult = shell_readline(zPrompt); 657 if( zResult && *zResult ) shell_add_history(zResult); 658 #endif 659 } 660 return zResult; 661 } 662 663 664 /* 665 ** Return the value of a hexadecimal digit. Return -1 if the input 666 ** is not a hex digit. 667 */ 668 static int hexDigitValue(char c){ 669 if( c>='0' && c<='9' ) return c - '0'; 670 if( c>='a' && c<='f' ) return c - 'a' + 10; 671 if( c>='A' && c<='F' ) return c - 'A' + 10; 672 return -1; 673 } 674 675 /* 676 ** Interpret zArg as an integer value, possibly with suffixes. 677 */ 678 static sqlite3_int64 integerValue(const char *zArg){ 679 sqlite3_int64 v = 0; 680 static const struct { char *zSuffix; int iMult; } aMult[] = { 681 { "KiB", 1024 }, 682 { "MiB", 1024*1024 }, 683 { "GiB", 1024*1024*1024 }, 684 { "KB", 1000 }, 685 { "MB", 1000000 }, 686 { "GB", 1000000000 }, 687 { "K", 1000 }, 688 { "M", 1000000 }, 689 { "G", 1000000000 }, 690 }; 691 int i; 692 int isNeg = 0; 693 if( zArg[0]=='-' ){ 694 isNeg = 1; 695 zArg++; 696 }else if( zArg[0]=='+' ){ 697 zArg++; 698 } 699 if( zArg[0]=='0' && zArg[1]=='x' ){ 700 int x; 701 zArg += 2; 702 while( (x = hexDigitValue(zArg[0]))>=0 ){ 703 v = (v<<4) + x; 704 zArg++; 705 } 706 }else{ 707 while( IsDigit(zArg[0]) ){ 708 v = v*10 + zArg[0] - '0'; 709 zArg++; 710 } 711 } 712 for(i=0; i<ArraySize(aMult); i++){ 713 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){ 714 v *= aMult[i].iMult; 715 break; 716 } 717 } 718 return isNeg? -v : v; 719 } 720 721 /* 722 ** A variable length string to which one can append text. 723 */ 724 typedef struct ShellText ShellText; 725 struct ShellText { 726 char *z; 727 int n; 728 int nAlloc; 729 }; 730 731 /* 732 ** Initialize and destroy a ShellText object 733 */ 734 static void initText(ShellText *p){ 735 memset(p, 0, sizeof(*p)); 736 } 737 static void freeText(ShellText *p){ 738 free(p->z); 739 initText(p); 740 } 741 742 /* zIn is either a pointer to a NULL-terminated string in memory obtained 743 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is 744 ** added to zIn, and the result returned in memory obtained from malloc(). 745 ** zIn, if it was not NULL, is freed. 746 ** 747 ** If the third argument, quote, is not '\0', then it is used as a 748 ** quote character for zAppend. 749 */ 750 static void appendText(ShellText *p, char const *zAppend, char quote){ 751 int len; 752 int i; 753 int nAppend = strlen30(zAppend); 754 755 len = nAppend+p->n+1; 756 if( quote ){ 757 len += 2; 758 for(i=0; i<nAppend; i++){ 759 if( zAppend[i]==quote ) len++; 760 } 761 } 762 763 if( p->n+len>=p->nAlloc ){ 764 p->nAlloc = p->nAlloc*2 + len + 20; 765 p->z = realloc(p->z, p->nAlloc); 766 if( p->z==0 ) shell_out_of_memory(); 767 } 768 769 if( quote ){ 770 char *zCsr = p->z+p->n; 771 *zCsr++ = quote; 772 for(i=0; i<nAppend; i++){ 773 *zCsr++ = zAppend[i]; 774 if( zAppend[i]==quote ) *zCsr++ = quote; 775 } 776 *zCsr++ = quote; 777 p->n = (int)(zCsr - p->z); 778 *zCsr = '\0'; 779 }else{ 780 memcpy(p->z+p->n, zAppend, nAppend); 781 p->n += nAppend; 782 p->z[p->n] = '\0'; 783 } 784 } 785 786 /* 787 ** Attempt to determine if identifier zName needs to be quoted, either 788 ** because it contains non-alphanumeric characters, or because it is an 789 ** SQLite keyword. Be conservative in this estimate: When in doubt assume 790 ** that quoting is required. 791 ** 792 ** Return '"' if quoting is required. Return 0 if no quoting is required. 793 */ 794 static char quoteChar(const char *zName){ 795 int i; 796 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"'; 797 for(i=0; zName[i]; i++){ 798 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"'; 799 } 800 return sqlite3_keyword_check(zName, i) ? '"' : 0; 801 } 802 803 /* 804 ** Construct a fake object name and column list to describe the structure 805 ** of the view, virtual table, or table valued function zSchema.zName. 806 */ 807 static char *shellFakeSchema( 808 sqlite3 *db, /* The database connection containing the vtab */ 809 const char *zSchema, /* Schema of the database holding the vtab */ 810 const char *zName /* The name of the virtual table */ 811 ){ 812 sqlite3_stmt *pStmt = 0; 813 char *zSql; 814 ShellText s; 815 char cQuote; 816 char *zDiv = "("; 817 int nRow = 0; 818 819 zSql = sqlite3_mprintf("PRAGMA \"%w\".table_info=%Q;", 820 zSchema ? zSchema : "main", zName); 821 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 822 sqlite3_free(zSql); 823 initText(&s); 824 if( zSchema ){ 825 cQuote = quoteChar(zSchema); 826 if( cQuote && sqlite3_stricmp(zSchema,"temp")==0 ) cQuote = 0; 827 appendText(&s, zSchema, cQuote); 828 appendText(&s, ".", 0); 829 } 830 cQuote = quoteChar(zName); 831 appendText(&s, zName, cQuote); 832 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 833 const char *zCol = (const char*)sqlite3_column_text(pStmt, 1); 834 nRow++; 835 appendText(&s, zDiv, 0); 836 zDiv = ","; 837 cQuote = quoteChar(zCol); 838 appendText(&s, zCol, cQuote); 839 } 840 appendText(&s, ")", 0); 841 sqlite3_finalize(pStmt); 842 if( nRow==0 ){ 843 freeText(&s); 844 s.z = 0; 845 } 846 return s.z; 847 } 848 849 /* 850 ** SQL function: shell_module_schema(X) 851 ** 852 ** Return a fake schema for the table-valued function or eponymous virtual 853 ** table X. 854 */ 855 static void shellModuleSchema( 856 sqlite3_context *pCtx, 857 int nVal, 858 sqlite3_value **apVal 859 ){ 860 const char *zName = (const char*)sqlite3_value_text(apVal[0]); 861 char *zFake = shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName); 862 UNUSED_PARAMETER(nVal); 863 if( zFake ){ 864 sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake), 865 -1, sqlite3_free); 866 free(zFake); 867 } 868 } 869 870 /* 871 ** SQL function: shell_add_schema(S,X) 872 ** 873 ** Add the schema name X to the CREATE statement in S and return the result. 874 ** Examples: 875 ** 876 ** CREATE TABLE t1(x) -> CREATE TABLE xyz.t1(x); 877 ** 878 ** Also works on 879 ** 880 ** CREATE INDEX 881 ** CREATE UNIQUE INDEX 882 ** CREATE VIEW 883 ** CREATE TRIGGER 884 ** CREATE VIRTUAL TABLE 885 ** 886 ** This UDF is used by the .schema command to insert the schema name of 887 ** attached databases into the middle of the sqlite_master.sql field. 888 */ 889 static void shellAddSchemaName( 890 sqlite3_context *pCtx, 891 int nVal, 892 sqlite3_value **apVal 893 ){ 894 static const char *aPrefix[] = { 895 "TABLE", 896 "INDEX", 897 "UNIQUE INDEX", 898 "VIEW", 899 "TRIGGER", 900 "VIRTUAL TABLE" 901 }; 902 int i = 0; 903 const char *zIn = (const char*)sqlite3_value_text(apVal[0]); 904 const char *zSchema = (const char*)sqlite3_value_text(apVal[1]); 905 const char *zName = (const char*)sqlite3_value_text(apVal[2]); 906 sqlite3 *db = sqlite3_context_db_handle(pCtx); 907 UNUSED_PARAMETER(nVal); 908 if( zIn!=0 && strncmp(zIn, "CREATE ", 7)==0 ){ 909 for(i=0; i<(int)(sizeof(aPrefix)/sizeof(aPrefix[0])); i++){ 910 int n = strlen30(aPrefix[i]); 911 if( strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){ 912 char *z = 0; 913 char *zFake = 0; 914 if( zSchema ){ 915 char cQuote = quoteChar(zSchema); 916 if( cQuote && sqlite3_stricmp(zSchema,"temp")!=0 ){ 917 z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8); 918 }else{ 919 z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8); 920 } 921 } 922 if( zName 923 && aPrefix[i][0]=='V' 924 && (zFake = shellFakeSchema(db, zSchema, zName))!=0 925 ){ 926 if( z==0 ){ 927 z = sqlite3_mprintf("%s\n/* %s */", zIn, zFake); 928 }else{ 929 z = sqlite3_mprintf("%z\n/* %s */", z, zFake); 930 } 931 free(zFake); 932 } 933 if( z ){ 934 sqlite3_result_text(pCtx, z, -1, sqlite3_free); 935 return; 936 } 937 } 938 } 939 } 940 sqlite3_result_value(pCtx, apVal[0]); 941 } 942 943 /* 944 ** The source code for several run-time loadable extensions is inserted 945 ** below by the ../tool/mkshellc.tcl script. Before processing that included 946 ** code, we need to override some macros to make the included program code 947 ** work here in the middle of this regular program. 948 */ 949 #define SQLITE_EXTENSION_INIT1 950 #define SQLITE_EXTENSION_INIT2(X) (void)(X) 951 952 #if defined(_WIN32) && defined(_MSC_VER) 953 /************************* Begin test_windirent.h ******************/ 954 /* 955 ** 2015 November 30 956 ** 957 ** The author disclaims copyright to this source code. In place of 958 ** a legal notice, here is a blessing: 959 ** 960 ** May you do good and not evil. 961 ** May you find forgiveness for yourself and forgive others. 962 ** May you share freely, never taking more than you give. 963 ** 964 ************************************************************************* 965 ** This file contains declarations for most of the opendir() family of 966 ** POSIX functions on Win32 using the MSVCRT. 967 */ 968 969 #if defined(_WIN32) && defined(_MSC_VER) && !defined(SQLITE_WINDIRENT_H) 970 #define SQLITE_WINDIRENT_H 971 972 /* 973 ** We need several data types from the Windows SDK header. 974 */ 975 976 #ifndef WIN32_LEAN_AND_MEAN 977 #define WIN32_LEAN_AND_MEAN 978 #endif 979 980 #include "windows.h" 981 982 /* 983 ** We need several support functions from the SQLite core. 984 */ 985 986 987 /* 988 ** We need several things from the ANSI and MSVCRT headers. 989 */ 990 991 #include <stdio.h> 992 #include <stdlib.h> 993 #include <errno.h> 994 #include <io.h> 995 #include <limits.h> 996 #include <sys/types.h> 997 #include <sys/stat.h> 998 999 /* 1000 ** We may need several defines that should have been in "sys/stat.h". 1001 */ 1002 1003 #ifndef S_ISREG 1004 #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) 1005 #endif 1006 1007 #ifndef S_ISDIR 1008 #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) 1009 #endif 1010 1011 #ifndef S_ISLNK 1012 #define S_ISLNK(mode) (0) 1013 #endif 1014 1015 /* 1016 ** We may need to provide the "mode_t" type. 1017 */ 1018 1019 #ifndef MODE_T_DEFINED 1020 #define MODE_T_DEFINED 1021 typedef unsigned short mode_t; 1022 #endif 1023 1024 /* 1025 ** We may need to provide the "ino_t" type. 1026 */ 1027 1028 #ifndef INO_T_DEFINED 1029 #define INO_T_DEFINED 1030 typedef unsigned short ino_t; 1031 #endif 1032 1033 /* 1034 ** We need to define "NAME_MAX" if it was not present in "limits.h". 1035 */ 1036 1037 #ifndef NAME_MAX 1038 # ifdef FILENAME_MAX 1039 # define NAME_MAX (FILENAME_MAX) 1040 # else 1041 # define NAME_MAX (260) 1042 # endif 1043 #endif 1044 1045 /* 1046 ** We need to define "NULL_INTPTR_T" and "BAD_INTPTR_T". 1047 */ 1048 1049 #ifndef NULL_INTPTR_T 1050 # define NULL_INTPTR_T ((intptr_t)(0)) 1051 #endif 1052 1053 #ifndef BAD_INTPTR_T 1054 # define BAD_INTPTR_T ((intptr_t)(-1)) 1055 #endif 1056 1057 /* 1058 ** We need to provide the necessary structures and related types. 1059 */ 1060 1061 #ifndef DIRENT_DEFINED 1062 #define DIRENT_DEFINED 1063 typedef struct DIRENT DIRENT; 1064 typedef DIRENT *LPDIRENT; 1065 struct DIRENT { 1066 ino_t d_ino; /* Sequence number, do not use. */ 1067 unsigned d_attributes; /* Win32 file attributes. */ 1068 char d_name[NAME_MAX + 1]; /* Name within the directory. */ 1069 }; 1070 #endif 1071 1072 #ifndef DIR_DEFINED 1073 #define DIR_DEFINED 1074 typedef struct DIR DIR; 1075 typedef DIR *LPDIR; 1076 struct DIR { 1077 intptr_t d_handle; /* Value returned by "_findfirst". */ 1078 DIRENT d_first; /* DIRENT constructed based on "_findfirst". */ 1079 DIRENT d_next; /* DIRENT constructed based on "_findnext". */ 1080 }; 1081 #endif 1082 1083 /* 1084 ** Provide a macro, for use by the implementation, to determine if a 1085 ** particular directory entry should be skipped over when searching for 1086 ** the next directory entry that should be returned by the readdir() or 1087 ** readdir_r() functions. 1088 */ 1089 1090 #ifndef is_filtered 1091 # define is_filtered(a) ((((a).attrib)&_A_HIDDEN) || (((a).attrib)&_A_SYSTEM)) 1092 #endif 1093 1094 /* 1095 ** Provide the function prototype for the POSIX compatiable getenv() 1096 ** function. This function is not thread-safe. 1097 */ 1098 1099 extern const char *windirent_getenv(const char *name); 1100 1101 /* 1102 ** Finally, we can provide the function prototypes for the opendir(), 1103 ** readdir(), readdir_r(), and closedir() POSIX functions. 1104 */ 1105 1106 extern LPDIR opendir(const char *dirname); 1107 extern LPDIRENT readdir(LPDIR dirp); 1108 extern INT readdir_r(LPDIR dirp, LPDIRENT entry, LPDIRENT *result); 1109 extern INT closedir(LPDIR dirp); 1110 1111 #endif /* defined(WIN32) && defined(_MSC_VER) */ 1112 1113 /************************* End test_windirent.h ********************/ 1114 /************************* Begin test_windirent.c ******************/ 1115 /* 1116 ** 2015 November 30 1117 ** 1118 ** The author disclaims copyright to this source code. In place of 1119 ** a legal notice, here is a blessing: 1120 ** 1121 ** May you do good and not evil. 1122 ** May you find forgiveness for yourself and forgive others. 1123 ** May you share freely, never taking more than you give. 1124 ** 1125 ************************************************************************* 1126 ** This file contains code to implement most of the opendir() family of 1127 ** POSIX functions on Win32 using the MSVCRT. 1128 */ 1129 1130 #if defined(_WIN32) && defined(_MSC_VER) 1131 /* #include "test_windirent.h" */ 1132 1133 /* 1134 ** Implementation of the POSIX getenv() function using the Win32 API. 1135 ** This function is not thread-safe. 1136 */ 1137 const char *windirent_getenv( 1138 const char *name 1139 ){ 1140 static char value[32768]; /* Maximum length, per MSDN */ 1141 DWORD dwSize = sizeof(value) / sizeof(char); /* Size in chars */ 1142 DWORD dwRet; /* Value returned by GetEnvironmentVariableA() */ 1143 1144 memset(value, 0, sizeof(value)); 1145 dwRet = GetEnvironmentVariableA(name, value, dwSize); 1146 if( dwRet==0 || dwRet>dwSize ){ 1147 /* 1148 ** The function call to GetEnvironmentVariableA() failed -OR- 1149 ** the buffer is not large enough. Either way, return NULL. 1150 */ 1151 return 0; 1152 }else{ 1153 /* 1154 ** The function call to GetEnvironmentVariableA() succeeded 1155 ** -AND- the buffer contains the entire value. 1156 */ 1157 return value; 1158 } 1159 } 1160 1161 /* 1162 ** Implementation of the POSIX opendir() function using the MSVCRT. 1163 */ 1164 LPDIR opendir( 1165 const char *dirname 1166 ){ 1167 struct _finddata_t data; 1168 LPDIR dirp = (LPDIR)sqlite3_malloc(sizeof(DIR)); 1169 SIZE_T namesize = sizeof(data.name) / sizeof(data.name[0]); 1170 1171 if( dirp==NULL ) return NULL; 1172 memset(dirp, 0, sizeof(DIR)); 1173 1174 /* TODO: Remove this if Unix-style root paths are not used. */ 1175 if( sqlite3_stricmp(dirname, "/")==0 ){ 1176 dirname = windirent_getenv("SystemDrive"); 1177 } 1178 1179 memset(&data, 0, sizeof(struct _finddata_t)); 1180 _snprintf(data.name, namesize, "%s\\*", dirname); 1181 dirp->d_handle = _findfirst(data.name, &data); 1182 1183 if( dirp->d_handle==BAD_INTPTR_T ){ 1184 closedir(dirp); 1185 return NULL; 1186 } 1187 1188 /* TODO: Remove this block to allow hidden and/or system files. */ 1189 if( is_filtered(data) ){ 1190 next: 1191 1192 memset(&data, 0, sizeof(struct _finddata_t)); 1193 if( _findnext(dirp->d_handle, &data)==-1 ){ 1194 closedir(dirp); 1195 return NULL; 1196 } 1197 1198 /* TODO: Remove this block to allow hidden and/or system files. */ 1199 if( is_filtered(data) ) goto next; 1200 } 1201 1202 dirp->d_first.d_attributes = data.attrib; 1203 strncpy(dirp->d_first.d_name, data.name, NAME_MAX); 1204 dirp->d_first.d_name[NAME_MAX] = '\0'; 1205 1206 return dirp; 1207 } 1208 1209 /* 1210 ** Implementation of the POSIX readdir() function using the MSVCRT. 1211 */ 1212 LPDIRENT readdir( 1213 LPDIR dirp 1214 ){ 1215 struct _finddata_t data; 1216 1217 if( dirp==NULL ) return NULL; 1218 1219 if( dirp->d_first.d_ino==0 ){ 1220 dirp->d_first.d_ino++; 1221 dirp->d_next.d_ino++; 1222 1223 return &dirp->d_first; 1224 } 1225 1226 next: 1227 1228 memset(&data, 0, sizeof(struct _finddata_t)); 1229 if( _findnext(dirp->d_handle, &data)==-1 ) return NULL; 1230 1231 /* TODO: Remove this block to allow hidden and/or system files. */ 1232 if( is_filtered(data) ) goto next; 1233 1234 dirp->d_next.d_ino++; 1235 dirp->d_next.d_attributes = data.attrib; 1236 strncpy(dirp->d_next.d_name, data.name, NAME_MAX); 1237 dirp->d_next.d_name[NAME_MAX] = '\0'; 1238 1239 return &dirp->d_next; 1240 } 1241 1242 /* 1243 ** Implementation of the POSIX readdir_r() function using the MSVCRT. 1244 */ 1245 INT readdir_r( 1246 LPDIR dirp, 1247 LPDIRENT entry, 1248 LPDIRENT *result 1249 ){ 1250 struct _finddata_t data; 1251 1252 if( dirp==NULL ) return EBADF; 1253 1254 if( dirp->d_first.d_ino==0 ){ 1255 dirp->d_first.d_ino++; 1256 dirp->d_next.d_ino++; 1257 1258 entry->d_ino = dirp->d_first.d_ino; 1259 entry->d_attributes = dirp->d_first.d_attributes; 1260 strncpy(entry->d_name, dirp->d_first.d_name, NAME_MAX); 1261 entry->d_name[NAME_MAX] = '\0'; 1262 1263 *result = entry; 1264 return 0; 1265 } 1266 1267 next: 1268 1269 memset(&data, 0, sizeof(struct _finddata_t)); 1270 if( _findnext(dirp->d_handle, &data)==-1 ){ 1271 *result = NULL; 1272 return ENOENT; 1273 } 1274 1275 /* TODO: Remove this block to allow hidden and/or system files. */ 1276 if( is_filtered(data) ) goto next; 1277 1278 entry->d_ino = (ino_t)-1; /* not available */ 1279 entry->d_attributes = data.attrib; 1280 strncpy(entry->d_name, data.name, NAME_MAX); 1281 entry->d_name[NAME_MAX] = '\0'; 1282 1283 *result = entry; 1284 return 0; 1285 } 1286 1287 /* 1288 ** Implementation of the POSIX closedir() function using the MSVCRT. 1289 */ 1290 INT closedir( 1291 LPDIR dirp 1292 ){ 1293 INT result = 0; 1294 1295 if( dirp==NULL ) return EINVAL; 1296 1297 if( dirp->d_handle!=NULL_INTPTR_T && dirp->d_handle!=BAD_INTPTR_T ){ 1298 result = _findclose(dirp->d_handle); 1299 } 1300 1301 sqlite3_free(dirp); 1302 return result; 1303 } 1304 1305 #endif /* defined(WIN32) && defined(_MSC_VER) */ 1306 1307 /************************* End test_windirent.c ********************/ 1308 #define dirent DIRENT 1309 #endif 1310 /************************* Begin ../ext/misc/shathree.c ******************/ 1311 /* 1312 ** 2017-03-08 1313 ** 1314 ** The author disclaims copyright to this source code. In place of 1315 ** a legal notice, here is a blessing: 1316 ** 1317 ** May you do good and not evil. 1318 ** May you find forgiveness for yourself and forgive others. 1319 ** May you share freely, never taking more than you give. 1320 ** 1321 ****************************************************************************** 1322 ** 1323 ** This SQLite extension implements functions that compute SHA3 hashes. 1324 ** Two SQL functions are implemented: 1325 ** 1326 ** sha3(X,SIZE) 1327 ** sha3_query(Y,SIZE) 1328 ** 1329 ** The sha3(X) function computes the SHA3 hash of the input X, or NULL if 1330 ** X is NULL. 1331 ** 1332 ** The sha3_query(Y) function evalutes all queries in the SQL statements of Y 1333 ** and returns a hash of their results. 1334 ** 1335 ** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm 1336 ** is used. If SIZE is included it must be one of the integers 224, 256, 1337 ** 384, or 512, to determine SHA3 hash variant that is computed. 1338 */ 1339 SQLITE_EXTENSION_INIT1 1340 #include <assert.h> 1341 #include <string.h> 1342 #include <stdarg.h> 1343 /* typedef sqlite3_uint64 u64; */ 1344 1345 /****************************************************************************** 1346 ** The Hash Engine 1347 */ 1348 /* 1349 ** Macros to determine whether the machine is big or little endian, 1350 ** and whether or not that determination is run-time or compile-time. 1351 ** 1352 ** For best performance, an attempt is made to guess at the byte-order 1353 ** using C-preprocessor macros. If that is unsuccessful, or if 1354 ** -DSHA3_BYTEORDER=0 is set, then byte-order is determined 1355 ** at run-time. 1356 */ 1357 #ifndef SHA3_BYTEORDER 1358 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ 1359 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ 1360 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ 1361 defined(__arm__) 1362 # define SHA3_BYTEORDER 1234 1363 # elif defined(sparc) || defined(__ppc__) 1364 # define SHA3_BYTEORDER 4321 1365 # else 1366 # define SHA3_BYTEORDER 0 1367 # endif 1368 #endif 1369 1370 1371 /* 1372 ** State structure for a SHA3 hash in progress 1373 */ 1374 typedef struct SHA3Context SHA3Context; 1375 struct SHA3Context { 1376 union { 1377 u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */ 1378 unsigned char x[1600]; /* ... or 1600 bytes */ 1379 } u; 1380 unsigned nRate; /* Bytes of input accepted per Keccak iteration */ 1381 unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */ 1382 unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */ 1383 }; 1384 1385 /* 1386 ** A single step of the Keccak mixing function for a 1600-bit state 1387 */ 1388 static void KeccakF1600Step(SHA3Context *p){ 1389 int i; 1390 u64 b0, b1, b2, b3, b4; 1391 u64 c0, c1, c2, c3, c4; 1392 u64 d0, d1, d2, d3, d4; 1393 static const u64 RC[] = { 1394 0x0000000000000001ULL, 0x0000000000008082ULL, 1395 0x800000000000808aULL, 0x8000000080008000ULL, 1396 0x000000000000808bULL, 0x0000000080000001ULL, 1397 0x8000000080008081ULL, 0x8000000000008009ULL, 1398 0x000000000000008aULL, 0x0000000000000088ULL, 1399 0x0000000080008009ULL, 0x000000008000000aULL, 1400 0x000000008000808bULL, 0x800000000000008bULL, 1401 0x8000000000008089ULL, 0x8000000000008003ULL, 1402 0x8000000000008002ULL, 0x8000000000000080ULL, 1403 0x000000000000800aULL, 0x800000008000000aULL, 1404 0x8000000080008081ULL, 0x8000000000008080ULL, 1405 0x0000000080000001ULL, 0x8000000080008008ULL 1406 }; 1407 # define a00 (p->u.s[0]) 1408 # define a01 (p->u.s[1]) 1409 # define a02 (p->u.s[2]) 1410 # define a03 (p->u.s[3]) 1411 # define a04 (p->u.s[4]) 1412 # define a10 (p->u.s[5]) 1413 # define a11 (p->u.s[6]) 1414 # define a12 (p->u.s[7]) 1415 # define a13 (p->u.s[8]) 1416 # define a14 (p->u.s[9]) 1417 # define a20 (p->u.s[10]) 1418 # define a21 (p->u.s[11]) 1419 # define a22 (p->u.s[12]) 1420 # define a23 (p->u.s[13]) 1421 # define a24 (p->u.s[14]) 1422 # define a30 (p->u.s[15]) 1423 # define a31 (p->u.s[16]) 1424 # define a32 (p->u.s[17]) 1425 # define a33 (p->u.s[18]) 1426 # define a34 (p->u.s[19]) 1427 # define a40 (p->u.s[20]) 1428 # define a41 (p->u.s[21]) 1429 # define a42 (p->u.s[22]) 1430 # define a43 (p->u.s[23]) 1431 # define a44 (p->u.s[24]) 1432 # define ROL64(a,x) ((a<<x)|(a>>(64-x))) 1433 1434 for(i=0; i<24; i+=4){ 1435 c0 = a00^a10^a20^a30^a40; 1436 c1 = a01^a11^a21^a31^a41; 1437 c2 = a02^a12^a22^a32^a42; 1438 c3 = a03^a13^a23^a33^a43; 1439 c4 = a04^a14^a24^a34^a44; 1440 d0 = c4^ROL64(c1, 1); 1441 d1 = c0^ROL64(c2, 1); 1442 d2 = c1^ROL64(c3, 1); 1443 d3 = c2^ROL64(c4, 1); 1444 d4 = c3^ROL64(c0, 1); 1445 1446 b0 = (a00^d0); 1447 b1 = ROL64((a11^d1), 44); 1448 b2 = ROL64((a22^d2), 43); 1449 b3 = ROL64((a33^d3), 21); 1450 b4 = ROL64((a44^d4), 14); 1451 a00 = b0 ^((~b1)& b2 ); 1452 a00 ^= RC[i]; 1453 a11 = b1 ^((~b2)& b3 ); 1454 a22 = b2 ^((~b3)& b4 ); 1455 a33 = b3 ^((~b4)& b0 ); 1456 a44 = b4 ^((~b0)& b1 ); 1457 1458 b2 = ROL64((a20^d0), 3); 1459 b3 = ROL64((a31^d1), 45); 1460 b4 = ROL64((a42^d2), 61); 1461 b0 = ROL64((a03^d3), 28); 1462 b1 = ROL64((a14^d4), 20); 1463 a20 = b0 ^((~b1)& b2 ); 1464 a31 = b1 ^((~b2)& b3 ); 1465 a42 = b2 ^((~b3)& b4 ); 1466 a03 = b3 ^((~b4)& b0 ); 1467 a14 = b4 ^((~b0)& b1 ); 1468 1469 b4 = ROL64((a40^d0), 18); 1470 b0 = ROL64((a01^d1), 1); 1471 b1 = ROL64((a12^d2), 6); 1472 b2 = ROL64((a23^d3), 25); 1473 b3 = ROL64((a34^d4), 8); 1474 a40 = b0 ^((~b1)& b2 ); 1475 a01 = b1 ^((~b2)& b3 ); 1476 a12 = b2 ^((~b3)& b4 ); 1477 a23 = b3 ^((~b4)& b0 ); 1478 a34 = b4 ^((~b0)& b1 ); 1479 1480 b1 = ROL64((a10^d0), 36); 1481 b2 = ROL64((a21^d1), 10); 1482 b3 = ROL64((a32^d2), 15); 1483 b4 = ROL64((a43^d3), 56); 1484 b0 = ROL64((a04^d4), 27); 1485 a10 = b0 ^((~b1)& b2 ); 1486 a21 = b1 ^((~b2)& b3 ); 1487 a32 = b2 ^((~b3)& b4 ); 1488 a43 = b3 ^((~b4)& b0 ); 1489 a04 = b4 ^((~b0)& b1 ); 1490 1491 b3 = ROL64((a30^d0), 41); 1492 b4 = ROL64((a41^d1), 2); 1493 b0 = ROL64((a02^d2), 62); 1494 b1 = ROL64((a13^d3), 55); 1495 b2 = ROL64((a24^d4), 39); 1496 a30 = b0 ^((~b1)& b2 ); 1497 a41 = b1 ^((~b2)& b3 ); 1498 a02 = b2 ^((~b3)& b4 ); 1499 a13 = b3 ^((~b4)& b0 ); 1500 a24 = b4 ^((~b0)& b1 ); 1501 1502 c0 = a00^a20^a40^a10^a30; 1503 c1 = a11^a31^a01^a21^a41; 1504 c2 = a22^a42^a12^a32^a02; 1505 c3 = a33^a03^a23^a43^a13; 1506 c4 = a44^a14^a34^a04^a24; 1507 d0 = c4^ROL64(c1, 1); 1508 d1 = c0^ROL64(c2, 1); 1509 d2 = c1^ROL64(c3, 1); 1510 d3 = c2^ROL64(c4, 1); 1511 d4 = c3^ROL64(c0, 1); 1512 1513 b0 = (a00^d0); 1514 b1 = ROL64((a31^d1), 44); 1515 b2 = ROL64((a12^d2), 43); 1516 b3 = ROL64((a43^d3), 21); 1517 b4 = ROL64((a24^d4), 14); 1518 a00 = b0 ^((~b1)& b2 ); 1519 a00 ^= RC[i+1]; 1520 a31 = b1 ^((~b2)& b3 ); 1521 a12 = b2 ^((~b3)& b4 ); 1522 a43 = b3 ^((~b4)& b0 ); 1523 a24 = b4 ^((~b0)& b1 ); 1524 1525 b2 = ROL64((a40^d0), 3); 1526 b3 = ROL64((a21^d1), 45); 1527 b4 = ROL64((a02^d2), 61); 1528 b0 = ROL64((a33^d3), 28); 1529 b1 = ROL64((a14^d4), 20); 1530 a40 = b0 ^((~b1)& b2 ); 1531 a21 = b1 ^((~b2)& b3 ); 1532 a02 = b2 ^((~b3)& b4 ); 1533 a33 = b3 ^((~b4)& b0 ); 1534 a14 = b4 ^((~b0)& b1 ); 1535 1536 b4 = ROL64((a30^d0), 18); 1537 b0 = ROL64((a11^d1), 1); 1538 b1 = ROL64((a42^d2), 6); 1539 b2 = ROL64((a23^d3), 25); 1540 b3 = ROL64((a04^d4), 8); 1541 a30 = b0 ^((~b1)& b2 ); 1542 a11 = b1 ^((~b2)& b3 ); 1543 a42 = b2 ^((~b3)& b4 ); 1544 a23 = b3 ^((~b4)& b0 ); 1545 a04 = b4 ^((~b0)& b1 ); 1546 1547 b1 = ROL64((a20^d0), 36); 1548 b2 = ROL64((a01^d1), 10); 1549 b3 = ROL64((a32^d2), 15); 1550 b4 = ROL64((a13^d3), 56); 1551 b0 = ROL64((a44^d4), 27); 1552 a20 = b0 ^((~b1)& b2 ); 1553 a01 = b1 ^((~b2)& b3 ); 1554 a32 = b2 ^((~b3)& b4 ); 1555 a13 = b3 ^((~b4)& b0 ); 1556 a44 = b4 ^((~b0)& b1 ); 1557 1558 b3 = ROL64((a10^d0), 41); 1559 b4 = ROL64((a41^d1), 2); 1560 b0 = ROL64((a22^d2), 62); 1561 b1 = ROL64((a03^d3), 55); 1562 b2 = ROL64((a34^d4), 39); 1563 a10 = b0 ^((~b1)& b2 ); 1564 a41 = b1 ^((~b2)& b3 ); 1565 a22 = b2 ^((~b3)& b4 ); 1566 a03 = b3 ^((~b4)& b0 ); 1567 a34 = b4 ^((~b0)& b1 ); 1568 1569 c0 = a00^a40^a30^a20^a10; 1570 c1 = a31^a21^a11^a01^a41; 1571 c2 = a12^a02^a42^a32^a22; 1572 c3 = a43^a33^a23^a13^a03; 1573 c4 = a24^a14^a04^a44^a34; 1574 d0 = c4^ROL64(c1, 1); 1575 d1 = c0^ROL64(c2, 1); 1576 d2 = c1^ROL64(c3, 1); 1577 d3 = c2^ROL64(c4, 1); 1578 d4 = c3^ROL64(c0, 1); 1579 1580 b0 = (a00^d0); 1581 b1 = ROL64((a21^d1), 44); 1582 b2 = ROL64((a42^d2), 43); 1583 b3 = ROL64((a13^d3), 21); 1584 b4 = ROL64((a34^d4), 14); 1585 a00 = b0 ^((~b1)& b2 ); 1586 a00 ^= RC[i+2]; 1587 a21 = b1 ^((~b2)& b3 ); 1588 a42 = b2 ^((~b3)& b4 ); 1589 a13 = b3 ^((~b4)& b0 ); 1590 a34 = b4 ^((~b0)& b1 ); 1591 1592 b2 = ROL64((a30^d0), 3); 1593 b3 = ROL64((a01^d1), 45); 1594 b4 = ROL64((a22^d2), 61); 1595 b0 = ROL64((a43^d3), 28); 1596 b1 = ROL64((a14^d4), 20); 1597 a30 = b0 ^((~b1)& b2 ); 1598 a01 = b1 ^((~b2)& b3 ); 1599 a22 = b2 ^((~b3)& b4 ); 1600 a43 = b3 ^((~b4)& b0 ); 1601 a14 = b4 ^((~b0)& b1 ); 1602 1603 b4 = ROL64((a10^d0), 18); 1604 b0 = ROL64((a31^d1), 1); 1605 b1 = ROL64((a02^d2), 6); 1606 b2 = ROL64((a23^d3), 25); 1607 b3 = ROL64((a44^d4), 8); 1608 a10 = b0 ^((~b1)& b2 ); 1609 a31 = b1 ^((~b2)& b3 ); 1610 a02 = b2 ^((~b3)& b4 ); 1611 a23 = b3 ^((~b4)& b0 ); 1612 a44 = b4 ^((~b0)& b1 ); 1613 1614 b1 = ROL64((a40^d0), 36); 1615 b2 = ROL64((a11^d1), 10); 1616 b3 = ROL64((a32^d2), 15); 1617 b4 = ROL64((a03^d3), 56); 1618 b0 = ROL64((a24^d4), 27); 1619 a40 = b0 ^((~b1)& b2 ); 1620 a11 = b1 ^((~b2)& b3 ); 1621 a32 = b2 ^((~b3)& b4 ); 1622 a03 = b3 ^((~b4)& b0 ); 1623 a24 = b4 ^((~b0)& b1 ); 1624 1625 b3 = ROL64((a20^d0), 41); 1626 b4 = ROL64((a41^d1), 2); 1627 b0 = ROL64((a12^d2), 62); 1628 b1 = ROL64((a33^d3), 55); 1629 b2 = ROL64((a04^d4), 39); 1630 a20 = b0 ^((~b1)& b2 ); 1631 a41 = b1 ^((~b2)& b3 ); 1632 a12 = b2 ^((~b3)& b4 ); 1633 a33 = b3 ^((~b4)& b0 ); 1634 a04 = b4 ^((~b0)& b1 ); 1635 1636 c0 = a00^a30^a10^a40^a20; 1637 c1 = a21^a01^a31^a11^a41; 1638 c2 = a42^a22^a02^a32^a12; 1639 c3 = a13^a43^a23^a03^a33; 1640 c4 = a34^a14^a44^a24^a04; 1641 d0 = c4^ROL64(c1, 1); 1642 d1 = c0^ROL64(c2, 1); 1643 d2 = c1^ROL64(c3, 1); 1644 d3 = c2^ROL64(c4, 1); 1645 d4 = c3^ROL64(c0, 1); 1646 1647 b0 = (a00^d0); 1648 b1 = ROL64((a01^d1), 44); 1649 b2 = ROL64((a02^d2), 43); 1650 b3 = ROL64((a03^d3), 21); 1651 b4 = ROL64((a04^d4), 14); 1652 a00 = b0 ^((~b1)& b2 ); 1653 a00 ^= RC[i+3]; 1654 a01 = b1 ^((~b2)& b3 ); 1655 a02 = b2 ^((~b3)& b4 ); 1656 a03 = b3 ^((~b4)& b0 ); 1657 a04 = b4 ^((~b0)& b1 ); 1658 1659 b2 = ROL64((a10^d0), 3); 1660 b3 = ROL64((a11^d1), 45); 1661 b4 = ROL64((a12^d2), 61); 1662 b0 = ROL64((a13^d3), 28); 1663 b1 = ROL64((a14^d4), 20); 1664 a10 = b0 ^((~b1)& b2 ); 1665 a11 = b1 ^((~b2)& b3 ); 1666 a12 = b2 ^((~b3)& b4 ); 1667 a13 = b3 ^((~b4)& b0 ); 1668 a14 = b4 ^((~b0)& b1 ); 1669 1670 b4 = ROL64((a20^d0), 18); 1671 b0 = ROL64((a21^d1), 1); 1672 b1 = ROL64((a22^d2), 6); 1673 b2 = ROL64((a23^d3), 25); 1674 b3 = ROL64((a24^d4), 8); 1675 a20 = b0 ^((~b1)& b2 ); 1676 a21 = b1 ^((~b2)& b3 ); 1677 a22 = b2 ^((~b3)& b4 ); 1678 a23 = b3 ^((~b4)& b0 ); 1679 a24 = b4 ^((~b0)& b1 ); 1680 1681 b1 = ROL64((a30^d0), 36); 1682 b2 = ROL64((a31^d1), 10); 1683 b3 = ROL64((a32^d2), 15); 1684 b4 = ROL64((a33^d3), 56); 1685 b0 = ROL64((a34^d4), 27); 1686 a30 = b0 ^((~b1)& b2 ); 1687 a31 = b1 ^((~b2)& b3 ); 1688 a32 = b2 ^((~b3)& b4 ); 1689 a33 = b3 ^((~b4)& b0 ); 1690 a34 = b4 ^((~b0)& b1 ); 1691 1692 b3 = ROL64((a40^d0), 41); 1693 b4 = ROL64((a41^d1), 2); 1694 b0 = ROL64((a42^d2), 62); 1695 b1 = ROL64((a43^d3), 55); 1696 b2 = ROL64((a44^d4), 39); 1697 a40 = b0 ^((~b1)& b2 ); 1698 a41 = b1 ^((~b2)& b3 ); 1699 a42 = b2 ^((~b3)& b4 ); 1700 a43 = b3 ^((~b4)& b0 ); 1701 a44 = b4 ^((~b0)& b1 ); 1702 } 1703 } 1704 1705 /* 1706 ** Initialize a new hash. iSize determines the size of the hash 1707 ** in bits and should be one of 224, 256, 384, or 512. Or iSize 1708 ** can be zero to use the default hash size of 256 bits. 1709 */ 1710 static void SHA3Init(SHA3Context *p, int iSize){ 1711 memset(p, 0, sizeof(*p)); 1712 if( iSize>=128 && iSize<=512 ){ 1713 p->nRate = (1600 - ((iSize + 31)&~31)*2)/8; 1714 }else{ 1715 p->nRate = (1600 - 2*256)/8; 1716 } 1717 #if SHA3_BYTEORDER==1234 1718 /* Known to be little-endian at compile-time. No-op */ 1719 #elif SHA3_BYTEORDER==4321 1720 p->ixMask = 7; /* Big-endian */ 1721 #else 1722 { 1723 static unsigned int one = 1; 1724 if( 1==*(unsigned char*)&one ){ 1725 /* Little endian. No byte swapping. */ 1726 p->ixMask = 0; 1727 }else{ 1728 /* Big endian. Byte swap. */ 1729 p->ixMask = 7; 1730 } 1731 } 1732 #endif 1733 } 1734 1735 /* 1736 ** Make consecutive calls to the SHA3Update function to add new content 1737 ** to the hash 1738 */ 1739 static void SHA3Update( 1740 SHA3Context *p, 1741 const unsigned char *aData, 1742 unsigned int nData 1743 ){ 1744 unsigned int i = 0; 1745 #if SHA3_BYTEORDER==1234 1746 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){ 1747 for(; i+7<nData; i+=8){ 1748 p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i]; 1749 p->nLoaded += 8; 1750 if( p->nLoaded>=p->nRate ){ 1751 KeccakF1600Step(p); 1752 p->nLoaded = 0; 1753 } 1754 } 1755 } 1756 #endif 1757 for(; i<nData; i++){ 1758 #if SHA3_BYTEORDER==1234 1759 p->u.x[p->nLoaded] ^= aData[i]; 1760 #elif SHA3_BYTEORDER==4321 1761 p->u.x[p->nLoaded^0x07] ^= aData[i]; 1762 #else 1763 p->u.x[p->nLoaded^p->ixMask] ^= aData[i]; 1764 #endif 1765 p->nLoaded++; 1766 if( p->nLoaded==p->nRate ){ 1767 KeccakF1600Step(p); 1768 p->nLoaded = 0; 1769 } 1770 } 1771 } 1772 1773 /* 1774 ** After all content has been added, invoke SHA3Final() to compute 1775 ** the final hash. The function returns a pointer to the binary 1776 ** hash value. 1777 */ 1778 static unsigned char *SHA3Final(SHA3Context *p){ 1779 unsigned int i; 1780 if( p->nLoaded==p->nRate-1 ){ 1781 const unsigned char c1 = 0x86; 1782 SHA3Update(p, &c1, 1); 1783 }else{ 1784 const unsigned char c2 = 0x06; 1785 const unsigned char c3 = 0x80; 1786 SHA3Update(p, &c2, 1); 1787 p->nLoaded = p->nRate - 1; 1788 SHA3Update(p, &c3, 1); 1789 } 1790 for(i=0; i<p->nRate; i++){ 1791 p->u.x[i+p->nRate] = p->u.x[i^p->ixMask]; 1792 } 1793 return &p->u.x[p->nRate]; 1794 } 1795 /* End of the hashing logic 1796 *****************************************************************************/ 1797 1798 /* 1799 ** Implementation of the sha3(X,SIZE) function. 1800 ** 1801 ** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default 1802 ** size is 256. If X is a BLOB, it is hashed as is. 1803 ** For all other non-NULL types of input, X is converted into a UTF-8 string 1804 ** and the string is hashed without the trailing 0x00 terminator. The hash 1805 ** of a NULL value is NULL. 1806 */ 1807 static void sha3Func( 1808 sqlite3_context *context, 1809 int argc, 1810 sqlite3_value **argv 1811 ){ 1812 SHA3Context cx; 1813 int eType = sqlite3_value_type(argv[0]); 1814 int nByte = sqlite3_value_bytes(argv[0]); 1815 int iSize; 1816 if( argc==1 ){ 1817 iSize = 256; 1818 }else{ 1819 iSize = sqlite3_value_int(argv[1]); 1820 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ 1821 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " 1822 "384 512", -1); 1823 return; 1824 } 1825 } 1826 if( eType==SQLITE_NULL ) return; 1827 SHA3Init(&cx, iSize); 1828 if( eType==SQLITE_BLOB ){ 1829 SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte); 1830 }else{ 1831 SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte); 1832 } 1833 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); 1834 } 1835 1836 /* Compute a string using sqlite3_vsnprintf() with a maximum length 1837 ** of 50 bytes and add it to the hash. 1838 */ 1839 static void hash_step_vformat( 1840 SHA3Context *p, /* Add content to this context */ 1841 const char *zFormat, 1842 ... 1843 ){ 1844 va_list ap; 1845 int n; 1846 char zBuf[50]; 1847 va_start(ap, zFormat); 1848 sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap); 1849 va_end(ap); 1850 n = (int)strlen(zBuf); 1851 SHA3Update(p, (unsigned char*)zBuf, n); 1852 } 1853 1854 /* 1855 ** Implementation of the sha3_query(SQL,SIZE) function. 1856 ** 1857 ** This function compiles and runs the SQL statement(s) given in the 1858 ** argument. The results are hashed using a SIZE-bit SHA3. The default 1859 ** size is 256. 1860 ** 1861 ** The format of the byte stream that is hashed is summarized as follows: 1862 ** 1863 ** S<n>:<sql> 1864 ** R 1865 ** N 1866 ** I<int> 1867 ** F<ieee-float> 1868 ** B<size>:<bytes> 1869 ** T<size>:<text> 1870 ** 1871 ** <sql> is the original SQL text for each statement run and <n> is 1872 ** the size of that text. The SQL text is UTF-8. A single R character 1873 ** occurs before the start of each row. N means a NULL value. 1874 ** I mean an 8-byte little-endian integer <int>. F is a floating point 1875 ** number with an 8-byte little-endian IEEE floating point value <ieee-float>. 1876 ** B means blobs of <size> bytes. T means text rendered as <size> 1877 ** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII 1878 ** text integers. 1879 ** 1880 ** For each SQL statement in the X input, there is one S segment. Each 1881 ** S segment is followed by zero or more R segments, one for each row in the 1882 ** result set. After each R, there are one or more N, I, F, B, or T segments, 1883 ** one for each column in the result set. Segments are concatentated directly 1884 ** with no delimiters of any kind. 1885 */ 1886 static void sha3QueryFunc( 1887 sqlite3_context *context, 1888 int argc, 1889 sqlite3_value **argv 1890 ){ 1891 sqlite3 *db = sqlite3_context_db_handle(context); 1892 const char *zSql = (const char*)sqlite3_value_text(argv[0]); 1893 sqlite3_stmt *pStmt = 0; 1894 int nCol; /* Number of columns in the result set */ 1895 int i; /* Loop counter */ 1896 int rc; 1897 int n; 1898 const char *z; 1899 SHA3Context cx; 1900 int iSize; 1901 1902 if( argc==1 ){ 1903 iSize = 256; 1904 }else{ 1905 iSize = sqlite3_value_int(argv[1]); 1906 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ 1907 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " 1908 "384 512", -1); 1909 return; 1910 } 1911 } 1912 if( zSql==0 ) return; 1913 SHA3Init(&cx, iSize); 1914 while( zSql[0] ){ 1915 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql); 1916 if( rc ){ 1917 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s", 1918 zSql, sqlite3_errmsg(db)); 1919 sqlite3_finalize(pStmt); 1920 sqlite3_result_error(context, zMsg, -1); 1921 sqlite3_free(zMsg); 1922 return; 1923 } 1924 if( !sqlite3_stmt_readonly(pStmt) ){ 1925 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt)); 1926 sqlite3_finalize(pStmt); 1927 sqlite3_result_error(context, zMsg, -1); 1928 sqlite3_free(zMsg); 1929 return; 1930 } 1931 nCol = sqlite3_column_count(pStmt); 1932 z = sqlite3_sql(pStmt); 1933 n = (int)strlen(z); 1934 hash_step_vformat(&cx,"S%d:",n); 1935 SHA3Update(&cx,(unsigned char*)z,n); 1936 1937 /* Compute a hash over the result of the query */ 1938 while( SQLITE_ROW==sqlite3_step(pStmt) ){ 1939 SHA3Update(&cx,(const unsigned char*)"R",1); 1940 for(i=0; i<nCol; i++){ 1941 switch( sqlite3_column_type(pStmt,i) ){ 1942 case SQLITE_NULL: { 1943 SHA3Update(&cx, (const unsigned char*)"N",1); 1944 break; 1945 } 1946 case SQLITE_INTEGER: { 1947 sqlite3_uint64 u; 1948 int j; 1949 unsigned char x[9]; 1950 sqlite3_int64 v = sqlite3_column_int64(pStmt,i); 1951 memcpy(&u, &v, 8); 1952 for(j=8; j>=1; j--){ 1953 x[j] = u & 0xff; 1954 u >>= 8; 1955 } 1956 x[0] = 'I'; 1957 SHA3Update(&cx, x, 9); 1958 break; 1959 } 1960 case SQLITE_FLOAT: { 1961 sqlite3_uint64 u; 1962 int j; 1963 unsigned char x[9]; 1964 double r = sqlite3_column_double(pStmt,i); 1965 memcpy(&u, &r, 8); 1966 for(j=8; j>=1; j--){ 1967 x[j] = u & 0xff; 1968 u >>= 8; 1969 } 1970 x[0] = 'F'; 1971 SHA3Update(&cx,x,9); 1972 break; 1973 } 1974 case SQLITE_TEXT: { 1975 int n2 = sqlite3_column_bytes(pStmt, i); 1976 const unsigned char *z2 = sqlite3_column_text(pStmt, i); 1977 hash_step_vformat(&cx,"T%d:",n2); 1978 SHA3Update(&cx, z2, n2); 1979 break; 1980 } 1981 case SQLITE_BLOB: { 1982 int n2 = sqlite3_column_bytes(pStmt, i); 1983 const unsigned char *z2 = sqlite3_column_blob(pStmt, i); 1984 hash_step_vformat(&cx,"B%d:",n2); 1985 SHA3Update(&cx, z2, n2); 1986 break; 1987 } 1988 } 1989 } 1990 } 1991 sqlite3_finalize(pStmt); 1992 } 1993 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); 1994 } 1995 1996 1997 #ifdef _WIN32 1998 1999 #endif 2000 int sqlite3_shathree_init( 2001 sqlite3 *db, 2002 char **pzErrMsg, 2003 const sqlite3_api_routines *pApi 2004 ){ 2005 int rc = SQLITE_OK; 2006 SQLITE_EXTENSION_INIT2(pApi); 2007 (void)pzErrMsg; /* Unused parameter */ 2008 rc = sqlite3_create_function(db, "sha3", 1, SQLITE_UTF8, 0, 2009 sha3Func, 0, 0); 2010 if( rc==SQLITE_OK ){ 2011 rc = sqlite3_create_function(db, "sha3", 2, SQLITE_UTF8, 0, 2012 sha3Func, 0, 0); 2013 } 2014 if( rc==SQLITE_OK ){ 2015 rc = sqlite3_create_function(db, "sha3_query", 1, SQLITE_UTF8, 0, 2016 sha3QueryFunc, 0, 0); 2017 } 2018 if( rc==SQLITE_OK ){ 2019 rc = sqlite3_create_function(db, "sha3_query", 2, SQLITE_UTF8, 0, 2020 sha3QueryFunc, 0, 0); 2021 } 2022 return rc; 2023 } 2024 2025 /************************* End ../ext/misc/shathree.c ********************/ 2026 /************************* Begin ../ext/misc/fileio.c ******************/ 2027 /* 2028 ** 2014-06-13 2029 ** 2030 ** The author disclaims copyright to this source code. In place of 2031 ** a legal notice, here is a blessing: 2032 ** 2033 ** May you do good and not evil. 2034 ** May you find forgiveness for yourself and forgive others. 2035 ** May you share freely, never taking more than you give. 2036 ** 2037 ****************************************************************************** 2038 ** 2039 ** This SQLite extension implements SQL functions readfile() and 2040 ** writefile(), and eponymous virtual type "fsdir". 2041 ** 2042 ** WRITEFILE(FILE, DATA [, MODE [, MTIME]]): 2043 ** 2044 ** If neither of the optional arguments is present, then this UDF 2045 ** function writes blob DATA to file FILE. If successful, the number 2046 ** of bytes written is returned. If an error occurs, NULL is returned. 2047 ** 2048 ** If the first option argument - MODE - is present, then it must 2049 ** be passed an integer value that corresponds to a POSIX mode 2050 ** value (file type + permissions, as returned in the stat.st_mode 2051 ** field by the stat() system call). Three types of files may 2052 ** be written/created: 2053 ** 2054 ** regular files: (mode & 0170000)==0100000 2055 ** symbolic links: (mode & 0170000)==0120000 2056 ** directories: (mode & 0170000)==0040000 2057 ** 2058 ** For a directory, the DATA is ignored. For a symbolic link, it is 2059 ** interpreted as text and used as the target of the link. For a 2060 ** regular file, it is interpreted as a blob and written into the 2061 ** named file. Regardless of the type of file, its permissions are 2062 ** set to (mode & 0777) before returning. 2063 ** 2064 ** If the optional MTIME argument is present, then it is interpreted 2065 ** as an integer - the number of seconds since the unix epoch. The 2066 ** modification-time of the target file is set to this value before 2067 ** returning. 2068 ** 2069 ** If three or more arguments are passed to this function and an 2070 ** error is encountered, an exception is raised. 2071 ** 2072 ** READFILE(FILE): 2073 ** 2074 ** Read and return the contents of file FILE (type blob) from disk. 2075 ** 2076 ** FSDIR: 2077 ** 2078 ** Used as follows: 2079 ** 2080 ** SELECT * FROM fsdir($path [, $dir]); 2081 ** 2082 ** Parameter $path is an absolute or relative pathname. If the file that it 2083 ** refers to does not exist, it is an error. If the path refers to a regular 2084 ** file or symbolic link, it returns a single row. Or, if the path refers 2085 ** to a directory, it returns one row for the directory, and one row for each 2086 ** file within the hierarchy rooted at $path. 2087 ** 2088 ** Each row has the following columns: 2089 ** 2090 ** name: Path to file or directory (text value). 2091 ** mode: Value of stat.st_mode for directory entry (an integer). 2092 ** mtime: Value of stat.st_mtime for directory entry (an integer). 2093 ** data: For a regular file, a blob containing the file data. For a 2094 ** symlink, a text value containing the text of the link. For a 2095 ** directory, NULL. 2096 ** 2097 ** If a non-NULL value is specified for the optional $dir parameter and 2098 ** $path is a relative path, then $path is interpreted relative to $dir. 2099 ** And the paths returned in the "name" column of the table are also 2100 ** relative to directory $dir. 2101 */ 2102 SQLITE_EXTENSION_INIT1 2103 #include <stdio.h> 2104 #include <string.h> 2105 #include <assert.h> 2106 2107 #include <sys/types.h> 2108 #include <sys/stat.h> 2109 #include <fcntl.h> 2110 #if !defined(_WIN32) && !defined(WIN32) 2111 # include <unistd.h> 2112 # include <dirent.h> 2113 # include <utime.h> 2114 # include <sys/time.h> 2115 #else 2116 # include "windows.h" 2117 # include <io.h> 2118 # include <direct.h> 2119 /* # include "test_windirent.h" */ 2120 # define dirent DIRENT 2121 # ifndef chmod 2122 # define chmod _chmod 2123 # endif 2124 # ifndef stat 2125 # define stat _stat 2126 # endif 2127 # define mkdir(path,mode) _mkdir(path) 2128 # define lstat(path,buf) stat(path,buf) 2129 #endif 2130 #include <time.h> 2131 #include <errno.h> 2132 2133 2134 /* 2135 ** Structure of the fsdir() table-valued function 2136 */ 2137 /* 0 1 2 3 4 5 */ 2138 #define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)" 2139 #define FSDIR_COLUMN_NAME 0 /* Name of the file */ 2140 #define FSDIR_COLUMN_MODE 1 /* Access mode */ 2141 #define FSDIR_COLUMN_MTIME 2 /* Last modification time */ 2142 #define FSDIR_COLUMN_DATA 3 /* File content */ 2143 #define FSDIR_COLUMN_PATH 4 /* Path to top of search */ 2144 #define FSDIR_COLUMN_DIR 5 /* Path is relative to this directory */ 2145 2146 2147 /* 2148 ** Set the result stored by context ctx to a blob containing the 2149 ** contents of file zName. Or, leave the result unchanged (NULL) 2150 ** if the file does not exist or is unreadable. 2151 ** 2152 ** If the file exceeds the SQLite blob size limit, through an 2153 ** SQLITE_TOOBIG error. 2154 ** 2155 ** Throw an SQLITE_IOERR if there are difficulties pulling the file 2156 ** off of disk. 2157 */ 2158 static void readFileContents(sqlite3_context *ctx, const char *zName){ 2159 FILE *in; 2160 sqlite3_int64 nIn; 2161 void *pBuf; 2162 sqlite3 *db; 2163 int mxBlob; 2164 2165 in = fopen(zName, "rb"); 2166 if( in==0 ){ 2167 /* File does not exist or is unreadable. Leave the result set to NULL. */ 2168 return; 2169 } 2170 fseek(in, 0, SEEK_END); 2171 nIn = ftell(in); 2172 rewind(in); 2173 db = sqlite3_context_db_handle(ctx); 2174 mxBlob = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1); 2175 if( nIn>mxBlob ){ 2176 sqlite3_result_error_code(ctx, SQLITE_TOOBIG); 2177 fclose(in); 2178 return; 2179 } 2180 pBuf = sqlite3_malloc64( nIn ); 2181 if( pBuf==0 ){ 2182 sqlite3_result_error_nomem(ctx); 2183 fclose(in); 2184 return; 2185 } 2186 if( 1==fread(pBuf, nIn, 1, in) ){ 2187 sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free); 2188 }else{ 2189 sqlite3_result_error_code(ctx, SQLITE_IOERR); 2190 sqlite3_free(pBuf); 2191 } 2192 fclose(in); 2193 } 2194 2195 /* 2196 ** Implementation of the "readfile(X)" SQL function. The entire content 2197 ** of the file named X is read and returned as a BLOB. NULL is returned 2198 ** if the file does not exist or is unreadable. 2199 */ 2200 static void readfileFunc( 2201 sqlite3_context *context, 2202 int argc, 2203 sqlite3_value **argv 2204 ){ 2205 const char *zName; 2206 (void)(argc); /* Unused parameter */ 2207 zName = (const char*)sqlite3_value_text(argv[0]); 2208 if( zName==0 ) return; 2209 readFileContents(context, zName); 2210 } 2211 2212 /* 2213 ** Set the error message contained in context ctx to the results of 2214 ** vprintf(zFmt, ...). 2215 */ 2216 static void ctxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){ 2217 char *zMsg = 0; 2218 va_list ap; 2219 va_start(ap, zFmt); 2220 zMsg = sqlite3_vmprintf(zFmt, ap); 2221 sqlite3_result_error(ctx, zMsg, -1); 2222 sqlite3_free(zMsg); 2223 va_end(ap); 2224 } 2225 2226 #if defined(_WIN32) 2227 /* 2228 ** This function is designed to convert a Win32 FILETIME structure into the 2229 ** number of seconds since the Unix Epoch (1970-01-01 00:00:00 UTC). 2230 */ 2231 static sqlite3_uint64 fileTimeToUnixTime( 2232 LPFILETIME pFileTime 2233 ){ 2234 SYSTEMTIME epochSystemTime; 2235 ULARGE_INTEGER epochIntervals; 2236 FILETIME epochFileTime; 2237 ULARGE_INTEGER fileIntervals; 2238 2239 memset(&epochSystemTime, 0, sizeof(SYSTEMTIME)); 2240 epochSystemTime.wYear = 1970; 2241 epochSystemTime.wMonth = 1; 2242 epochSystemTime.wDay = 1; 2243 SystemTimeToFileTime(&epochSystemTime, &epochFileTime); 2244 epochIntervals.LowPart = epochFileTime.dwLowDateTime; 2245 epochIntervals.HighPart = epochFileTime.dwHighDateTime; 2246 2247 fileIntervals.LowPart = pFileTime->dwLowDateTime; 2248 fileIntervals.HighPart = pFileTime->dwHighDateTime; 2249 2250 return (fileIntervals.QuadPart - epochIntervals.QuadPart) / 10000000; 2251 } 2252 2253 /* 2254 ** This function attempts to normalize the time values found in the stat() 2255 ** buffer to UTC. This is necessary on Win32, where the runtime library 2256 ** appears to return these values as local times. 2257 */ 2258 static void statTimesToUtc( 2259 const char *zPath, 2260 struct stat *pStatBuf 2261 ){ 2262 HANDLE hFindFile; 2263 WIN32_FIND_DATAW fd; 2264 LPWSTR zUnicodeName; 2265 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); 2266 zUnicodeName = sqlite3_win32_utf8_to_unicode(zPath); 2267 if( zUnicodeName ){ 2268 memset(&fd, 0, sizeof(WIN32_FIND_DATAW)); 2269 hFindFile = FindFirstFileW(zUnicodeName, &fd); 2270 if( hFindFile!=NULL ){ 2271 pStatBuf->st_ctime = (time_t)fileTimeToUnixTime(&fd.ftCreationTime); 2272 pStatBuf->st_atime = (time_t)fileTimeToUnixTime(&fd.ftLastAccessTime); 2273 pStatBuf->st_mtime = (time_t)fileTimeToUnixTime(&fd.ftLastWriteTime); 2274 FindClose(hFindFile); 2275 } 2276 sqlite3_free(zUnicodeName); 2277 } 2278 } 2279 #endif 2280 2281 /* 2282 ** This function is used in place of stat(). On Windows, special handling 2283 ** is required in order for the included time to be returned as UTC. On all 2284 ** other systems, this function simply calls stat(). 2285 */ 2286 static int fileStat( 2287 const char *zPath, 2288 struct stat *pStatBuf 2289 ){ 2290 #if defined(_WIN32) 2291 int rc = stat(zPath, pStatBuf); 2292 if( rc==0 ) statTimesToUtc(zPath, pStatBuf); 2293 return rc; 2294 #else 2295 return stat(zPath, pStatBuf); 2296 #endif 2297 } 2298 2299 /* 2300 ** This function is used in place of lstat(). On Windows, special handling 2301 ** is required in order for the included time to be returned as UTC. On all 2302 ** other systems, this function simply calls lstat(). 2303 */ 2304 static int fileLinkStat( 2305 const char *zPath, 2306 struct stat *pStatBuf 2307 ){ 2308 #if defined(_WIN32) 2309 int rc = lstat(zPath, pStatBuf); 2310 if( rc==0 ) statTimesToUtc(zPath, pStatBuf); 2311 return rc; 2312 #else 2313 return lstat(zPath, pStatBuf); 2314 #endif 2315 } 2316 2317 /* 2318 ** Argument zFile is the name of a file that will be created and/or written 2319 ** by SQL function writefile(). This function ensures that the directory 2320 ** zFile will be written to exists, creating it if required. The permissions 2321 ** for any path components created by this function are set to (mode&0777). 2322 ** 2323 ** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise, 2324 ** SQLITE_OK is returned if the directory is successfully created, or 2325 ** SQLITE_ERROR otherwise. 2326 */ 2327 static int makeDirectory( 2328 const char *zFile, 2329 mode_t mode 2330 ){ 2331 char *zCopy = sqlite3_mprintf("%s", zFile); 2332 int rc = SQLITE_OK; 2333 2334 if( zCopy==0 ){ 2335 rc = SQLITE_NOMEM; 2336 }else{ 2337 int nCopy = (int)strlen(zCopy); 2338 int i = 1; 2339 2340 while( rc==SQLITE_OK ){ 2341 struct stat sStat; 2342 int rc2; 2343 2344 for(; zCopy[i]!='/' && i<nCopy; i++); 2345 if( i==nCopy ) break; 2346 zCopy[i] = '\0'; 2347 2348 rc2 = fileStat(zCopy, &sStat); 2349 if( rc2!=0 ){ 2350 if( mkdir(zCopy, mode & 0777) ) rc = SQLITE_ERROR; 2351 }else{ 2352 if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR; 2353 } 2354 zCopy[i] = '/'; 2355 i++; 2356 } 2357 2358 sqlite3_free(zCopy); 2359 } 2360 2361 return rc; 2362 } 2363 2364 /* 2365 ** This function does the work for the writefile() UDF. Refer to 2366 ** header comments at the top of this file for details. 2367 */ 2368 static int writeFile( 2369 sqlite3_context *pCtx, /* Context to return bytes written in */ 2370 const char *zFile, /* File to write */ 2371 sqlite3_value *pData, /* Data to write */ 2372 mode_t mode, /* MODE parameter passed to writefile() */ 2373 sqlite3_int64 mtime /* MTIME parameter (or -1 to not set time) */ 2374 ){ 2375 #if !defined(_WIN32) && !defined(WIN32) 2376 if( S_ISLNK(mode) ){ 2377 const char *zTo = (const char*)sqlite3_value_text(pData); 2378 if( symlink(zTo, zFile)<0 ) return 1; 2379 }else 2380 #endif 2381 { 2382 if( S_ISDIR(mode) ){ 2383 if( mkdir(zFile, mode) ){ 2384 /* The mkdir() call to create the directory failed. This might not 2385 ** be an error though - if there is already a directory at the same 2386 ** path and either the permissions already match or can be changed 2387 ** to do so using chmod(), it is not an error. */ 2388 struct stat sStat; 2389 if( errno!=EEXIST 2390 || 0!=fileStat(zFile, &sStat) 2391 || !S_ISDIR(sStat.st_mode) 2392 || ((sStat.st_mode&0777)!=(mode&0777) && 0!=chmod(zFile, mode&0777)) 2393 ){ 2394 return 1; 2395 } 2396 } 2397 }else{ 2398 sqlite3_int64 nWrite = 0; 2399 const char *z; 2400 int rc = 0; 2401 FILE *out = fopen(zFile, "wb"); 2402 if( out==0 ) return 1; 2403 z = (const char*)sqlite3_value_blob(pData); 2404 if( z ){ 2405 sqlite3_int64 n = fwrite(z, 1, sqlite3_value_bytes(pData), out); 2406 nWrite = sqlite3_value_bytes(pData); 2407 if( nWrite!=n ){ 2408 rc = 1; 2409 } 2410 } 2411 fclose(out); 2412 if( rc==0 && mode && chmod(zFile, mode & 0777) ){ 2413 rc = 1; 2414 } 2415 if( rc ) return 2; 2416 sqlite3_result_int64(pCtx, nWrite); 2417 } 2418 } 2419 2420 if( mtime>=0 ){ 2421 #if defined(_WIN32) 2422 /* Windows */ 2423 FILETIME lastAccess; 2424 FILETIME lastWrite; 2425 SYSTEMTIME currentTime; 2426 LONGLONG intervals; 2427 HANDLE hFile; 2428 LPWSTR zUnicodeName; 2429 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); 2430 2431 GetSystemTime(¤tTime); 2432 SystemTimeToFileTime(¤tTime, &lastAccess); 2433 intervals = Int32x32To64(mtime, 10000000) + 116444736000000000; 2434 lastWrite.dwLowDateTime = (DWORD)intervals; 2435 lastWrite.dwHighDateTime = intervals >> 32; 2436 zUnicodeName = sqlite3_win32_utf8_to_unicode(zFile); 2437 if( zUnicodeName==0 ){ 2438 return 1; 2439 } 2440 hFile = CreateFileW( 2441 zUnicodeName, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, 2442 FILE_FLAG_BACKUP_SEMANTICS, NULL 2443 ); 2444 sqlite3_free(zUnicodeName); 2445 if( hFile!=INVALID_HANDLE_VALUE ){ 2446 BOOL bResult = SetFileTime(hFile, NULL, &lastAccess, &lastWrite); 2447 CloseHandle(hFile); 2448 return !bResult; 2449 }else{ 2450 return 1; 2451 } 2452 #elif defined(AT_FDCWD) && 0 /* utimensat() is not universally available */ 2453 /* Recent unix */ 2454 struct timespec times[2]; 2455 times[0].tv_nsec = times[1].tv_nsec = 0; 2456 times[0].tv_sec = time(0); 2457 times[1].tv_sec = mtime; 2458 if( utimensat(AT_FDCWD, zFile, times, AT_SYMLINK_NOFOLLOW) ){ 2459 return 1; 2460 } 2461 #else 2462 /* Legacy unix */ 2463 struct timeval times[2]; 2464 times[0].tv_usec = times[1].tv_usec = 0; 2465 times[0].tv_sec = time(0); 2466 times[1].tv_sec = mtime; 2467 if( utimes(zFile, times) ){ 2468 return 1; 2469 } 2470 #endif 2471 } 2472 2473 return 0; 2474 } 2475 2476 /* 2477 ** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function. 2478 ** Refer to header comments at the top of this file for details. 2479 */ 2480 static void writefileFunc( 2481 sqlite3_context *context, 2482 int argc, 2483 sqlite3_value **argv 2484 ){ 2485 const char *zFile; 2486 mode_t mode = 0; 2487 int res; 2488 sqlite3_int64 mtime = -1; 2489 2490 if( argc<2 || argc>4 ){ 2491 sqlite3_result_error(context, 2492 "wrong number of arguments to function writefile()", -1 2493 ); 2494 return; 2495 } 2496 2497 zFile = (const char*)sqlite3_value_text(argv[0]); 2498 if( zFile==0 ) return; 2499 if( argc>=3 ){ 2500 mode = (mode_t)sqlite3_value_int(argv[2]); 2501 } 2502 if( argc==4 ){ 2503 mtime = sqlite3_value_int64(argv[3]); 2504 } 2505 2506 res = writeFile(context, zFile, argv[1], mode, mtime); 2507 if( res==1 && errno==ENOENT ){ 2508 if( makeDirectory(zFile, mode)==SQLITE_OK ){ 2509 res = writeFile(context, zFile, argv[1], mode, mtime); 2510 } 2511 } 2512 2513 if( argc>2 && res!=0 ){ 2514 if( S_ISLNK(mode) ){ 2515 ctxErrorMsg(context, "failed to create symlink: %s", zFile); 2516 }else if( S_ISDIR(mode) ){ 2517 ctxErrorMsg(context, "failed to create directory: %s", zFile); 2518 }else{ 2519 ctxErrorMsg(context, "failed to write file: %s", zFile); 2520 } 2521 } 2522 } 2523 2524 /* 2525 ** SQL function: lsmode(MODE) 2526 ** 2527 ** Given a numberic st_mode from stat(), convert it into a human-readable 2528 ** text string in the style of "ls -l". 2529 */ 2530 static void lsModeFunc( 2531 sqlite3_context *context, 2532 int argc, 2533 sqlite3_value **argv 2534 ){ 2535 int i; 2536 int iMode = sqlite3_value_int(argv[0]); 2537 char z[16]; 2538 (void)argc; 2539 if( S_ISLNK(iMode) ){ 2540 z[0] = 'l'; 2541 }else if( S_ISREG(iMode) ){ 2542 z[0] = '-'; 2543 }else if( S_ISDIR(iMode) ){ 2544 z[0] = 'd'; 2545 }else{ 2546 z[0] = '?'; 2547 } 2548 for(i=0; i<3; i++){ 2549 int m = (iMode >> ((2-i)*3)); 2550 char *a = &z[1 + i*3]; 2551 a[0] = (m & 0x4) ? 'r' : '-'; 2552 a[1] = (m & 0x2) ? 'w' : '-'; 2553 a[2] = (m & 0x1) ? 'x' : '-'; 2554 } 2555 z[10] = '\0'; 2556 sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT); 2557 } 2558 2559 #ifndef SQLITE_OMIT_VIRTUALTABLE 2560 2561 /* 2562 ** Cursor type for recursively iterating through a directory structure. 2563 */ 2564 typedef struct fsdir_cursor fsdir_cursor; 2565 typedef struct FsdirLevel FsdirLevel; 2566 2567 struct FsdirLevel { 2568 DIR *pDir; /* From opendir() */ 2569 char *zDir; /* Name of directory (nul-terminated) */ 2570 }; 2571 2572 struct fsdir_cursor { 2573 sqlite3_vtab_cursor base; /* Base class - must be first */ 2574 2575 int nLvl; /* Number of entries in aLvl[] array */ 2576 int iLvl; /* Index of current entry */ 2577 FsdirLevel *aLvl; /* Hierarchy of directories being traversed */ 2578 2579 const char *zBase; 2580 int nBase; 2581 2582 struct stat sStat; /* Current lstat() results */ 2583 char *zPath; /* Path to current entry */ 2584 sqlite3_int64 iRowid; /* Current rowid */ 2585 }; 2586 2587 typedef struct fsdir_tab fsdir_tab; 2588 struct fsdir_tab { 2589 sqlite3_vtab base; /* Base class - must be first */ 2590 }; 2591 2592 /* 2593 ** Construct a new fsdir virtual table object. 2594 */ 2595 static int fsdirConnect( 2596 sqlite3 *db, 2597 void *pAux, 2598 int argc, const char *const*argv, 2599 sqlite3_vtab **ppVtab, 2600 char **pzErr 2601 ){ 2602 fsdir_tab *pNew = 0; 2603 int rc; 2604 (void)pAux; 2605 (void)argc; 2606 (void)argv; 2607 (void)pzErr; 2608 rc = sqlite3_declare_vtab(db, "CREATE TABLE x" FSDIR_SCHEMA); 2609 if( rc==SQLITE_OK ){ 2610 pNew = (fsdir_tab*)sqlite3_malloc( sizeof(*pNew) ); 2611 if( pNew==0 ) return SQLITE_NOMEM; 2612 memset(pNew, 0, sizeof(*pNew)); 2613 } 2614 *ppVtab = (sqlite3_vtab*)pNew; 2615 return rc; 2616 } 2617 2618 /* 2619 ** This method is the destructor for fsdir vtab objects. 2620 */ 2621 static int fsdirDisconnect(sqlite3_vtab *pVtab){ 2622 sqlite3_free(pVtab); 2623 return SQLITE_OK; 2624 } 2625 2626 /* 2627 ** Constructor for a new fsdir_cursor object. 2628 */ 2629 static int fsdirOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 2630 fsdir_cursor *pCur; 2631 (void)p; 2632 pCur = sqlite3_malloc( sizeof(*pCur) ); 2633 if( pCur==0 ) return SQLITE_NOMEM; 2634 memset(pCur, 0, sizeof(*pCur)); 2635 pCur->iLvl = -1; 2636 *ppCursor = &pCur->base; 2637 return SQLITE_OK; 2638 } 2639 2640 /* 2641 ** Reset a cursor back to the state it was in when first returned 2642 ** by fsdirOpen(). 2643 */ 2644 static void fsdirResetCursor(fsdir_cursor *pCur){ 2645 int i; 2646 for(i=0; i<=pCur->iLvl; i++){ 2647 FsdirLevel *pLvl = &pCur->aLvl[i]; 2648 if( pLvl->pDir ) closedir(pLvl->pDir); 2649 sqlite3_free(pLvl->zDir); 2650 } 2651 sqlite3_free(pCur->zPath); 2652 sqlite3_free(pCur->aLvl); 2653 pCur->aLvl = 0; 2654 pCur->zPath = 0; 2655 pCur->zBase = 0; 2656 pCur->nBase = 0; 2657 pCur->nLvl = 0; 2658 pCur->iLvl = -1; 2659 pCur->iRowid = 1; 2660 } 2661 2662 /* 2663 ** Destructor for an fsdir_cursor. 2664 */ 2665 static int fsdirClose(sqlite3_vtab_cursor *cur){ 2666 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2667 2668 fsdirResetCursor(pCur); 2669 sqlite3_free(pCur); 2670 return SQLITE_OK; 2671 } 2672 2673 /* 2674 ** Set the error message for the virtual table associated with cursor 2675 ** pCur to the results of vprintf(zFmt, ...). 2676 */ 2677 static void fsdirSetErrmsg(fsdir_cursor *pCur, const char *zFmt, ...){ 2678 va_list ap; 2679 va_start(ap, zFmt); 2680 pCur->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap); 2681 va_end(ap); 2682 } 2683 2684 2685 /* 2686 ** Advance an fsdir_cursor to its next row of output. 2687 */ 2688 static int fsdirNext(sqlite3_vtab_cursor *cur){ 2689 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2690 mode_t m = pCur->sStat.st_mode; 2691 2692 pCur->iRowid++; 2693 if( S_ISDIR(m) ){ 2694 /* Descend into this directory */ 2695 int iNew = pCur->iLvl + 1; 2696 FsdirLevel *pLvl; 2697 if( iNew>=pCur->nLvl ){ 2698 int nNew = iNew+1; 2699 sqlite3_int64 nByte = nNew*sizeof(FsdirLevel); 2700 FsdirLevel *aNew = (FsdirLevel*)sqlite3_realloc64(pCur->aLvl, nByte); 2701 if( aNew==0 ) return SQLITE_NOMEM; 2702 memset(&aNew[pCur->nLvl], 0, sizeof(FsdirLevel)*(nNew-pCur->nLvl)); 2703 pCur->aLvl = aNew; 2704 pCur->nLvl = nNew; 2705 } 2706 pCur->iLvl = iNew; 2707 pLvl = &pCur->aLvl[iNew]; 2708 2709 pLvl->zDir = pCur->zPath; 2710 pCur->zPath = 0; 2711 pLvl->pDir = opendir(pLvl->zDir); 2712 if( pLvl->pDir==0 ){ 2713 fsdirSetErrmsg(pCur, "cannot read directory: %s", pCur->zPath); 2714 return SQLITE_ERROR; 2715 } 2716 } 2717 2718 while( pCur->iLvl>=0 ){ 2719 FsdirLevel *pLvl = &pCur->aLvl[pCur->iLvl]; 2720 struct dirent *pEntry = readdir(pLvl->pDir); 2721 if( pEntry ){ 2722 if( pEntry->d_name[0]=='.' ){ 2723 if( pEntry->d_name[1]=='.' && pEntry->d_name[2]=='\0' ) continue; 2724 if( pEntry->d_name[1]=='\0' ) continue; 2725 } 2726 sqlite3_free(pCur->zPath); 2727 pCur->zPath = sqlite3_mprintf("%s/%s", pLvl->zDir, pEntry->d_name); 2728 if( pCur->zPath==0 ) return SQLITE_NOMEM; 2729 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ 2730 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); 2731 return SQLITE_ERROR; 2732 } 2733 return SQLITE_OK; 2734 } 2735 closedir(pLvl->pDir); 2736 sqlite3_free(pLvl->zDir); 2737 pLvl->pDir = 0; 2738 pLvl->zDir = 0; 2739 pCur->iLvl--; 2740 } 2741 2742 /* EOF */ 2743 sqlite3_free(pCur->zPath); 2744 pCur->zPath = 0; 2745 return SQLITE_OK; 2746 } 2747 2748 /* 2749 ** Return values of columns for the row at which the series_cursor 2750 ** is currently pointing. 2751 */ 2752 static int fsdirColumn( 2753 sqlite3_vtab_cursor *cur, /* The cursor */ 2754 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 2755 int i /* Which column to return */ 2756 ){ 2757 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2758 switch( i ){ 2759 case FSDIR_COLUMN_NAME: { 2760 sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT); 2761 break; 2762 } 2763 2764 case FSDIR_COLUMN_MODE: 2765 sqlite3_result_int64(ctx, pCur->sStat.st_mode); 2766 break; 2767 2768 case FSDIR_COLUMN_MTIME: 2769 sqlite3_result_int64(ctx, pCur->sStat.st_mtime); 2770 break; 2771 2772 case FSDIR_COLUMN_DATA: { 2773 mode_t m = pCur->sStat.st_mode; 2774 if( S_ISDIR(m) ){ 2775 sqlite3_result_null(ctx); 2776 #if !defined(_WIN32) && !defined(WIN32) 2777 }else if( S_ISLNK(m) ){ 2778 char aStatic[64]; 2779 char *aBuf = aStatic; 2780 sqlite3_int64 nBuf = 64; 2781 int n; 2782 2783 while( 1 ){ 2784 n = readlink(pCur->zPath, aBuf, nBuf); 2785 if( n<nBuf ) break; 2786 if( aBuf!=aStatic ) sqlite3_free(aBuf); 2787 nBuf = nBuf*2; 2788 aBuf = sqlite3_malloc64(nBuf); 2789 if( aBuf==0 ){ 2790 sqlite3_result_error_nomem(ctx); 2791 return SQLITE_NOMEM; 2792 } 2793 } 2794 2795 sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT); 2796 if( aBuf!=aStatic ) sqlite3_free(aBuf); 2797 #endif 2798 }else{ 2799 readFileContents(ctx, pCur->zPath); 2800 } 2801 } 2802 case FSDIR_COLUMN_PATH: 2803 default: { 2804 /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters. 2805 ** always return their values as NULL */ 2806 break; 2807 } 2808 } 2809 return SQLITE_OK; 2810 } 2811 2812 /* 2813 ** Return the rowid for the current row. In this implementation, the 2814 ** first row returned is assigned rowid value 1, and each subsequent 2815 ** row a value 1 more than that of the previous. 2816 */ 2817 static int fsdirRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 2818 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2819 *pRowid = pCur->iRowid; 2820 return SQLITE_OK; 2821 } 2822 2823 /* 2824 ** Return TRUE if the cursor has been moved off of the last 2825 ** row of output. 2826 */ 2827 static int fsdirEof(sqlite3_vtab_cursor *cur){ 2828 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2829 return (pCur->zPath==0); 2830 } 2831 2832 /* 2833 ** xFilter callback. 2834 ** 2835 ** idxNum==1 PATH parameter only 2836 ** idxNum==2 Both PATH and DIR supplied 2837 */ 2838 static int fsdirFilter( 2839 sqlite3_vtab_cursor *cur, 2840 int idxNum, const char *idxStr, 2841 int argc, sqlite3_value **argv 2842 ){ 2843 const char *zDir = 0; 2844 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2845 (void)idxStr; 2846 fsdirResetCursor(pCur); 2847 2848 if( idxNum==0 ){ 2849 fsdirSetErrmsg(pCur, "table function fsdir requires an argument"); 2850 return SQLITE_ERROR; 2851 } 2852 2853 assert( argc==idxNum && (argc==1 || argc==2) ); 2854 zDir = (const char*)sqlite3_value_text(argv[0]); 2855 if( zDir==0 ){ 2856 fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument"); 2857 return SQLITE_ERROR; 2858 } 2859 if( argc==2 ){ 2860 pCur->zBase = (const char*)sqlite3_value_text(argv[1]); 2861 } 2862 if( pCur->zBase ){ 2863 pCur->nBase = (int)strlen(pCur->zBase)+1; 2864 pCur->zPath = sqlite3_mprintf("%s/%s", pCur->zBase, zDir); 2865 }else{ 2866 pCur->zPath = sqlite3_mprintf("%s", zDir); 2867 } 2868 2869 if( pCur->zPath==0 ){ 2870 return SQLITE_NOMEM; 2871 } 2872 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ 2873 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); 2874 return SQLITE_ERROR; 2875 } 2876 2877 return SQLITE_OK; 2878 } 2879 2880 /* 2881 ** SQLite will invoke this method one or more times while planning a query 2882 ** that uses the generate_series virtual table. This routine needs to create 2883 ** a query plan for each invocation and compute an estimated cost for that 2884 ** plan. 2885 ** 2886 ** In this implementation idxNum is used to represent the 2887 ** query plan. idxStr is unused. 2888 ** 2889 ** The query plan is represented by values of idxNum: 2890 ** 2891 ** (1) The path value is supplied by argv[0] 2892 ** (2) Path is in argv[0] and dir is in argv[1] 2893 */ 2894 static int fsdirBestIndex( 2895 sqlite3_vtab *tab, 2896 sqlite3_index_info *pIdxInfo 2897 ){ 2898 int i; /* Loop over constraints */ 2899 int idxPath = -1; /* Index in pIdxInfo->aConstraint of PATH= */ 2900 int idxDir = -1; /* Index in pIdxInfo->aConstraint of DIR= */ 2901 int seenPath = 0; /* True if an unusable PATH= constraint is seen */ 2902 int seenDir = 0; /* True if an unusable DIR= constraint is seen */ 2903 const struct sqlite3_index_constraint *pConstraint; 2904 2905 (void)tab; 2906 pConstraint = pIdxInfo->aConstraint; 2907 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 2908 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 2909 switch( pConstraint->iColumn ){ 2910 case FSDIR_COLUMN_PATH: { 2911 if( pConstraint->usable ){ 2912 idxPath = i; 2913 seenPath = 0; 2914 }else if( idxPath<0 ){ 2915 seenPath = 1; 2916 } 2917 break; 2918 } 2919 case FSDIR_COLUMN_DIR: { 2920 if( pConstraint->usable ){ 2921 idxDir = i; 2922 seenDir = 0; 2923 }else if( idxDir<0 ){ 2924 seenDir = 1; 2925 } 2926 break; 2927 } 2928 } 2929 } 2930 if( seenPath || seenDir ){ 2931 /* If input parameters are unusable, disallow this plan */ 2932 return SQLITE_CONSTRAINT; 2933 } 2934 2935 if( idxPath<0 ){ 2936 pIdxInfo->idxNum = 0; 2937 /* The pIdxInfo->estimatedCost should have been initialized to a huge 2938 ** number. Leave it unchanged. */ 2939 pIdxInfo->estimatedRows = 0x7fffffff; 2940 }else{ 2941 pIdxInfo->aConstraintUsage[idxPath].omit = 1; 2942 pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1; 2943 if( idxDir>=0 ){ 2944 pIdxInfo->aConstraintUsage[idxDir].omit = 1; 2945 pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2; 2946 pIdxInfo->idxNum = 2; 2947 pIdxInfo->estimatedCost = 10.0; 2948 }else{ 2949 pIdxInfo->idxNum = 1; 2950 pIdxInfo->estimatedCost = 100.0; 2951 } 2952 } 2953 2954 return SQLITE_OK; 2955 } 2956 2957 /* 2958 ** Register the "fsdir" virtual table. 2959 */ 2960 static int fsdirRegister(sqlite3 *db){ 2961 static sqlite3_module fsdirModule = { 2962 0, /* iVersion */ 2963 0, /* xCreate */ 2964 fsdirConnect, /* xConnect */ 2965 fsdirBestIndex, /* xBestIndex */ 2966 fsdirDisconnect, /* xDisconnect */ 2967 0, /* xDestroy */ 2968 fsdirOpen, /* xOpen - open a cursor */ 2969 fsdirClose, /* xClose - close a cursor */ 2970 fsdirFilter, /* xFilter - configure scan constraints */ 2971 fsdirNext, /* xNext - advance a cursor */ 2972 fsdirEof, /* xEof - check for end of scan */ 2973 fsdirColumn, /* xColumn - read data */ 2974 fsdirRowid, /* xRowid - read data */ 2975 0, /* xUpdate */ 2976 0, /* xBegin */ 2977 0, /* xSync */ 2978 0, /* xCommit */ 2979 0, /* xRollback */ 2980 0, /* xFindMethod */ 2981 0, /* xRename */ 2982 0, /* xSavepoint */ 2983 0, /* xRelease */ 2984 0, /* xRollbackTo */ 2985 0, /* xShadowName */ 2986 }; 2987 2988 int rc = sqlite3_create_module(db, "fsdir", &fsdirModule, 0); 2989 return rc; 2990 } 2991 #else /* SQLITE_OMIT_VIRTUALTABLE */ 2992 # define fsdirRegister(x) SQLITE_OK 2993 #endif 2994 2995 #ifdef _WIN32 2996 2997 #endif 2998 int sqlite3_fileio_init( 2999 sqlite3 *db, 3000 char **pzErrMsg, 3001 const sqlite3_api_routines *pApi 3002 ){ 3003 int rc = SQLITE_OK; 3004 SQLITE_EXTENSION_INIT2(pApi); 3005 (void)pzErrMsg; /* Unused parameter */ 3006 rc = sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0, 3007 readfileFunc, 0, 0); 3008 if( rc==SQLITE_OK ){ 3009 rc = sqlite3_create_function(db, "writefile", -1, SQLITE_UTF8, 0, 3010 writefileFunc, 0, 0); 3011 } 3012 if( rc==SQLITE_OK ){ 3013 rc = sqlite3_create_function(db, "lsmode", 1, SQLITE_UTF8, 0, 3014 lsModeFunc, 0, 0); 3015 } 3016 if( rc==SQLITE_OK ){ 3017 rc = fsdirRegister(db); 3018 } 3019 return rc; 3020 } 3021 3022 /************************* End ../ext/misc/fileio.c ********************/ 3023 /************************* Begin ../ext/misc/completion.c ******************/ 3024 /* 3025 ** 2017-07-10 3026 ** 3027 ** The author disclaims copyright to this source code. In place of 3028 ** a legal notice, here is a blessing: 3029 ** 3030 ** May you do good and not evil. 3031 ** May you find forgiveness for yourself and forgive others. 3032 ** May you share freely, never taking more than you give. 3033 ** 3034 ************************************************************************* 3035 ** 3036 ** This file implements an eponymous virtual table that returns suggested 3037 ** completions for a partial SQL input. 3038 ** 3039 ** Suggested usage: 3040 ** 3041 ** SELECT DISTINCT candidate COLLATE nocase 3042 ** FROM completion($prefix,$wholeline) 3043 ** ORDER BY 1; 3044 ** 3045 ** The two query parameters are optional. $prefix is the text of the 3046 ** current word being typed and that is to be completed. $wholeline is 3047 ** the complete input line, used for context. 3048 ** 3049 ** The raw completion() table might return the same candidate multiple 3050 ** times, for example if the same column name is used to two or more 3051 ** tables. And the candidates are returned in an arbitrary order. Hence, 3052 ** the DISTINCT and ORDER BY are recommended. 3053 ** 3054 ** This virtual table operates at the speed of human typing, and so there 3055 ** is no attempt to make it fast. Even a slow implementation will be much 3056 ** faster than any human can type. 3057 ** 3058 */ 3059 SQLITE_EXTENSION_INIT1 3060 #include <assert.h> 3061 #include <string.h> 3062 #include <ctype.h> 3063 3064 #ifndef SQLITE_OMIT_VIRTUALTABLE 3065 3066 /* completion_vtab is a subclass of sqlite3_vtab which will 3067 ** serve as the underlying representation of a completion virtual table 3068 */ 3069 typedef struct completion_vtab completion_vtab; 3070 struct completion_vtab { 3071 sqlite3_vtab base; /* Base class - must be first */ 3072 sqlite3 *db; /* Database connection for this completion vtab */ 3073 }; 3074 3075 /* completion_cursor is a subclass of sqlite3_vtab_cursor which will 3076 ** serve as the underlying representation of a cursor that scans 3077 ** over rows of the result 3078 */ 3079 typedef struct completion_cursor completion_cursor; 3080 struct completion_cursor { 3081 sqlite3_vtab_cursor base; /* Base class - must be first */ 3082 sqlite3 *db; /* Database connection for this cursor */ 3083 int nPrefix, nLine; /* Number of bytes in zPrefix and zLine */ 3084 char *zPrefix; /* The prefix for the word we want to complete */ 3085 char *zLine; /* The whole that we want to complete */ 3086 const char *zCurrentRow; /* Current output row */ 3087 int szRow; /* Length of the zCurrentRow string */ 3088 sqlite3_stmt *pStmt; /* Current statement */ 3089 sqlite3_int64 iRowid; /* The rowid */ 3090 int ePhase; /* Current phase */ 3091 int j; /* inter-phase counter */ 3092 }; 3093 3094 /* Values for ePhase: 3095 */ 3096 #define COMPLETION_FIRST_PHASE 1 3097 #define COMPLETION_KEYWORDS 1 3098 #define COMPLETION_PRAGMAS 2 3099 #define COMPLETION_FUNCTIONS 3 3100 #define COMPLETION_COLLATIONS 4 3101 #define COMPLETION_INDEXES 5 3102 #define COMPLETION_TRIGGERS 6 3103 #define COMPLETION_DATABASES 7 3104 #define COMPLETION_TABLES 8 /* Also VIEWs and TRIGGERs */ 3105 #define COMPLETION_COLUMNS 9 3106 #define COMPLETION_MODULES 10 3107 #define COMPLETION_EOF 11 3108 3109 /* 3110 ** The completionConnect() method is invoked to create a new 3111 ** completion_vtab that describes the completion virtual table. 3112 ** 3113 ** Think of this routine as the constructor for completion_vtab objects. 3114 ** 3115 ** All this routine needs to do is: 3116 ** 3117 ** (1) Allocate the completion_vtab object and initialize all fields. 3118 ** 3119 ** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the 3120 ** result set of queries against completion will look like. 3121 */ 3122 static int completionConnect( 3123 sqlite3 *db, 3124 void *pAux, 3125 int argc, const char *const*argv, 3126 sqlite3_vtab **ppVtab, 3127 char **pzErr 3128 ){ 3129 completion_vtab *pNew; 3130 int rc; 3131 3132 (void)(pAux); /* Unused parameter */ 3133 (void)(argc); /* Unused parameter */ 3134 (void)(argv); /* Unused parameter */ 3135 (void)(pzErr); /* Unused parameter */ 3136 3137 /* Column numbers */ 3138 #define COMPLETION_COLUMN_CANDIDATE 0 /* Suggested completion of the input */ 3139 #define COMPLETION_COLUMN_PREFIX 1 /* Prefix of the word to be completed */ 3140 #define COMPLETION_COLUMN_WHOLELINE 2 /* Entire line seen so far */ 3141 #define COMPLETION_COLUMN_PHASE 3 /* ePhase - used for debugging only */ 3142 3143 rc = sqlite3_declare_vtab(db, 3144 "CREATE TABLE x(" 3145 " candidate TEXT," 3146 " prefix TEXT HIDDEN," 3147 " wholeline TEXT HIDDEN," 3148 " phase INT HIDDEN" /* Used for debugging only */ 3149 ")"); 3150 if( rc==SQLITE_OK ){ 3151 pNew = sqlite3_malloc( sizeof(*pNew) ); 3152 *ppVtab = (sqlite3_vtab*)pNew; 3153 if( pNew==0 ) return SQLITE_NOMEM; 3154 memset(pNew, 0, sizeof(*pNew)); 3155 pNew->db = db; 3156 } 3157 return rc; 3158 } 3159 3160 /* 3161 ** This method is the destructor for completion_cursor objects. 3162 */ 3163 static int completionDisconnect(sqlite3_vtab *pVtab){ 3164 sqlite3_free(pVtab); 3165 return SQLITE_OK; 3166 } 3167 3168 /* 3169 ** Constructor for a new completion_cursor object. 3170 */ 3171 static int completionOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 3172 completion_cursor *pCur; 3173 pCur = sqlite3_malloc( sizeof(*pCur) ); 3174 if( pCur==0 ) return SQLITE_NOMEM; 3175 memset(pCur, 0, sizeof(*pCur)); 3176 pCur->db = ((completion_vtab*)p)->db; 3177 *ppCursor = &pCur->base; 3178 return SQLITE_OK; 3179 } 3180 3181 /* 3182 ** Reset the completion_cursor. 3183 */ 3184 static void completionCursorReset(completion_cursor *pCur){ 3185 sqlite3_free(pCur->zPrefix); pCur->zPrefix = 0; pCur->nPrefix = 0; 3186 sqlite3_free(pCur->zLine); pCur->zLine = 0; pCur->nLine = 0; 3187 sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0; 3188 pCur->j = 0; 3189 } 3190 3191 /* 3192 ** Destructor for a completion_cursor. 3193 */ 3194 static int completionClose(sqlite3_vtab_cursor *cur){ 3195 completionCursorReset((completion_cursor*)cur); 3196 sqlite3_free(cur); 3197 return SQLITE_OK; 3198 } 3199 3200 /* 3201 ** Advance a completion_cursor to its next row of output. 3202 ** 3203 ** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object 3204 ** record the current state of the scan. This routine sets ->zCurrentRow 3205 ** to the current row of output and then returns. If no more rows remain, 3206 ** then ->ePhase is set to COMPLETION_EOF which will signal the virtual 3207 ** table that has reached the end of its scan. 3208 ** 3209 ** The current implementation just lists potential identifiers and 3210 ** keywords and filters them by zPrefix. Future enhancements should 3211 ** take zLine into account to try to restrict the set of identifiers and 3212 ** keywords based on what would be legal at the current point of input. 3213 */ 3214 static int completionNext(sqlite3_vtab_cursor *cur){ 3215 completion_cursor *pCur = (completion_cursor*)cur; 3216 int eNextPhase = 0; /* Next phase to try if current phase reaches end */ 3217 int iCol = -1; /* If >=0, step pCur->pStmt and use the i-th column */ 3218 pCur->iRowid++; 3219 while( pCur->ePhase!=COMPLETION_EOF ){ 3220 switch( pCur->ePhase ){ 3221 case COMPLETION_KEYWORDS: { 3222 if( pCur->j >= sqlite3_keyword_count() ){ 3223 pCur->zCurrentRow = 0; 3224 pCur->ePhase = COMPLETION_DATABASES; 3225 }else{ 3226 sqlite3_keyword_name(pCur->j++, &pCur->zCurrentRow, &pCur->szRow); 3227 } 3228 iCol = -1; 3229 break; 3230 } 3231 case COMPLETION_DATABASES: { 3232 if( pCur->pStmt==0 ){ 3233 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, 3234 &pCur->pStmt, 0); 3235 } 3236 iCol = 1; 3237 eNextPhase = COMPLETION_TABLES; 3238 break; 3239 } 3240 case COMPLETION_TABLES: { 3241 if( pCur->pStmt==0 ){ 3242 sqlite3_stmt *pS2; 3243 char *zSql = 0; 3244 const char *zSep = ""; 3245 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); 3246 while( sqlite3_step(pS2)==SQLITE_ROW ){ 3247 const char *zDb = (const char*)sqlite3_column_text(pS2, 1); 3248 zSql = sqlite3_mprintf( 3249 "%z%s" 3250 "SELECT name FROM \"%w\".sqlite_master", 3251 zSql, zSep, zDb 3252 ); 3253 if( zSql==0 ) return SQLITE_NOMEM; 3254 zSep = " UNION "; 3255 } 3256 sqlite3_finalize(pS2); 3257 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); 3258 sqlite3_free(zSql); 3259 } 3260 iCol = 0; 3261 eNextPhase = COMPLETION_COLUMNS; 3262 break; 3263 } 3264 case COMPLETION_COLUMNS: { 3265 if( pCur->pStmt==0 ){ 3266 sqlite3_stmt *pS2; 3267 char *zSql = 0; 3268 const char *zSep = ""; 3269 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); 3270 while( sqlite3_step(pS2)==SQLITE_ROW ){ 3271 const char *zDb = (const char*)sqlite3_column_text(pS2, 1); 3272 zSql = sqlite3_mprintf( 3273 "%z%s" 3274 "SELECT pti.name FROM \"%w\".sqlite_master AS sm" 3275 " JOIN pragma_table_info(sm.name,%Q) AS pti" 3276 " WHERE sm.type='table'", 3277 zSql, zSep, zDb, zDb 3278 ); 3279 if( zSql==0 ) return SQLITE_NOMEM; 3280 zSep = " UNION "; 3281 } 3282 sqlite3_finalize(pS2); 3283 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); 3284 sqlite3_free(zSql); 3285 } 3286 iCol = 0; 3287 eNextPhase = COMPLETION_EOF; 3288 break; 3289 } 3290 } 3291 if( iCol<0 ){ 3292 /* This case is when the phase presets zCurrentRow */ 3293 if( pCur->zCurrentRow==0 ) continue; 3294 }else{ 3295 if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){ 3296 /* Extract the next row of content */ 3297 pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol); 3298 pCur->szRow = sqlite3_column_bytes(pCur->pStmt, iCol); 3299 }else{ 3300 /* When all rows are finished, advance to the next phase */ 3301 sqlite3_finalize(pCur->pStmt); 3302 pCur->pStmt = 0; 3303 pCur->ePhase = eNextPhase; 3304 continue; 3305 } 3306 } 3307 if( pCur->nPrefix==0 ) break; 3308 if( pCur->nPrefix<=pCur->szRow 3309 && sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0 3310 ){ 3311 break; 3312 } 3313 } 3314 3315 return SQLITE_OK; 3316 } 3317 3318 /* 3319 ** Return values of columns for the row at which the completion_cursor 3320 ** is currently pointing. 3321 */ 3322 static int completionColumn( 3323 sqlite3_vtab_cursor *cur, /* The cursor */ 3324 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 3325 int i /* Which column to return */ 3326 ){ 3327 completion_cursor *pCur = (completion_cursor*)cur; 3328 switch( i ){ 3329 case COMPLETION_COLUMN_CANDIDATE: { 3330 sqlite3_result_text(ctx, pCur->zCurrentRow, pCur->szRow,SQLITE_TRANSIENT); 3331 break; 3332 } 3333 case COMPLETION_COLUMN_PREFIX: { 3334 sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT); 3335 break; 3336 } 3337 case COMPLETION_COLUMN_WHOLELINE: { 3338 sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT); 3339 break; 3340 } 3341 case COMPLETION_COLUMN_PHASE: { 3342 sqlite3_result_int(ctx, pCur->ePhase); 3343 break; 3344 } 3345 } 3346 return SQLITE_OK; 3347 } 3348 3349 /* 3350 ** Return the rowid for the current row. In this implementation, the 3351 ** rowid is the same as the output value. 3352 */ 3353 static int completionRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 3354 completion_cursor *pCur = (completion_cursor*)cur; 3355 *pRowid = pCur->iRowid; 3356 return SQLITE_OK; 3357 } 3358 3359 /* 3360 ** Return TRUE if the cursor has been moved off of the last 3361 ** row of output. 3362 */ 3363 static int completionEof(sqlite3_vtab_cursor *cur){ 3364 completion_cursor *pCur = (completion_cursor*)cur; 3365 return pCur->ePhase >= COMPLETION_EOF; 3366 } 3367 3368 /* 3369 ** This method is called to "rewind" the completion_cursor object back 3370 ** to the first row of output. This method is always called at least 3371 ** once prior to any call to completionColumn() or completionRowid() or 3372 ** completionEof(). 3373 */ 3374 static int completionFilter( 3375 sqlite3_vtab_cursor *pVtabCursor, 3376 int idxNum, const char *idxStr, 3377 int argc, sqlite3_value **argv 3378 ){ 3379 completion_cursor *pCur = (completion_cursor *)pVtabCursor; 3380 int iArg = 0; 3381 (void)(idxStr); /* Unused parameter */ 3382 (void)(argc); /* Unused parameter */ 3383 completionCursorReset(pCur); 3384 if( idxNum & 1 ){ 3385 pCur->nPrefix = sqlite3_value_bytes(argv[iArg]); 3386 if( pCur->nPrefix>0 ){ 3387 pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); 3388 if( pCur->zPrefix==0 ) return SQLITE_NOMEM; 3389 } 3390 iArg = 1; 3391 } 3392 if( idxNum & 2 ){ 3393 pCur->nLine = sqlite3_value_bytes(argv[iArg]); 3394 if( pCur->nLine>0 ){ 3395 pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); 3396 if( pCur->zLine==0 ) return SQLITE_NOMEM; 3397 } 3398 } 3399 if( pCur->zLine!=0 && pCur->zPrefix==0 ){ 3400 int i = pCur->nLine; 3401 while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){ 3402 i--; 3403 } 3404 pCur->nPrefix = pCur->nLine - i; 3405 if( pCur->nPrefix>0 ){ 3406 pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i); 3407 if( pCur->zPrefix==0 ) return SQLITE_NOMEM; 3408 } 3409 } 3410 pCur->iRowid = 0; 3411 pCur->ePhase = COMPLETION_FIRST_PHASE; 3412 return completionNext(pVtabCursor); 3413 } 3414 3415 /* 3416 ** SQLite will invoke this method one or more times while planning a query 3417 ** that uses the completion virtual table. This routine needs to create 3418 ** a query plan for each invocation and compute an estimated cost for that 3419 ** plan. 3420 ** 3421 ** There are two hidden parameters that act as arguments to the table-valued 3422 ** function: "prefix" and "wholeline". Bit 0 of idxNum is set if "prefix" 3423 ** is available and bit 1 is set if "wholeline" is available. 3424 */ 3425 static int completionBestIndex( 3426 sqlite3_vtab *tab, 3427 sqlite3_index_info *pIdxInfo 3428 ){ 3429 int i; /* Loop over constraints */ 3430 int idxNum = 0; /* The query plan bitmask */ 3431 int prefixIdx = -1; /* Index of the start= constraint, or -1 if none */ 3432 int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */ 3433 int nArg = 0; /* Number of arguments that completeFilter() expects */ 3434 const struct sqlite3_index_constraint *pConstraint; 3435 3436 (void)(tab); /* Unused parameter */ 3437 pConstraint = pIdxInfo->aConstraint; 3438 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 3439 if( pConstraint->usable==0 ) continue; 3440 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 3441 switch( pConstraint->iColumn ){ 3442 case COMPLETION_COLUMN_PREFIX: 3443 prefixIdx = i; 3444 idxNum |= 1; 3445 break; 3446 case COMPLETION_COLUMN_WHOLELINE: 3447 wholelineIdx = i; 3448 idxNum |= 2; 3449 break; 3450 } 3451 } 3452 if( prefixIdx>=0 ){ 3453 pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg; 3454 pIdxInfo->aConstraintUsage[prefixIdx].omit = 1; 3455 } 3456 if( wholelineIdx>=0 ){ 3457 pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg; 3458 pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1; 3459 } 3460 pIdxInfo->idxNum = idxNum; 3461 pIdxInfo->estimatedCost = (double)5000 - 1000*nArg; 3462 pIdxInfo->estimatedRows = 500 - 100*nArg; 3463 return SQLITE_OK; 3464 } 3465 3466 /* 3467 ** This following structure defines all the methods for the 3468 ** completion virtual table. 3469 */ 3470 static sqlite3_module completionModule = { 3471 0, /* iVersion */ 3472 0, /* xCreate */ 3473 completionConnect, /* xConnect */ 3474 completionBestIndex, /* xBestIndex */ 3475 completionDisconnect, /* xDisconnect */ 3476 0, /* xDestroy */ 3477 completionOpen, /* xOpen - open a cursor */ 3478 completionClose, /* xClose - close a cursor */ 3479 completionFilter, /* xFilter - configure scan constraints */ 3480 completionNext, /* xNext - advance a cursor */ 3481 completionEof, /* xEof - check for end of scan */ 3482 completionColumn, /* xColumn - read data */ 3483 completionRowid, /* xRowid - read data */ 3484 0, /* xUpdate */ 3485 0, /* xBegin */ 3486 0, /* xSync */ 3487 0, /* xCommit */ 3488 0, /* xRollback */ 3489 0, /* xFindMethod */ 3490 0, /* xRename */ 3491 0, /* xSavepoint */ 3492 0, /* xRelease */ 3493 0, /* xRollbackTo */ 3494 0 /* xShadowName */ 3495 }; 3496 3497 #endif /* SQLITE_OMIT_VIRTUALTABLE */ 3498 3499 int sqlite3CompletionVtabInit(sqlite3 *db){ 3500 int rc = SQLITE_OK; 3501 #ifndef SQLITE_OMIT_VIRTUALTABLE 3502 rc = sqlite3_create_module(db, "completion", &completionModule, 0); 3503 #endif 3504 return rc; 3505 } 3506 3507 #ifdef _WIN32 3508 3509 #endif 3510 int sqlite3_completion_init( 3511 sqlite3 *db, 3512 char **pzErrMsg, 3513 const sqlite3_api_routines *pApi 3514 ){ 3515 int rc = SQLITE_OK; 3516 SQLITE_EXTENSION_INIT2(pApi); 3517 (void)(pzErrMsg); /* Unused parameter */ 3518 #ifndef SQLITE_OMIT_VIRTUALTABLE 3519 rc = sqlite3CompletionVtabInit(db); 3520 #endif 3521 return rc; 3522 } 3523 3524 /************************* End ../ext/misc/completion.c ********************/ 3525 /************************* Begin ../ext/misc/appendvfs.c ******************/ 3526 /* 3527 ** 2017-10-20 3528 ** 3529 ** The author disclaims copyright to this source code. In place of 3530 ** a legal notice, here is a blessing: 3531 ** 3532 ** May you do good and not evil. 3533 ** May you find forgiveness for yourself and forgive others. 3534 ** May you share freely, never taking more than you give. 3535 ** 3536 ****************************************************************************** 3537 ** 3538 ** This file implements a VFS shim that allows an SQLite database to be 3539 ** appended onto the end of some other file, such as an executable. 3540 ** 3541 ** A special record must appear at the end of the file that identifies the 3542 ** file as an appended database and provides an offset to page 1. For 3543 ** best performance page 1 should be located at a disk page boundary, though 3544 ** that is not required. 3545 ** 3546 ** When opening a database using this VFS, the connection might treat 3547 ** the file as an ordinary SQLite database, or it might treat is as a 3548 ** database appended onto some other file. Here are the rules: 3549 ** 3550 ** (1) When opening a new empty file, that file is treated as an ordinary 3551 ** database. 3552 ** 3553 ** (2) When opening a file that begins with the standard SQLite prefix 3554 ** string "SQLite format 3", that file is treated as an ordinary 3555 ** database. 3556 ** 3557 ** (3) When opening a file that ends with the appendvfs trailer string 3558 ** "Start-Of-SQLite3-NNNNNNNN" that file is treated as an appended 3559 ** database. 3560 ** 3561 ** (4) If none of the above apply and the SQLITE_OPEN_CREATE flag is 3562 ** set, then a new database is appended to the already existing file. 3563 ** 3564 ** (5) Otherwise, SQLITE_CANTOPEN is returned. 3565 ** 3566 ** To avoid unnecessary complications with the PENDING_BYTE, the size of 3567 ** the file containing the database is limited to 1GB. This VFS will refuse 3568 ** to read or write past the 1GB mark. This restriction might be lifted in 3569 ** future versions. For now, if you need a large database, then keep the 3570 ** database in a separate file. 3571 ** 3572 ** If the file being opened is not an appended database, then this shim is 3573 ** a pass-through into the default underlying VFS. 3574 **/ 3575 SQLITE_EXTENSION_INIT1 3576 #include <string.h> 3577 #include <assert.h> 3578 3579 /* The append mark at the end of the database is: 3580 ** 3581 ** Start-Of-SQLite3-NNNNNNNN 3582 ** 123456789 123456789 12345 3583 ** 3584 ** The NNNNNNNN represents a 64-bit big-endian unsigned integer which is 3585 ** the offset to page 1. 3586 */ 3587 #define APND_MARK_PREFIX "Start-Of-SQLite3-" 3588 #define APND_MARK_PREFIX_SZ 17 3589 #define APND_MARK_SIZE 25 3590 3591 /* 3592 ** Maximum size of the combined prefix + database + append-mark. This 3593 ** must be less than 0x40000000 to avoid locking issues on Windows. 3594 */ 3595 #define APND_MAX_SIZE (65536*15259) 3596 3597 /* 3598 ** Forward declaration of objects used by this utility 3599 */ 3600 typedef struct sqlite3_vfs ApndVfs; 3601 typedef struct ApndFile ApndFile; 3602 3603 /* Access to a lower-level VFS that (might) implement dynamic loading, 3604 ** access to randomness, etc. 3605 */ 3606 #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) 3607 #define ORIGFILE(p) ((sqlite3_file*)(((ApndFile*)(p))+1)) 3608 3609 /* An open file */ 3610 struct ApndFile { 3611 sqlite3_file base; /* IO methods */ 3612 sqlite3_int64 iPgOne; /* File offset to page 1 */ 3613 sqlite3_int64 iMark; /* Start of the append-mark */ 3614 }; 3615 3616 /* 3617 ** Methods for ApndFile 3618 */ 3619 static int apndClose(sqlite3_file*); 3620 static int apndRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); 3621 static int apndWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); 3622 static int apndTruncate(sqlite3_file*, sqlite3_int64 size); 3623 static int apndSync(sqlite3_file*, int flags); 3624 static int apndFileSize(sqlite3_file*, sqlite3_int64 *pSize); 3625 static int apndLock(sqlite3_file*, int); 3626 static int apndUnlock(sqlite3_file*, int); 3627 static int apndCheckReservedLock(sqlite3_file*, int *pResOut); 3628 static int apndFileControl(sqlite3_file*, int op, void *pArg); 3629 static int apndSectorSize(sqlite3_file*); 3630 static int apndDeviceCharacteristics(sqlite3_file*); 3631 static int apndShmMap(sqlite3_file*, int iPg, int pgsz, int, void volatile**); 3632 static int apndShmLock(sqlite3_file*, int offset, int n, int flags); 3633 static void apndShmBarrier(sqlite3_file*); 3634 static int apndShmUnmap(sqlite3_file*, int deleteFlag); 3635 static int apndFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); 3636 static int apndUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); 3637 3638 /* 3639 ** Methods for ApndVfs 3640 */ 3641 static int apndOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); 3642 static int apndDelete(sqlite3_vfs*, const char *zName, int syncDir); 3643 static int apndAccess(sqlite3_vfs*, const char *zName, int flags, int *); 3644 static int apndFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); 3645 static void *apndDlOpen(sqlite3_vfs*, const char *zFilename); 3646 static void apndDlError(sqlite3_vfs*, int nByte, char *zErrMsg); 3647 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); 3648 static void apndDlClose(sqlite3_vfs*, void*); 3649 static int apndRandomness(sqlite3_vfs*, int nByte, char *zOut); 3650 static int apndSleep(sqlite3_vfs*, int microseconds); 3651 static int apndCurrentTime(sqlite3_vfs*, double*); 3652 static int apndGetLastError(sqlite3_vfs*, int, char *); 3653 static int apndCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); 3654 static int apndSetSystemCall(sqlite3_vfs*, const char*,sqlite3_syscall_ptr); 3655 static sqlite3_syscall_ptr apndGetSystemCall(sqlite3_vfs*, const char *z); 3656 static const char *apndNextSystemCall(sqlite3_vfs*, const char *zName); 3657 3658 static sqlite3_vfs apnd_vfs = { 3659 3, /* iVersion (set when registered) */ 3660 0, /* szOsFile (set when registered) */ 3661 1024, /* mxPathname */ 3662 0, /* pNext */ 3663 "apndvfs", /* zName */ 3664 0, /* pAppData (set when registered) */ 3665 apndOpen, /* xOpen */ 3666 apndDelete, /* xDelete */ 3667 apndAccess, /* xAccess */ 3668 apndFullPathname, /* xFullPathname */ 3669 apndDlOpen, /* xDlOpen */ 3670 apndDlError, /* xDlError */ 3671 apndDlSym, /* xDlSym */ 3672 apndDlClose, /* xDlClose */ 3673 apndRandomness, /* xRandomness */ 3674 apndSleep, /* xSleep */ 3675 apndCurrentTime, /* xCurrentTime */ 3676 apndGetLastError, /* xGetLastError */ 3677 apndCurrentTimeInt64, /* xCurrentTimeInt64 */ 3678 apndSetSystemCall, /* xSetSystemCall */ 3679 apndGetSystemCall, /* xGetSystemCall */ 3680 apndNextSystemCall /* xNextSystemCall */ 3681 }; 3682 3683 static const sqlite3_io_methods apnd_io_methods = { 3684 3, /* iVersion */ 3685 apndClose, /* xClose */ 3686 apndRead, /* xRead */ 3687 apndWrite, /* xWrite */ 3688 apndTruncate, /* xTruncate */ 3689 apndSync, /* xSync */ 3690 apndFileSize, /* xFileSize */ 3691 apndLock, /* xLock */ 3692 apndUnlock, /* xUnlock */ 3693 apndCheckReservedLock, /* xCheckReservedLock */ 3694 apndFileControl, /* xFileControl */ 3695 apndSectorSize, /* xSectorSize */ 3696 apndDeviceCharacteristics, /* xDeviceCharacteristics */ 3697 apndShmMap, /* xShmMap */ 3698 apndShmLock, /* xShmLock */ 3699 apndShmBarrier, /* xShmBarrier */ 3700 apndShmUnmap, /* xShmUnmap */ 3701 apndFetch, /* xFetch */ 3702 apndUnfetch /* xUnfetch */ 3703 }; 3704 3705 3706 3707 /* 3708 ** Close an apnd-file. 3709 */ 3710 static int apndClose(sqlite3_file *pFile){ 3711 pFile = ORIGFILE(pFile); 3712 return pFile->pMethods->xClose(pFile); 3713 } 3714 3715 /* 3716 ** Read data from an apnd-file. 3717 */ 3718 static int apndRead( 3719 sqlite3_file *pFile, 3720 void *zBuf, 3721 int iAmt, 3722 sqlite_int64 iOfst 3723 ){ 3724 ApndFile *p = (ApndFile *)pFile; 3725 pFile = ORIGFILE(pFile); 3726 return pFile->pMethods->xRead(pFile, zBuf, iAmt, iOfst+p->iPgOne); 3727 } 3728 3729 /* 3730 ** Add the append-mark onto the end of the file. 3731 */ 3732 static int apndWriteMark(ApndFile *p, sqlite3_file *pFile){ 3733 int i; 3734 unsigned char a[APND_MARK_SIZE]; 3735 memcpy(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ); 3736 for(i=0; i<8; i++){ 3737 a[APND_MARK_PREFIX_SZ+i] = (p->iPgOne >> (56 - i*8)) & 0xff; 3738 } 3739 return pFile->pMethods->xWrite(pFile, a, APND_MARK_SIZE, p->iMark); 3740 } 3741 3742 /* 3743 ** Write data to an apnd-file. 3744 */ 3745 static int apndWrite( 3746 sqlite3_file *pFile, 3747 const void *zBuf, 3748 int iAmt, 3749 sqlite_int64 iOfst 3750 ){ 3751 int rc; 3752 ApndFile *p = (ApndFile *)pFile; 3753 pFile = ORIGFILE(pFile); 3754 if( iOfst+iAmt>=APND_MAX_SIZE ) return SQLITE_FULL; 3755 rc = pFile->pMethods->xWrite(pFile, zBuf, iAmt, iOfst+p->iPgOne); 3756 if( rc==SQLITE_OK && iOfst + iAmt + p->iPgOne > p->iMark ){ 3757 sqlite3_int64 sz = 0; 3758 rc = pFile->pMethods->xFileSize(pFile, &sz); 3759 if( rc==SQLITE_OK ){ 3760 p->iMark = sz - APND_MARK_SIZE; 3761 if( iOfst + iAmt + p->iPgOne > p->iMark ){ 3762 p->iMark = p->iPgOne + iOfst + iAmt; 3763 rc = apndWriteMark(p, pFile); 3764 } 3765 } 3766 } 3767 return rc; 3768 } 3769 3770 /* 3771 ** Truncate an apnd-file. 3772 */ 3773 static int apndTruncate(sqlite3_file *pFile, sqlite_int64 size){ 3774 int rc; 3775 ApndFile *p = (ApndFile *)pFile; 3776 pFile = ORIGFILE(pFile); 3777 rc = pFile->pMethods->xTruncate(pFile, size+p->iPgOne+APND_MARK_SIZE); 3778 if( rc==SQLITE_OK ){ 3779 p->iMark = p->iPgOne+size; 3780 rc = apndWriteMark(p, pFile); 3781 } 3782 return rc; 3783 } 3784 3785 /* 3786 ** Sync an apnd-file. 3787 */ 3788 static int apndSync(sqlite3_file *pFile, int flags){ 3789 pFile = ORIGFILE(pFile); 3790 return pFile->pMethods->xSync(pFile, flags); 3791 } 3792 3793 /* 3794 ** Return the current file-size of an apnd-file. 3795 */ 3796 static int apndFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 3797 ApndFile *p = (ApndFile *)pFile; 3798 int rc; 3799 pFile = ORIGFILE(p); 3800 rc = pFile->pMethods->xFileSize(pFile, pSize); 3801 if( rc==SQLITE_OK && p->iPgOne ){ 3802 *pSize -= p->iPgOne + APND_MARK_SIZE; 3803 } 3804 return rc; 3805 } 3806 3807 /* 3808 ** Lock an apnd-file. 3809 */ 3810 static int apndLock(sqlite3_file *pFile, int eLock){ 3811 pFile = ORIGFILE(pFile); 3812 return pFile->pMethods->xLock(pFile, eLock); 3813 } 3814 3815 /* 3816 ** Unlock an apnd-file. 3817 */ 3818 static int apndUnlock(sqlite3_file *pFile, int eLock){ 3819 pFile = ORIGFILE(pFile); 3820 return pFile->pMethods->xUnlock(pFile, eLock); 3821 } 3822 3823 /* 3824 ** Check if another file-handle holds a RESERVED lock on an apnd-file. 3825 */ 3826 static int apndCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 3827 pFile = ORIGFILE(pFile); 3828 return pFile->pMethods->xCheckReservedLock(pFile, pResOut); 3829 } 3830 3831 /* 3832 ** File control method. For custom operations on an apnd-file. 3833 */ 3834 static int apndFileControl(sqlite3_file *pFile, int op, void *pArg){ 3835 ApndFile *p = (ApndFile *)pFile; 3836 int rc; 3837 pFile = ORIGFILE(pFile); 3838 rc = pFile->pMethods->xFileControl(pFile, op, pArg); 3839 if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){ 3840 *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", p->iPgOne, *(char**)pArg); 3841 } 3842 return rc; 3843 } 3844 3845 /* 3846 ** Return the sector-size in bytes for an apnd-file. 3847 */ 3848 static int apndSectorSize(sqlite3_file *pFile){ 3849 pFile = ORIGFILE(pFile); 3850 return pFile->pMethods->xSectorSize(pFile); 3851 } 3852 3853 /* 3854 ** Return the device characteristic flags supported by an apnd-file. 3855 */ 3856 static int apndDeviceCharacteristics(sqlite3_file *pFile){ 3857 pFile = ORIGFILE(pFile); 3858 return pFile->pMethods->xDeviceCharacteristics(pFile); 3859 } 3860 3861 /* Create a shared memory file mapping */ 3862 static int apndShmMap( 3863 sqlite3_file *pFile, 3864 int iPg, 3865 int pgsz, 3866 int bExtend, 3867 void volatile **pp 3868 ){ 3869 pFile = ORIGFILE(pFile); 3870 return pFile->pMethods->xShmMap(pFile,iPg,pgsz,bExtend,pp); 3871 } 3872 3873 /* Perform locking on a shared-memory segment */ 3874 static int apndShmLock(sqlite3_file *pFile, int offset, int n, int flags){ 3875 pFile = ORIGFILE(pFile); 3876 return pFile->pMethods->xShmLock(pFile,offset,n,flags); 3877 } 3878 3879 /* Memory barrier operation on shared memory */ 3880 static void apndShmBarrier(sqlite3_file *pFile){ 3881 pFile = ORIGFILE(pFile); 3882 pFile->pMethods->xShmBarrier(pFile); 3883 } 3884 3885 /* Unmap a shared memory segment */ 3886 static int apndShmUnmap(sqlite3_file *pFile, int deleteFlag){ 3887 pFile = ORIGFILE(pFile); 3888 return pFile->pMethods->xShmUnmap(pFile,deleteFlag); 3889 } 3890 3891 /* Fetch a page of a memory-mapped file */ 3892 static int apndFetch( 3893 sqlite3_file *pFile, 3894 sqlite3_int64 iOfst, 3895 int iAmt, 3896 void **pp 3897 ){ 3898 ApndFile *p = (ApndFile *)pFile; 3899 pFile = ORIGFILE(pFile); 3900 return pFile->pMethods->xFetch(pFile, iOfst+p->iPgOne, iAmt, pp); 3901 } 3902 3903 /* Release a memory-mapped page */ 3904 static int apndUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ 3905 ApndFile *p = (ApndFile *)pFile; 3906 pFile = ORIGFILE(pFile); 3907 return pFile->pMethods->xUnfetch(pFile, iOfst+p->iPgOne, pPage); 3908 } 3909 3910 /* 3911 ** Check to see if the file is an ordinary SQLite database file. 3912 */ 3913 static int apndIsOrdinaryDatabaseFile(sqlite3_int64 sz, sqlite3_file *pFile){ 3914 int rc; 3915 char zHdr[16]; 3916 static const char aSqliteHdr[] = "SQLite format 3"; 3917 if( sz<512 ) return 0; 3918 rc = pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), 0); 3919 if( rc ) return 0; 3920 return memcmp(zHdr, aSqliteHdr, sizeof(zHdr))==0; 3921 } 3922 3923 /* 3924 ** Try to read the append-mark off the end of a file. Return the 3925 ** start of the appended database if the append-mark is present. If 3926 ** there is no append-mark, return -1; 3927 */ 3928 static sqlite3_int64 apndReadMark(sqlite3_int64 sz, sqlite3_file *pFile){ 3929 int rc, i; 3930 sqlite3_int64 iMark; 3931 unsigned char a[APND_MARK_SIZE]; 3932 3933 if( sz<=APND_MARK_SIZE ) return -1; 3934 rc = pFile->pMethods->xRead(pFile, a, APND_MARK_SIZE, sz-APND_MARK_SIZE); 3935 if( rc ) return -1; 3936 if( memcmp(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ)!=0 ) return -1; 3937 iMark = ((sqlite3_int64)(a[APND_MARK_PREFIX_SZ]&0x7f))<<56; 3938 for(i=1; i<8; i++){ 3939 iMark += (sqlite3_int64)a[APND_MARK_PREFIX_SZ+i]<<(56-8*i); 3940 } 3941 return iMark; 3942 } 3943 3944 /* 3945 ** Open an apnd file handle. 3946 */ 3947 static int apndOpen( 3948 sqlite3_vfs *pVfs, 3949 const char *zName, 3950 sqlite3_file *pFile, 3951 int flags, 3952 int *pOutFlags 3953 ){ 3954 ApndFile *p; 3955 sqlite3_file *pSubFile; 3956 sqlite3_vfs *pSubVfs; 3957 int rc; 3958 sqlite3_int64 sz; 3959 pSubVfs = ORIGVFS(pVfs); 3960 if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){ 3961 return pSubVfs->xOpen(pSubVfs, zName, pFile, flags, pOutFlags); 3962 } 3963 p = (ApndFile*)pFile; 3964 memset(p, 0, sizeof(*p)); 3965 pSubFile = ORIGFILE(pFile); 3966 p->base.pMethods = &apnd_io_methods; 3967 rc = pSubVfs->xOpen(pSubVfs, zName, pSubFile, flags, pOutFlags); 3968 if( rc ) goto apnd_open_done; 3969 rc = pSubFile->pMethods->xFileSize(pSubFile, &sz); 3970 if( rc ){ 3971 pSubFile->pMethods->xClose(pSubFile); 3972 goto apnd_open_done; 3973 } 3974 if( apndIsOrdinaryDatabaseFile(sz, pSubFile) ){ 3975 memmove(pFile, pSubFile, pSubVfs->szOsFile); 3976 return SQLITE_OK; 3977 } 3978 p->iMark = 0; 3979 p->iPgOne = apndReadMark(sz, pFile); 3980 if( p->iPgOne>0 ){ 3981 return SQLITE_OK; 3982 } 3983 if( (flags & SQLITE_OPEN_CREATE)==0 ){ 3984 pSubFile->pMethods->xClose(pSubFile); 3985 rc = SQLITE_CANTOPEN; 3986 } 3987 p->iPgOne = (sz+0xfff) & ~(sqlite3_int64)0xfff; 3988 apnd_open_done: 3989 if( rc ) pFile->pMethods = 0; 3990 return rc; 3991 } 3992 3993 /* 3994 ** All other VFS methods are pass-thrus. 3995 */ 3996 static int apndDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ 3997 return ORIGVFS(pVfs)->xDelete(ORIGVFS(pVfs), zPath, dirSync); 3998 } 3999 static int apndAccess( 4000 sqlite3_vfs *pVfs, 4001 const char *zPath, 4002 int flags, 4003 int *pResOut 4004 ){ 4005 return ORIGVFS(pVfs)->xAccess(ORIGVFS(pVfs), zPath, flags, pResOut); 4006 } 4007 static int apndFullPathname( 4008 sqlite3_vfs *pVfs, 4009 const char *zPath, 4010 int nOut, 4011 char *zOut 4012 ){ 4013 return ORIGVFS(pVfs)->xFullPathname(ORIGVFS(pVfs),zPath,nOut,zOut); 4014 } 4015 static void *apndDlOpen(sqlite3_vfs *pVfs, const char *zPath){ 4016 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); 4017 } 4018 static void apndDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ 4019 ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); 4020 } 4021 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ 4022 return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); 4023 } 4024 static void apndDlClose(sqlite3_vfs *pVfs, void *pHandle){ 4025 ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); 4026 } 4027 static int apndRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ 4028 return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); 4029 } 4030 static int apndSleep(sqlite3_vfs *pVfs, int nMicro){ 4031 return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); 4032 } 4033 static int apndCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ 4034 return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); 4035 } 4036 static int apndGetLastError(sqlite3_vfs *pVfs, int a, char *b){ 4037 return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); 4038 } 4039 static int apndCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ 4040 return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); 4041 } 4042 static int apndSetSystemCall( 4043 sqlite3_vfs *pVfs, 4044 const char *zName, 4045 sqlite3_syscall_ptr pCall 4046 ){ 4047 return ORIGVFS(pVfs)->xSetSystemCall(ORIGVFS(pVfs),zName,pCall); 4048 } 4049 static sqlite3_syscall_ptr apndGetSystemCall( 4050 sqlite3_vfs *pVfs, 4051 const char *zName 4052 ){ 4053 return ORIGVFS(pVfs)->xGetSystemCall(ORIGVFS(pVfs),zName); 4054 } 4055 static const char *apndNextSystemCall(sqlite3_vfs *pVfs, const char *zName){ 4056 return ORIGVFS(pVfs)->xNextSystemCall(ORIGVFS(pVfs), zName); 4057 } 4058 4059 4060 #ifdef _WIN32 4061 4062 #endif 4063 /* 4064 ** This routine is called when the extension is loaded. 4065 ** Register the new VFS. 4066 */ 4067 int sqlite3_appendvfs_init( 4068 sqlite3 *db, 4069 char **pzErrMsg, 4070 const sqlite3_api_routines *pApi 4071 ){ 4072 int rc = SQLITE_OK; 4073 sqlite3_vfs *pOrig; 4074 SQLITE_EXTENSION_INIT2(pApi); 4075 (void)pzErrMsg; 4076 (void)db; 4077 pOrig = sqlite3_vfs_find(0); 4078 apnd_vfs.iVersion = pOrig->iVersion; 4079 apnd_vfs.pAppData = pOrig; 4080 apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile); 4081 rc = sqlite3_vfs_register(&apnd_vfs, 0); 4082 #ifdef APPENDVFS_TEST 4083 if( rc==SQLITE_OK ){ 4084 rc = sqlite3_auto_extension((void(*)(void))apndvfsRegister); 4085 } 4086 #endif 4087 if( rc==SQLITE_OK ) rc = SQLITE_OK_LOAD_PERMANENTLY; 4088 return rc; 4089 } 4090 4091 /************************* End ../ext/misc/appendvfs.c ********************/ 4092 /************************* Begin ../ext/misc/memtrace.c ******************/ 4093 /* 4094 ** 2019-01-21 4095 ** 4096 ** The author disclaims copyright to this source code. In place of 4097 ** a legal notice, here is a blessing: 4098 ** 4099 ** May you do good and not evil. 4100 ** May you find forgiveness for yourself and forgive others. 4101 ** May you share freely, never taking more than you give. 4102 ** 4103 ************************************************************************* 4104 ** 4105 ** This file implements an extension that uses the SQLITE_CONFIG_MALLOC 4106 ** mechanism to add a tracing layer on top of SQLite. If this extension 4107 ** is registered prior to sqlite3_initialize(), it will cause all memory 4108 ** allocation activities to be logged on standard output, or to some other 4109 ** FILE specified by the initializer. 4110 ** 4111 ** This file needs to be compiled into the application that uses it. 4112 ** 4113 ** This extension is used to implement the --memtrace option of the 4114 ** command-line shell. 4115 */ 4116 #include <assert.h> 4117 #include <string.h> 4118 #include <stdio.h> 4119 4120 /* The original memory allocation routines */ 4121 static sqlite3_mem_methods memtraceBase; 4122 static FILE *memtraceOut; 4123 4124 /* Methods that trace memory allocations */ 4125 static void *memtraceMalloc(int n){ 4126 if( memtraceOut ){ 4127 fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n", 4128 memtraceBase.xRoundup(n)); 4129 } 4130 return memtraceBase.xMalloc(n); 4131 } 4132 static void memtraceFree(void *p){ 4133 if( p==0 ) return; 4134 if( memtraceOut ){ 4135 fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p)); 4136 } 4137 memtraceBase.xFree(p); 4138 } 4139 static void *memtraceRealloc(void *p, int n){ 4140 if( p==0 ) return memtraceMalloc(n); 4141 if( n==0 ){ 4142 memtraceFree(p); 4143 return 0; 4144 } 4145 if( memtraceOut ){ 4146 fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n", 4147 memtraceBase.xSize(p), memtraceBase.xRoundup(n)); 4148 } 4149 return memtraceBase.xRealloc(p, n); 4150 } 4151 static int memtraceSize(void *p){ 4152 return memtraceBase.xSize(p); 4153 } 4154 static int memtraceRoundup(int n){ 4155 return memtraceBase.xRoundup(n); 4156 } 4157 static int memtraceInit(void *p){ 4158 return memtraceBase.xInit(p); 4159 } 4160 static void memtraceShutdown(void *p){ 4161 memtraceBase.xShutdown(p); 4162 } 4163 4164 /* The substitute memory allocator */ 4165 static sqlite3_mem_methods ersaztMethods = { 4166 memtraceMalloc, 4167 memtraceFree, 4168 memtraceRealloc, 4169 memtraceSize, 4170 memtraceRoundup, 4171 memtraceInit, 4172 memtraceShutdown, 4173 0 4174 }; 4175 4176 /* Begin tracing memory allocations to out. */ 4177 int sqlite3MemTraceActivate(FILE *out){ 4178 int rc = SQLITE_OK; 4179 if( memtraceBase.xMalloc==0 ){ 4180 rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase); 4181 if( rc==SQLITE_OK ){ 4182 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods); 4183 } 4184 } 4185 memtraceOut = out; 4186 return rc; 4187 } 4188 4189 /* Deactivate memory tracing */ 4190 int sqlite3MemTraceDeactivate(void){ 4191 int rc = SQLITE_OK; 4192 if( memtraceBase.xMalloc!=0 ){ 4193 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase); 4194 if( rc==SQLITE_OK ){ 4195 memset(&memtraceBase, 0, sizeof(memtraceBase)); 4196 } 4197 } 4198 memtraceOut = 0; 4199 return rc; 4200 } 4201 4202 /************************* End ../ext/misc/memtrace.c ********************/ 4203 #ifdef SQLITE_HAVE_ZLIB 4204 /************************* Begin ../ext/misc/zipfile.c ******************/ 4205 /* 4206 ** 2017-12-26 4207 ** 4208 ** The author disclaims copyright to this source code. In place of 4209 ** a legal notice, here is a blessing: 4210 ** 4211 ** May you do good and not evil. 4212 ** May you find forgiveness for yourself and forgive others. 4213 ** May you share freely, never taking more than you give. 4214 ** 4215 ****************************************************************************** 4216 ** 4217 ** This file implements a virtual table for reading and writing ZIP archive 4218 ** files. 4219 ** 4220 ** Usage example: 4221 ** 4222 ** SELECT name, sz, datetime(mtime,'unixepoch') FROM zipfile($filename); 4223 ** 4224 ** Current limitations: 4225 ** 4226 ** * No support for encryption 4227 ** * No support for ZIP archives spanning multiple files 4228 ** * No support for zip64 extensions 4229 ** * Only the "inflate/deflate" (zlib) compression method is supported 4230 */ 4231 SQLITE_EXTENSION_INIT1 4232 #include <stdio.h> 4233 #include <string.h> 4234 #include <assert.h> 4235 4236 #include <zlib.h> 4237 4238 #ifndef SQLITE_OMIT_VIRTUALTABLE 4239 4240 #ifndef SQLITE_AMALGAMATION 4241 4242 /* typedef sqlite3_int64 i64; */ 4243 /* typedef unsigned char u8; */ 4244 typedef unsigned short u16; 4245 typedef unsigned long u32; 4246 #define MIN(a,b) ((a)<(b) ? (a) : (b)) 4247 4248 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) 4249 # define ALWAYS(X) (1) 4250 # define NEVER(X) (0) 4251 #elif !defined(NDEBUG) 4252 # define ALWAYS(X) ((X)?1:(assert(0),0)) 4253 # define NEVER(X) ((X)?(assert(0),1):0) 4254 #else 4255 # define ALWAYS(X) (X) 4256 # define NEVER(X) (X) 4257 #endif 4258 4259 #endif /* SQLITE_AMALGAMATION */ 4260 4261 /* 4262 ** Definitions for mode bitmasks S_IFDIR, S_IFREG and S_IFLNK. 4263 ** 4264 ** In some ways it would be better to obtain these values from system 4265 ** header files. But, the dependency is undesirable and (a) these 4266 ** have been stable for decades, (b) the values are part of POSIX and 4267 ** are also made explicit in [man stat], and (c) are part of the 4268 ** file format for zip archives. 4269 */ 4270 #ifndef S_IFDIR 4271 # define S_IFDIR 0040000 4272 #endif 4273 #ifndef S_IFREG 4274 # define S_IFREG 0100000 4275 #endif 4276 #ifndef S_IFLNK 4277 # define S_IFLNK 0120000 4278 #endif 4279 4280 static const char ZIPFILE_SCHEMA[] = 4281 "CREATE TABLE y(" 4282 "name PRIMARY KEY," /* 0: Name of file in zip archive */ 4283 "mode," /* 1: POSIX mode for file */ 4284 "mtime," /* 2: Last modification time (secs since 1970)*/ 4285 "sz," /* 3: Size of object */ 4286 "rawdata," /* 4: Raw data */ 4287 "data," /* 5: Uncompressed data */ 4288 "method," /* 6: Compression method (integer) */ 4289 "z HIDDEN" /* 7: Name of zip file */ 4290 ") WITHOUT ROWID;"; 4291 4292 #define ZIPFILE_F_COLUMN_IDX 7 /* Index of column "file" in the above */ 4293 #define ZIPFILE_BUFFER_SIZE (64*1024) 4294 4295 4296 /* 4297 ** Magic numbers used to read and write zip files. 4298 ** 4299 ** ZIPFILE_NEWENTRY_MADEBY: 4300 ** Use this value for the "version-made-by" field in new zip file 4301 ** entries. The upper byte indicates "unix", and the lower byte 4302 ** indicates that the zip file matches pkzip specification 3.0. 4303 ** This is what info-zip seems to do. 4304 ** 4305 ** ZIPFILE_NEWENTRY_REQUIRED: 4306 ** Value for "version-required-to-extract" field of new entries. 4307 ** Version 2.0 is required to support folders and deflate compression. 4308 ** 4309 ** ZIPFILE_NEWENTRY_FLAGS: 4310 ** Value for "general-purpose-bit-flags" field of new entries. Bit 4311 ** 11 means "utf-8 filename and comment". 4312 ** 4313 ** ZIPFILE_SIGNATURE_CDS: 4314 ** First 4 bytes of a valid CDS record. 4315 ** 4316 ** ZIPFILE_SIGNATURE_LFH: 4317 ** First 4 bytes of a valid LFH record. 4318 ** 4319 ** ZIPFILE_SIGNATURE_EOCD 4320 ** First 4 bytes of a valid EOCD record. 4321 */ 4322 #define ZIPFILE_EXTRA_TIMESTAMP 0x5455 4323 #define ZIPFILE_NEWENTRY_MADEBY ((3<<8) + 30) 4324 #define ZIPFILE_NEWENTRY_REQUIRED 20 4325 #define ZIPFILE_NEWENTRY_FLAGS 0x800 4326 #define ZIPFILE_SIGNATURE_CDS 0x02014b50 4327 #define ZIPFILE_SIGNATURE_LFH 0x04034b50 4328 #define ZIPFILE_SIGNATURE_EOCD 0x06054b50 4329 4330 /* 4331 ** The sizes of the fixed-size part of each of the three main data 4332 ** structures in a zip archive. 4333 */ 4334 #define ZIPFILE_LFH_FIXED_SZ 30 4335 #define ZIPFILE_EOCD_FIXED_SZ 22 4336 #define ZIPFILE_CDS_FIXED_SZ 46 4337 4338 /* 4339 *** 4.3.16 End of central directory record: 4340 *** 4341 *** end of central dir signature 4 bytes (0x06054b50) 4342 *** number of this disk 2 bytes 4343 *** number of the disk with the 4344 *** start of the central directory 2 bytes 4345 *** total number of entries in the 4346 *** central directory on this disk 2 bytes 4347 *** total number of entries in 4348 *** the central directory 2 bytes 4349 *** size of the central directory 4 bytes 4350 *** offset of start of central 4351 *** directory with respect to 4352 *** the starting disk number 4 bytes 4353 *** .ZIP file comment length 2 bytes 4354 *** .ZIP file comment (variable size) 4355 */ 4356 typedef struct ZipfileEOCD ZipfileEOCD; 4357 struct ZipfileEOCD { 4358 u16 iDisk; 4359 u16 iFirstDisk; 4360 u16 nEntry; 4361 u16 nEntryTotal; 4362 u32 nSize; 4363 u32 iOffset; 4364 }; 4365 4366 /* 4367 *** 4.3.12 Central directory structure: 4368 *** 4369 *** ... 4370 *** 4371 *** central file header signature 4 bytes (0x02014b50) 4372 *** version made by 2 bytes 4373 *** version needed to extract 2 bytes 4374 *** general purpose bit flag 2 bytes 4375 *** compression method 2 bytes 4376 *** last mod file time 2 bytes 4377 *** last mod file date 2 bytes 4378 *** crc-32 4 bytes 4379 *** compressed size 4 bytes 4380 *** uncompressed size 4 bytes 4381 *** file name length 2 bytes 4382 *** extra field length 2 bytes 4383 *** file comment length 2 bytes 4384 *** disk number start 2 bytes 4385 *** internal file attributes 2 bytes 4386 *** external file attributes 4 bytes 4387 *** relative offset of local header 4 bytes 4388 */ 4389 typedef struct ZipfileCDS ZipfileCDS; 4390 struct ZipfileCDS { 4391 u16 iVersionMadeBy; 4392 u16 iVersionExtract; 4393 u16 flags; 4394 u16 iCompression; 4395 u16 mTime; 4396 u16 mDate; 4397 u32 crc32; 4398 u32 szCompressed; 4399 u32 szUncompressed; 4400 u16 nFile; 4401 u16 nExtra; 4402 u16 nComment; 4403 u16 iDiskStart; 4404 u16 iInternalAttr; 4405 u32 iExternalAttr; 4406 u32 iOffset; 4407 char *zFile; /* Filename (sqlite3_malloc()) */ 4408 }; 4409 4410 /* 4411 *** 4.3.7 Local file header: 4412 *** 4413 *** local file header signature 4 bytes (0x04034b50) 4414 *** version needed to extract 2 bytes 4415 *** general purpose bit flag 2 bytes 4416 *** compression method 2 bytes 4417 *** last mod file time 2 bytes 4418 *** last mod file date 2 bytes 4419 *** crc-32 4 bytes 4420 *** compressed size 4 bytes 4421 *** uncompressed size 4 bytes 4422 *** file name length 2 bytes 4423 *** extra field length 2 bytes 4424 *** 4425 */ 4426 typedef struct ZipfileLFH ZipfileLFH; 4427 struct ZipfileLFH { 4428 u16 iVersionExtract; 4429 u16 flags; 4430 u16 iCompression; 4431 u16 mTime; 4432 u16 mDate; 4433 u32 crc32; 4434 u32 szCompressed; 4435 u32 szUncompressed; 4436 u16 nFile; 4437 u16 nExtra; 4438 }; 4439 4440 typedef struct ZipfileEntry ZipfileEntry; 4441 struct ZipfileEntry { 4442 ZipfileCDS cds; /* Parsed CDS record */ 4443 u32 mUnixTime; /* Modification time, in UNIX format */ 4444 u8 *aExtra; /* cds.nExtra+cds.nComment bytes of extra data */ 4445 i64 iDataOff; /* Offset to data in file (if aData==0) */ 4446 u8 *aData; /* cds.szCompressed bytes of compressed data */ 4447 ZipfileEntry *pNext; /* Next element in in-memory CDS */ 4448 }; 4449 4450 /* 4451 ** Cursor type for zipfile tables. 4452 */ 4453 typedef struct ZipfileCsr ZipfileCsr; 4454 struct ZipfileCsr { 4455 sqlite3_vtab_cursor base; /* Base class - must be first */ 4456 i64 iId; /* Cursor ID */ 4457 u8 bEof; /* True when at EOF */ 4458 u8 bNoop; /* If next xNext() call is no-op */ 4459 4460 /* Used outside of write transactions */ 4461 FILE *pFile; /* Zip file */ 4462 i64 iNextOff; /* Offset of next record in central directory */ 4463 ZipfileEOCD eocd; /* Parse of central directory record */ 4464 4465 ZipfileEntry *pFreeEntry; /* Free this list when cursor is closed or reset */ 4466 ZipfileEntry *pCurrent; /* Current entry */ 4467 ZipfileCsr *pCsrNext; /* Next cursor on same virtual table */ 4468 }; 4469 4470 typedef struct ZipfileTab ZipfileTab; 4471 struct ZipfileTab { 4472 sqlite3_vtab base; /* Base class - must be first */ 4473 char *zFile; /* Zip file this table accesses (may be NULL) */ 4474 sqlite3 *db; /* Host database connection */ 4475 u8 *aBuffer; /* Temporary buffer used for various tasks */ 4476 4477 ZipfileCsr *pCsrList; /* List of cursors */ 4478 i64 iNextCsrid; 4479 4480 /* The following are used by write transactions only */ 4481 ZipfileEntry *pFirstEntry; /* Linked list of all files (if pWriteFd!=0) */ 4482 ZipfileEntry *pLastEntry; /* Last element in pFirstEntry list */ 4483 FILE *pWriteFd; /* File handle open on zip archive */ 4484 i64 szCurrent; /* Current size of zip archive */ 4485 i64 szOrig; /* Size of archive at start of transaction */ 4486 }; 4487 4488 /* 4489 ** Set the error message contained in context ctx to the results of 4490 ** vprintf(zFmt, ...). 4491 */ 4492 static void zipfileCtxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){ 4493 char *zMsg = 0; 4494 va_list ap; 4495 va_start(ap, zFmt); 4496 zMsg = sqlite3_vmprintf(zFmt, ap); 4497 sqlite3_result_error(ctx, zMsg, -1); 4498 sqlite3_free(zMsg); 4499 va_end(ap); 4500 } 4501 4502 /* 4503 ** If string zIn is quoted, dequote it in place. Otherwise, if the string 4504 ** is not quoted, do nothing. 4505 */ 4506 static void zipfileDequote(char *zIn){ 4507 char q = zIn[0]; 4508 if( q=='"' || q=='\'' || q=='`' || q=='[' ){ 4509 int iIn = 1; 4510 int iOut = 0; 4511 if( q=='[' ) q = ']'; 4512 while( ALWAYS(zIn[iIn]) ){ 4513 char c = zIn[iIn++]; 4514 if( c==q && zIn[iIn++]!=q ) break; 4515 zIn[iOut++] = c; 4516 } 4517 zIn[iOut] = '\0'; 4518 } 4519 } 4520 4521 /* 4522 ** Construct a new ZipfileTab virtual table object. 4523 ** 4524 ** argv[0] -> module name ("zipfile") 4525 ** argv[1] -> database name 4526 ** argv[2] -> table name 4527 ** argv[...] -> "column name" and other module argument fields. 4528 */ 4529 static int zipfileConnect( 4530 sqlite3 *db, 4531 void *pAux, 4532 int argc, const char *const*argv, 4533 sqlite3_vtab **ppVtab, 4534 char **pzErr 4535 ){ 4536 int nByte = sizeof(ZipfileTab) + ZIPFILE_BUFFER_SIZE; 4537 int nFile = 0; 4538 const char *zFile = 0; 4539 ZipfileTab *pNew = 0; 4540 int rc; 4541 4542 /* If the table name is not "zipfile", require that the argument be 4543 ** specified. This stops zipfile tables from being created as: 4544 ** 4545 ** CREATE VIRTUAL TABLE zzz USING zipfile(); 4546 ** 4547 ** It does not prevent: 4548 ** 4549 ** CREATE VIRTUAL TABLE zipfile USING zipfile(); 4550 */ 4551 assert( 0==sqlite3_stricmp(argv[0], "zipfile") ); 4552 if( (0!=sqlite3_stricmp(argv[2], "zipfile") && argc<4) || argc>4 ){ 4553 *pzErr = sqlite3_mprintf("zipfile constructor requires one argument"); 4554 return SQLITE_ERROR; 4555 } 4556 4557 if( argc>3 ){ 4558 zFile = argv[3]; 4559 nFile = (int)strlen(zFile)+1; 4560 } 4561 4562 rc = sqlite3_declare_vtab(db, ZIPFILE_SCHEMA); 4563 if( rc==SQLITE_OK ){ 4564 pNew = (ZipfileTab*)sqlite3_malloc64((sqlite3_int64)nByte+nFile); 4565 if( pNew==0 ) return SQLITE_NOMEM; 4566 memset(pNew, 0, nByte+nFile); 4567 pNew->db = db; 4568 pNew->aBuffer = (u8*)&pNew[1]; 4569 if( zFile ){ 4570 pNew->zFile = (char*)&pNew->aBuffer[ZIPFILE_BUFFER_SIZE]; 4571 memcpy(pNew->zFile, zFile, nFile); 4572 zipfileDequote(pNew->zFile); 4573 } 4574 } 4575 *ppVtab = (sqlite3_vtab*)pNew; 4576 return rc; 4577 } 4578 4579 /* 4580 ** Free the ZipfileEntry structure indicated by the only argument. 4581 */ 4582 static void zipfileEntryFree(ZipfileEntry *p){ 4583 if( p ){ 4584 sqlite3_free(p->cds.zFile); 4585 sqlite3_free(p); 4586 } 4587 } 4588 4589 /* 4590 ** Release resources that should be freed at the end of a write 4591 ** transaction. 4592 */ 4593 static void zipfileCleanupTransaction(ZipfileTab *pTab){ 4594 ZipfileEntry *pEntry; 4595 ZipfileEntry *pNext; 4596 4597 if( pTab->pWriteFd ){ 4598 fclose(pTab->pWriteFd); 4599 pTab->pWriteFd = 0; 4600 } 4601 for(pEntry=pTab->pFirstEntry; pEntry; pEntry=pNext){ 4602 pNext = pEntry->pNext; 4603 zipfileEntryFree(pEntry); 4604 } 4605 pTab->pFirstEntry = 0; 4606 pTab->pLastEntry = 0; 4607 pTab->szCurrent = 0; 4608 pTab->szOrig = 0; 4609 } 4610 4611 /* 4612 ** This method is the destructor for zipfile vtab objects. 4613 */ 4614 static int zipfileDisconnect(sqlite3_vtab *pVtab){ 4615 zipfileCleanupTransaction((ZipfileTab*)pVtab); 4616 sqlite3_free(pVtab); 4617 return SQLITE_OK; 4618 } 4619 4620 /* 4621 ** Constructor for a new ZipfileCsr object. 4622 */ 4623 static int zipfileOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCsr){ 4624 ZipfileTab *pTab = (ZipfileTab*)p; 4625 ZipfileCsr *pCsr; 4626 pCsr = sqlite3_malloc(sizeof(*pCsr)); 4627 *ppCsr = (sqlite3_vtab_cursor*)pCsr; 4628 if( pCsr==0 ){ 4629 return SQLITE_NOMEM; 4630 } 4631 memset(pCsr, 0, sizeof(*pCsr)); 4632 pCsr->iId = ++pTab->iNextCsrid; 4633 pCsr->pCsrNext = pTab->pCsrList; 4634 pTab->pCsrList = pCsr; 4635 return SQLITE_OK; 4636 } 4637 4638 /* 4639 ** Reset a cursor back to the state it was in when first returned 4640 ** by zipfileOpen(). 4641 */ 4642 static void zipfileResetCursor(ZipfileCsr *pCsr){ 4643 ZipfileEntry *p; 4644 ZipfileEntry *pNext; 4645 4646 pCsr->bEof = 0; 4647 if( pCsr->pFile ){ 4648 fclose(pCsr->pFile); 4649 pCsr->pFile = 0; 4650 zipfileEntryFree(pCsr->pCurrent); 4651 pCsr->pCurrent = 0; 4652 } 4653 4654 for(p=pCsr->pFreeEntry; p; p=pNext){ 4655 pNext = p->pNext; 4656 zipfileEntryFree(p); 4657 } 4658 } 4659 4660 /* 4661 ** Destructor for an ZipfileCsr. 4662 */ 4663 static int zipfileClose(sqlite3_vtab_cursor *cur){ 4664 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 4665 ZipfileTab *pTab = (ZipfileTab*)(pCsr->base.pVtab); 4666 ZipfileCsr **pp; 4667 zipfileResetCursor(pCsr); 4668 4669 /* Remove this cursor from the ZipfileTab.pCsrList list. */ 4670 for(pp=&pTab->pCsrList; *pp!=pCsr; pp=&((*pp)->pCsrNext)); 4671 *pp = pCsr->pCsrNext; 4672 4673 sqlite3_free(pCsr); 4674 return SQLITE_OK; 4675 } 4676 4677 /* 4678 ** Set the error message for the virtual table associated with cursor 4679 ** pCsr to the results of vprintf(zFmt, ...). 4680 */ 4681 static void zipfileTableErr(ZipfileTab *pTab, const char *zFmt, ...){ 4682 va_list ap; 4683 va_start(ap, zFmt); 4684 sqlite3_free(pTab->base.zErrMsg); 4685 pTab->base.zErrMsg = sqlite3_vmprintf(zFmt, ap); 4686 va_end(ap); 4687 } 4688 static void zipfileCursorErr(ZipfileCsr *pCsr, const char *zFmt, ...){ 4689 va_list ap; 4690 va_start(ap, zFmt); 4691 sqlite3_free(pCsr->base.pVtab->zErrMsg); 4692 pCsr->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap); 4693 va_end(ap); 4694 } 4695 4696 /* 4697 ** Read nRead bytes of data from offset iOff of file pFile into buffer 4698 ** aRead[]. Return SQLITE_OK if successful, or an SQLite error code 4699 ** otherwise. 4700 ** 4701 ** If an error does occur, output variable (*pzErrmsg) may be set to point 4702 ** to an English language error message. It is the responsibility of the 4703 ** caller to eventually free this buffer using 4704 ** sqlite3_free(). 4705 */ 4706 static int zipfileReadData( 4707 FILE *pFile, /* Read from this file */ 4708 u8 *aRead, /* Read into this buffer */ 4709 int nRead, /* Number of bytes to read */ 4710 i64 iOff, /* Offset to read from */ 4711 char **pzErrmsg /* OUT: Error message (from sqlite3_malloc) */ 4712 ){ 4713 size_t n; 4714 fseek(pFile, (long)iOff, SEEK_SET); 4715 n = fread(aRead, 1, nRead, pFile); 4716 if( (int)n!=nRead ){ 4717 *pzErrmsg = sqlite3_mprintf("error in fread()"); 4718 return SQLITE_ERROR; 4719 } 4720 return SQLITE_OK; 4721 } 4722 4723 static int zipfileAppendData( 4724 ZipfileTab *pTab, 4725 const u8 *aWrite, 4726 int nWrite 4727 ){ 4728 size_t n; 4729 fseek(pTab->pWriteFd, (long)pTab->szCurrent, SEEK_SET); 4730 n = fwrite(aWrite, 1, nWrite, pTab->pWriteFd); 4731 if( (int)n!=nWrite ){ 4732 pTab->base.zErrMsg = sqlite3_mprintf("error in fwrite()"); 4733 return SQLITE_ERROR; 4734 } 4735 pTab->szCurrent += nWrite; 4736 return SQLITE_OK; 4737 } 4738 4739 /* 4740 ** Read and return a 16-bit little-endian unsigned integer from buffer aBuf. 4741 */ 4742 static u16 zipfileGetU16(const u8 *aBuf){ 4743 return (aBuf[1] << 8) + aBuf[0]; 4744 } 4745 4746 /* 4747 ** Read and return a 32-bit little-endian unsigned integer from buffer aBuf. 4748 */ 4749 static u32 zipfileGetU32(const u8 *aBuf){ 4750 return ((u32)(aBuf[3]) << 24) 4751 + ((u32)(aBuf[2]) << 16) 4752 + ((u32)(aBuf[1]) << 8) 4753 + ((u32)(aBuf[0]) << 0); 4754 } 4755 4756 /* 4757 ** Write a 16-bit little endiate integer into buffer aBuf. 4758 */ 4759 static void zipfilePutU16(u8 *aBuf, u16 val){ 4760 aBuf[0] = val & 0xFF; 4761 aBuf[1] = (val>>8) & 0xFF; 4762 } 4763 4764 /* 4765 ** Write a 32-bit little endiate integer into buffer aBuf. 4766 */ 4767 static void zipfilePutU32(u8 *aBuf, u32 val){ 4768 aBuf[0] = val & 0xFF; 4769 aBuf[1] = (val>>8) & 0xFF; 4770 aBuf[2] = (val>>16) & 0xFF; 4771 aBuf[3] = (val>>24) & 0xFF; 4772 } 4773 4774 #define zipfileRead32(aBuf) ( aBuf+=4, zipfileGetU32(aBuf-4) ) 4775 #define zipfileRead16(aBuf) ( aBuf+=2, zipfileGetU16(aBuf-2) ) 4776 4777 #define zipfileWrite32(aBuf,val) { zipfilePutU32(aBuf,val); aBuf+=4; } 4778 #define zipfileWrite16(aBuf,val) { zipfilePutU16(aBuf,val); aBuf+=2; } 4779 4780 /* 4781 ** Magic numbers used to read CDS records. 4782 */ 4783 #define ZIPFILE_CDS_NFILE_OFF 28 4784 #define ZIPFILE_CDS_SZCOMPRESSED_OFF 20 4785 4786 /* 4787 ** Decode the CDS record in buffer aBuf into (*pCDS). Return SQLITE_ERROR 4788 ** if the record is not well-formed, or SQLITE_OK otherwise. 4789 */ 4790 static int zipfileReadCDS(u8 *aBuf, ZipfileCDS *pCDS){ 4791 u8 *aRead = aBuf; 4792 u32 sig = zipfileRead32(aRead); 4793 int rc = SQLITE_OK; 4794 if( sig!=ZIPFILE_SIGNATURE_CDS ){ 4795 rc = SQLITE_ERROR; 4796 }else{ 4797 pCDS->iVersionMadeBy = zipfileRead16(aRead); 4798 pCDS->iVersionExtract = zipfileRead16(aRead); 4799 pCDS->flags = zipfileRead16(aRead); 4800 pCDS->iCompression = zipfileRead16(aRead); 4801 pCDS->mTime = zipfileRead16(aRead); 4802 pCDS->mDate = zipfileRead16(aRead); 4803 pCDS->crc32 = zipfileRead32(aRead); 4804 pCDS->szCompressed = zipfileRead32(aRead); 4805 pCDS->szUncompressed = zipfileRead32(aRead); 4806 assert( aRead==&aBuf[ZIPFILE_CDS_NFILE_OFF] ); 4807 pCDS->nFile = zipfileRead16(aRead); 4808 pCDS->nExtra = zipfileRead16(aRead); 4809 pCDS->nComment = zipfileRead16(aRead); 4810 pCDS->iDiskStart = zipfileRead16(aRead); 4811 pCDS->iInternalAttr = zipfileRead16(aRead); 4812 pCDS->iExternalAttr = zipfileRead32(aRead); 4813 pCDS->iOffset = zipfileRead32(aRead); 4814 assert( aRead==&aBuf[ZIPFILE_CDS_FIXED_SZ] ); 4815 } 4816 4817 return rc; 4818 } 4819 4820 /* 4821 ** Decode the LFH record in buffer aBuf into (*pLFH). Return SQLITE_ERROR 4822 ** if the record is not well-formed, or SQLITE_OK otherwise. 4823 */ 4824 static int zipfileReadLFH( 4825 u8 *aBuffer, 4826 ZipfileLFH *pLFH 4827 ){ 4828 u8 *aRead = aBuffer; 4829 int rc = SQLITE_OK; 4830 4831 u32 sig = zipfileRead32(aRead); 4832 if( sig!=ZIPFILE_SIGNATURE_LFH ){ 4833 rc = SQLITE_ERROR; 4834 }else{ 4835 pLFH->iVersionExtract = zipfileRead16(aRead); 4836 pLFH->flags = zipfileRead16(aRead); 4837 pLFH->iCompression = zipfileRead16(aRead); 4838 pLFH->mTime = zipfileRead16(aRead); 4839 pLFH->mDate = zipfileRead16(aRead); 4840 pLFH->crc32 = zipfileRead32(aRead); 4841 pLFH->szCompressed = zipfileRead32(aRead); 4842 pLFH->szUncompressed = zipfileRead32(aRead); 4843 pLFH->nFile = zipfileRead16(aRead); 4844 pLFH->nExtra = zipfileRead16(aRead); 4845 } 4846 return rc; 4847 } 4848 4849 4850 /* 4851 ** Buffer aExtra (size nExtra bytes) contains zip archive "extra" fields. 4852 ** Scan through this buffer to find an "extra-timestamp" field. If one 4853 ** exists, extract the 32-bit modification-timestamp from it and store 4854 ** the value in output parameter *pmTime. 4855 ** 4856 ** Zero is returned if no extra-timestamp record could be found (and so 4857 ** *pmTime is left unchanged), or non-zero otherwise. 4858 ** 4859 ** The general format of an extra field is: 4860 ** 4861 ** Header ID 2 bytes 4862 ** Data Size 2 bytes 4863 ** Data N bytes 4864 */ 4865 static int zipfileScanExtra(u8 *aExtra, int nExtra, u32 *pmTime){ 4866 int ret = 0; 4867 u8 *p = aExtra; 4868 u8 *pEnd = &aExtra[nExtra]; 4869 4870 while( p<pEnd ){ 4871 u16 id = zipfileRead16(p); 4872 u16 nByte = zipfileRead16(p); 4873 4874 switch( id ){ 4875 case ZIPFILE_EXTRA_TIMESTAMP: { 4876 u8 b = p[0]; 4877 if( b & 0x01 ){ /* 0x01 -> modtime is present */ 4878 *pmTime = zipfileGetU32(&p[1]); 4879 ret = 1; 4880 } 4881 break; 4882 } 4883 } 4884 4885 p += nByte; 4886 } 4887 return ret; 4888 } 4889 4890 /* 4891 ** Convert the standard MS-DOS timestamp stored in the mTime and mDate 4892 ** fields of the CDS structure passed as the only argument to a 32-bit 4893 ** UNIX seconds-since-the-epoch timestamp. Return the result. 4894 ** 4895 ** "Standard" MS-DOS time format: 4896 ** 4897 ** File modification time: 4898 ** Bits 00-04: seconds divided by 2 4899 ** Bits 05-10: minute 4900 ** Bits 11-15: hour 4901 ** File modification date: 4902 ** Bits 00-04: day 4903 ** Bits 05-08: month (1-12) 4904 ** Bits 09-15: years from 1980 4905 ** 4906 ** https://msdn.microsoft.com/en-us/library/9kkf9tah.aspx 4907 */ 4908 static u32 zipfileMtime(ZipfileCDS *pCDS){ 4909 int Y = (1980 + ((pCDS->mDate >> 9) & 0x7F)); 4910 int M = ((pCDS->mDate >> 5) & 0x0F); 4911 int D = (pCDS->mDate & 0x1F); 4912 int B = -13; 4913 4914 int sec = (pCDS->mTime & 0x1F)*2; 4915 int min = (pCDS->mTime >> 5) & 0x3F; 4916 int hr = (pCDS->mTime >> 11) & 0x1F; 4917 i64 JD; 4918 4919 /* JD = INT(365.25 * (Y+4716)) + INT(30.6001 * (M+1)) + D + B - 1524.5 */ 4920 4921 /* Calculate the JD in seconds for noon on the day in question */ 4922 if( M<3 ){ 4923 Y = Y-1; 4924 M = M+12; 4925 } 4926 JD = (i64)(24*60*60) * ( 4927 (int)(365.25 * (Y + 4716)) 4928 + (int)(30.6001 * (M + 1)) 4929 + D + B - 1524 4930 ); 4931 4932 /* Correct the JD for the time within the day */ 4933 JD += (hr-12) * 3600 + min * 60 + sec; 4934 4935 /* Convert JD to unix timestamp (the JD epoch is 2440587.5) */ 4936 return (u32)(JD - (i64)(24405875) * 24*60*6); 4937 } 4938 4939 /* 4940 ** The opposite of zipfileMtime(). This function populates the mTime and 4941 ** mDate fields of the CDS structure passed as the first argument according 4942 ** to the UNIX timestamp value passed as the second. 4943 */ 4944 static void zipfileMtimeToDos(ZipfileCDS *pCds, u32 mUnixTime){ 4945 /* Convert unix timestamp to JD (2440588 is noon on 1/1/1970) */ 4946 i64 JD = (i64)2440588 + mUnixTime / (24*60*60); 4947 4948 int A, B, C, D, E; 4949 int yr, mon, day; 4950 int hr, min, sec; 4951 4952 A = (int)((JD - 1867216.25)/36524.25); 4953 A = (int)(JD + 1 + A - (A/4)); 4954 B = A + 1524; 4955 C = (int)((B - 122.1)/365.25); 4956 D = (36525*(C&32767))/100; 4957 E = (int)((B-D)/30.6001); 4958 4959 day = B - D - (int)(30.6001*E); 4960 mon = (E<14 ? E-1 : E-13); 4961 yr = mon>2 ? C-4716 : C-4715; 4962 4963 hr = (mUnixTime % (24*60*60)) / (60*60); 4964 min = (mUnixTime % (60*60)) / 60; 4965 sec = (mUnixTime % 60); 4966 4967 if( yr>=1980 ){ 4968 pCds->mDate = (u16)(day + (mon << 5) + ((yr-1980) << 9)); 4969 pCds->mTime = (u16)(sec/2 + (min<<5) + (hr<<11)); 4970 }else{ 4971 pCds->mDate = pCds->mTime = 0; 4972 } 4973 4974 assert( mUnixTime<315507600 4975 || mUnixTime==zipfileMtime(pCds) 4976 || ((mUnixTime % 2) && mUnixTime-1==zipfileMtime(pCds)) 4977 /* || (mUnixTime % 2) */ 4978 ); 4979 } 4980 4981 /* 4982 ** If aBlob is not NULL, then it is a pointer to a buffer (nBlob bytes in 4983 ** size) containing an entire zip archive image. Or, if aBlob is NULL, 4984 ** then pFile is a file-handle open on a zip file. In either case, this 4985 ** function creates a ZipfileEntry object based on the zip archive entry 4986 ** for which the CDS record is at offset iOff. 4987 ** 4988 ** If successful, SQLITE_OK is returned and (*ppEntry) set to point to 4989 ** the new object. Otherwise, an SQLite error code is returned and the 4990 ** final value of (*ppEntry) undefined. 4991 */ 4992 static int zipfileGetEntry( 4993 ZipfileTab *pTab, /* Store any error message here */ 4994 const u8 *aBlob, /* Pointer to in-memory file image */ 4995 int nBlob, /* Size of aBlob[] in bytes */ 4996 FILE *pFile, /* If aBlob==0, read from this file */ 4997 i64 iOff, /* Offset of CDS record */ 4998 ZipfileEntry **ppEntry /* OUT: Pointer to new object */ 4999 ){ 5000 u8 *aRead; 5001 char **pzErr = &pTab->base.zErrMsg; 5002 int rc = SQLITE_OK; 5003 5004 if( aBlob==0 ){ 5005 aRead = pTab->aBuffer; 5006 rc = zipfileReadData(pFile, aRead, ZIPFILE_CDS_FIXED_SZ, iOff, pzErr); 5007 }else{ 5008 aRead = (u8*)&aBlob[iOff]; 5009 } 5010 5011 if( rc==SQLITE_OK ){ 5012 sqlite3_int64 nAlloc; 5013 ZipfileEntry *pNew; 5014 5015 int nFile = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF]); 5016 int nExtra = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+2]); 5017 nExtra += zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+4]); 5018 5019 nAlloc = sizeof(ZipfileEntry) + nExtra; 5020 if( aBlob ){ 5021 nAlloc += zipfileGetU32(&aRead[ZIPFILE_CDS_SZCOMPRESSED_OFF]); 5022 } 5023 5024 pNew = (ZipfileEntry*)sqlite3_malloc64(nAlloc); 5025 if( pNew==0 ){ 5026 rc = SQLITE_NOMEM; 5027 }else{ 5028 memset(pNew, 0, sizeof(ZipfileEntry)); 5029 rc = zipfileReadCDS(aRead, &pNew->cds); 5030 if( rc!=SQLITE_OK ){ 5031 *pzErr = sqlite3_mprintf("failed to read CDS at offset %lld", iOff); 5032 }else if( aBlob==0 ){ 5033 rc = zipfileReadData( 5034 pFile, aRead, nExtra+nFile, iOff+ZIPFILE_CDS_FIXED_SZ, pzErr 5035 ); 5036 }else{ 5037 aRead = (u8*)&aBlob[iOff + ZIPFILE_CDS_FIXED_SZ]; 5038 } 5039 } 5040 5041 if( rc==SQLITE_OK ){ 5042 u32 *pt = &pNew->mUnixTime; 5043 pNew->cds.zFile = sqlite3_mprintf("%.*s", nFile, aRead); 5044 pNew->aExtra = (u8*)&pNew[1]; 5045 memcpy(pNew->aExtra, &aRead[nFile], nExtra); 5046 if( pNew->cds.zFile==0 ){ 5047 rc = SQLITE_NOMEM; 5048 }else if( 0==zipfileScanExtra(&aRead[nFile], pNew->cds.nExtra, pt) ){ 5049 pNew->mUnixTime = zipfileMtime(&pNew->cds); 5050 } 5051 } 5052 5053 if( rc==SQLITE_OK ){ 5054 static const int szFix = ZIPFILE_LFH_FIXED_SZ; 5055 ZipfileLFH lfh; 5056 if( pFile ){ 5057 rc = zipfileReadData(pFile, aRead, szFix, pNew->cds.iOffset, pzErr); 5058 }else{ 5059 aRead = (u8*)&aBlob[pNew->cds.iOffset]; 5060 } 5061 5062 rc = zipfileReadLFH(aRead, &lfh); 5063 if( rc==SQLITE_OK ){ 5064 pNew->iDataOff = pNew->cds.iOffset + ZIPFILE_LFH_FIXED_SZ; 5065 pNew->iDataOff += lfh.nFile + lfh.nExtra; 5066 if( aBlob && pNew->cds.szCompressed ){ 5067 pNew->aData = &pNew->aExtra[nExtra]; 5068 memcpy(pNew->aData, &aBlob[pNew->iDataOff], pNew->cds.szCompressed); 5069 } 5070 }else{ 5071 *pzErr = sqlite3_mprintf("failed to read LFH at offset %d", 5072 (int)pNew->cds.iOffset 5073 ); 5074 } 5075 } 5076 5077 if( rc!=SQLITE_OK ){ 5078 zipfileEntryFree(pNew); 5079 }else{ 5080 *ppEntry = pNew; 5081 } 5082 } 5083 5084 return rc; 5085 } 5086 5087 /* 5088 ** Advance an ZipfileCsr to its next row of output. 5089 */ 5090 static int zipfileNext(sqlite3_vtab_cursor *cur){ 5091 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5092 int rc = SQLITE_OK; 5093 5094 if( pCsr->pFile ){ 5095 i64 iEof = pCsr->eocd.iOffset + pCsr->eocd.nSize; 5096 zipfileEntryFree(pCsr->pCurrent); 5097 pCsr->pCurrent = 0; 5098 if( pCsr->iNextOff>=iEof ){ 5099 pCsr->bEof = 1; 5100 }else{ 5101 ZipfileEntry *p = 0; 5102 ZipfileTab *pTab = (ZipfileTab*)(cur->pVtab); 5103 rc = zipfileGetEntry(pTab, 0, 0, pCsr->pFile, pCsr->iNextOff, &p); 5104 if( rc==SQLITE_OK ){ 5105 pCsr->iNextOff += ZIPFILE_CDS_FIXED_SZ; 5106 pCsr->iNextOff += (int)p->cds.nExtra + p->cds.nFile + p->cds.nComment; 5107 } 5108 pCsr->pCurrent = p; 5109 } 5110 }else{ 5111 if( !pCsr->bNoop ){ 5112 pCsr->pCurrent = pCsr->pCurrent->pNext; 5113 } 5114 if( pCsr->pCurrent==0 ){ 5115 pCsr->bEof = 1; 5116 } 5117 } 5118 5119 pCsr->bNoop = 0; 5120 return rc; 5121 } 5122 5123 static void zipfileFree(void *p) { 5124 sqlite3_free(p); 5125 } 5126 5127 /* 5128 ** Buffer aIn (size nIn bytes) contains compressed data. Uncompressed, the 5129 ** size is nOut bytes. This function uncompresses the data and sets the 5130 ** return value in context pCtx to the result (a blob). 5131 ** 5132 ** If an error occurs, an error code is left in pCtx instead. 5133 */ 5134 static void zipfileInflate( 5135 sqlite3_context *pCtx, /* Store result here */ 5136 const u8 *aIn, /* Compressed data */ 5137 int nIn, /* Size of buffer aIn[] in bytes */ 5138 int nOut /* Expected output size */ 5139 ){ 5140 u8 *aRes = sqlite3_malloc(nOut); 5141 if( aRes==0 ){ 5142 sqlite3_result_error_nomem(pCtx); 5143 }else{ 5144 int err; 5145 z_stream str; 5146 memset(&str, 0, sizeof(str)); 5147 5148 str.next_in = (Byte*)aIn; 5149 str.avail_in = nIn; 5150 str.next_out = (Byte*)aRes; 5151 str.avail_out = nOut; 5152 5153 err = inflateInit2(&str, -15); 5154 if( err!=Z_OK ){ 5155 zipfileCtxErrorMsg(pCtx, "inflateInit2() failed (%d)", err); 5156 }else{ 5157 err = inflate(&str, Z_NO_FLUSH); 5158 if( err!=Z_STREAM_END ){ 5159 zipfileCtxErrorMsg(pCtx, "inflate() failed (%d)", err); 5160 }else{ 5161 sqlite3_result_blob(pCtx, aRes, nOut, zipfileFree); 5162 aRes = 0; 5163 } 5164 } 5165 sqlite3_free(aRes); 5166 inflateEnd(&str); 5167 } 5168 } 5169 5170 /* 5171 ** Buffer aIn (size nIn bytes) contains uncompressed data. This function 5172 ** compresses it and sets (*ppOut) to point to a buffer containing the 5173 ** compressed data. The caller is responsible for eventually calling 5174 ** sqlite3_free() to release buffer (*ppOut). Before returning, (*pnOut) 5175 ** is set to the size of buffer (*ppOut) in bytes. 5176 ** 5177 ** If no error occurs, SQLITE_OK is returned. Otherwise, an SQLite error 5178 ** code is returned and an error message left in virtual-table handle 5179 ** pTab. The values of (*ppOut) and (*pnOut) are left unchanged in this 5180 ** case. 5181 */ 5182 static int zipfileDeflate( 5183 const u8 *aIn, int nIn, /* Input */ 5184 u8 **ppOut, int *pnOut, /* Output */ 5185 char **pzErr /* OUT: Error message */ 5186 ){ 5187 sqlite3_int64 nAlloc = compressBound(nIn); 5188 u8 *aOut; 5189 int rc = SQLITE_OK; 5190 5191 aOut = (u8*)sqlite3_malloc64(nAlloc); 5192 if( aOut==0 ){ 5193 rc = SQLITE_NOMEM; 5194 }else{ 5195 int res; 5196 z_stream str; 5197 memset(&str, 0, sizeof(str)); 5198 str.next_in = (Bytef*)aIn; 5199 str.avail_in = nIn; 5200 str.next_out = aOut; 5201 str.avail_out = nAlloc; 5202 5203 deflateInit2(&str, 9, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY); 5204 res = deflate(&str, Z_FINISH); 5205 5206 if( res==Z_STREAM_END ){ 5207 *ppOut = aOut; 5208 *pnOut = (int)str.total_out; 5209 }else{ 5210 sqlite3_free(aOut); 5211 *pzErr = sqlite3_mprintf("zipfile: deflate() error"); 5212 rc = SQLITE_ERROR; 5213 } 5214 deflateEnd(&str); 5215 } 5216 5217 return rc; 5218 } 5219 5220 5221 /* 5222 ** Return values of columns for the row at which the series_cursor 5223 ** is currently pointing. 5224 */ 5225 static int zipfileColumn( 5226 sqlite3_vtab_cursor *cur, /* The cursor */ 5227 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 5228 int i /* Which column to return */ 5229 ){ 5230 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5231 ZipfileCDS *pCDS = &pCsr->pCurrent->cds; 5232 int rc = SQLITE_OK; 5233 switch( i ){ 5234 case 0: /* name */ 5235 sqlite3_result_text(ctx, pCDS->zFile, -1, SQLITE_TRANSIENT); 5236 break; 5237 case 1: /* mode */ 5238 /* TODO: Whether or not the following is correct surely depends on 5239 ** the platform on which the archive was created. */ 5240 sqlite3_result_int(ctx, pCDS->iExternalAttr >> 16); 5241 break; 5242 case 2: { /* mtime */ 5243 sqlite3_result_int64(ctx, pCsr->pCurrent->mUnixTime); 5244 break; 5245 } 5246 case 3: { /* sz */ 5247 if( sqlite3_vtab_nochange(ctx)==0 ){ 5248 sqlite3_result_int64(ctx, pCDS->szUncompressed); 5249 } 5250 break; 5251 } 5252 case 4: /* rawdata */ 5253 if( sqlite3_vtab_nochange(ctx) ) break; 5254 case 5: { /* data */ 5255 if( i==4 || pCDS->iCompression==0 || pCDS->iCompression==8 ){ 5256 int sz = pCDS->szCompressed; 5257 int szFinal = pCDS->szUncompressed; 5258 if( szFinal>0 ){ 5259 u8 *aBuf; 5260 u8 *aFree = 0; 5261 if( pCsr->pCurrent->aData ){ 5262 aBuf = pCsr->pCurrent->aData; 5263 }else{ 5264 aBuf = aFree = sqlite3_malloc64(sz); 5265 if( aBuf==0 ){ 5266 rc = SQLITE_NOMEM; 5267 }else{ 5268 FILE *pFile = pCsr->pFile; 5269 if( pFile==0 ){ 5270 pFile = ((ZipfileTab*)(pCsr->base.pVtab))->pWriteFd; 5271 } 5272 rc = zipfileReadData(pFile, aBuf, sz, pCsr->pCurrent->iDataOff, 5273 &pCsr->base.pVtab->zErrMsg 5274 ); 5275 } 5276 } 5277 if( rc==SQLITE_OK ){ 5278 if( i==5 && pCDS->iCompression ){ 5279 zipfileInflate(ctx, aBuf, sz, szFinal); 5280 }else{ 5281 sqlite3_result_blob(ctx, aBuf, sz, SQLITE_TRANSIENT); 5282 } 5283 } 5284 sqlite3_free(aFree); 5285 }else{ 5286 /* Figure out if this is a directory or a zero-sized file. Consider 5287 ** it to be a directory either if the mode suggests so, or if 5288 ** the final character in the name is '/'. */ 5289 u32 mode = pCDS->iExternalAttr >> 16; 5290 if( !(mode & S_IFDIR) && pCDS->zFile[pCDS->nFile-1]!='/' ){ 5291 sqlite3_result_blob(ctx, "", 0, SQLITE_STATIC); 5292 } 5293 } 5294 } 5295 break; 5296 } 5297 case 6: /* method */ 5298 sqlite3_result_int(ctx, pCDS->iCompression); 5299 break; 5300 default: /* z */ 5301 assert( i==7 ); 5302 sqlite3_result_int64(ctx, pCsr->iId); 5303 break; 5304 } 5305 5306 return rc; 5307 } 5308 5309 /* 5310 ** Return TRUE if the cursor is at EOF. 5311 */ 5312 static int zipfileEof(sqlite3_vtab_cursor *cur){ 5313 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5314 return pCsr->bEof; 5315 } 5316 5317 /* 5318 ** If aBlob is not NULL, then it points to a buffer nBlob bytes in size 5319 ** containing an entire zip archive image. Or, if aBlob is NULL, then pFile 5320 ** is guaranteed to be a file-handle open on a zip file. 5321 ** 5322 ** This function attempts to locate the EOCD record within the zip archive 5323 ** and populate *pEOCD with the results of decoding it. SQLITE_OK is 5324 ** returned if successful. Otherwise, an SQLite error code is returned and 5325 ** an English language error message may be left in virtual-table pTab. 5326 */ 5327 static int zipfileReadEOCD( 5328 ZipfileTab *pTab, /* Return errors here */ 5329 const u8 *aBlob, /* Pointer to in-memory file image */ 5330 int nBlob, /* Size of aBlob[] in bytes */ 5331 FILE *pFile, /* Read from this file if aBlob==0 */ 5332 ZipfileEOCD *pEOCD /* Object to populate */ 5333 ){ 5334 u8 *aRead = pTab->aBuffer; /* Temporary buffer */ 5335 int nRead; /* Bytes to read from file */ 5336 int rc = SQLITE_OK; 5337 5338 if( aBlob==0 ){ 5339 i64 iOff; /* Offset to read from */ 5340 i64 szFile; /* Total size of file in bytes */ 5341 fseek(pFile, 0, SEEK_END); 5342 szFile = (i64)ftell(pFile); 5343 if( szFile==0 ){ 5344 memset(pEOCD, 0, sizeof(ZipfileEOCD)); 5345 return SQLITE_OK; 5346 } 5347 nRead = (int)(MIN(szFile, ZIPFILE_BUFFER_SIZE)); 5348 iOff = szFile - nRead; 5349 rc = zipfileReadData(pFile, aRead, nRead, iOff, &pTab->base.zErrMsg); 5350 }else{ 5351 nRead = (int)(MIN(nBlob, ZIPFILE_BUFFER_SIZE)); 5352 aRead = (u8*)&aBlob[nBlob-nRead]; 5353 } 5354 5355 if( rc==SQLITE_OK ){ 5356 int i; 5357 5358 /* Scan backwards looking for the signature bytes */ 5359 for(i=nRead-20; i>=0; i--){ 5360 if( aRead[i]==0x50 && aRead[i+1]==0x4b 5361 && aRead[i+2]==0x05 && aRead[i+3]==0x06 5362 ){ 5363 break; 5364 } 5365 } 5366 if( i<0 ){ 5367 pTab->base.zErrMsg = sqlite3_mprintf( 5368 "cannot find end of central directory record" 5369 ); 5370 return SQLITE_ERROR; 5371 } 5372 5373 aRead += i+4; 5374 pEOCD->iDisk = zipfileRead16(aRead); 5375 pEOCD->iFirstDisk = zipfileRead16(aRead); 5376 pEOCD->nEntry = zipfileRead16(aRead); 5377 pEOCD->nEntryTotal = zipfileRead16(aRead); 5378 pEOCD->nSize = zipfileRead32(aRead); 5379 pEOCD->iOffset = zipfileRead32(aRead); 5380 } 5381 5382 return rc; 5383 } 5384 5385 /* 5386 ** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry 5387 ** and ends with pLastEntry. If argument pBefore is NULL, then pNew is added 5388 ** to the end of the list. Otherwise, it is added to the list immediately 5389 ** before pBefore (which is guaranteed to be a part of said list). 5390 */ 5391 static void zipfileAddEntry( 5392 ZipfileTab *pTab, 5393 ZipfileEntry *pBefore, 5394 ZipfileEntry *pNew 5395 ){ 5396 assert( (pTab->pFirstEntry==0)==(pTab->pLastEntry==0) ); 5397 assert( pNew->pNext==0 ); 5398 if( pBefore==0 ){ 5399 if( pTab->pFirstEntry==0 ){ 5400 pTab->pFirstEntry = pTab->pLastEntry = pNew; 5401 }else{ 5402 assert( pTab->pLastEntry->pNext==0 ); 5403 pTab->pLastEntry->pNext = pNew; 5404 pTab->pLastEntry = pNew; 5405 } 5406 }else{ 5407 ZipfileEntry **pp; 5408 for(pp=&pTab->pFirstEntry; *pp!=pBefore; pp=&((*pp)->pNext)); 5409 pNew->pNext = pBefore; 5410 *pp = pNew; 5411 } 5412 } 5413 5414 static int zipfileLoadDirectory(ZipfileTab *pTab, const u8 *aBlob, int nBlob){ 5415 ZipfileEOCD eocd; 5416 int rc; 5417 int i; 5418 i64 iOff; 5419 5420 rc = zipfileReadEOCD(pTab, aBlob, nBlob, pTab->pWriteFd, &eocd); 5421 iOff = eocd.iOffset; 5422 for(i=0; rc==SQLITE_OK && i<eocd.nEntry; i++){ 5423 ZipfileEntry *pNew = 0; 5424 rc = zipfileGetEntry(pTab, aBlob, nBlob, pTab->pWriteFd, iOff, &pNew); 5425 5426 if( rc==SQLITE_OK ){ 5427 zipfileAddEntry(pTab, 0, pNew); 5428 iOff += ZIPFILE_CDS_FIXED_SZ; 5429 iOff += (int)pNew->cds.nExtra + pNew->cds.nFile + pNew->cds.nComment; 5430 } 5431 } 5432 return rc; 5433 } 5434 5435 /* 5436 ** xFilter callback. 5437 */ 5438 static int zipfileFilter( 5439 sqlite3_vtab_cursor *cur, 5440 int idxNum, const char *idxStr, 5441 int argc, sqlite3_value **argv 5442 ){ 5443 ZipfileTab *pTab = (ZipfileTab*)cur->pVtab; 5444 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5445 const char *zFile = 0; /* Zip file to scan */ 5446 int rc = SQLITE_OK; /* Return Code */ 5447 int bInMemory = 0; /* True for an in-memory zipfile */ 5448 5449 zipfileResetCursor(pCsr); 5450 5451 if( pTab->zFile ){ 5452 zFile = pTab->zFile; 5453 }else if( idxNum==0 ){ 5454 zipfileCursorErr(pCsr, "zipfile() function requires an argument"); 5455 return SQLITE_ERROR; 5456 }else if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){ 5457 const u8 *aBlob = (const u8*)sqlite3_value_blob(argv[0]); 5458 int nBlob = sqlite3_value_bytes(argv[0]); 5459 assert( pTab->pFirstEntry==0 ); 5460 rc = zipfileLoadDirectory(pTab, aBlob, nBlob); 5461 pCsr->pFreeEntry = pTab->pFirstEntry; 5462 pTab->pFirstEntry = pTab->pLastEntry = 0; 5463 if( rc!=SQLITE_OK ) return rc; 5464 bInMemory = 1; 5465 }else{ 5466 zFile = (const char*)sqlite3_value_text(argv[0]); 5467 } 5468 5469 if( 0==pTab->pWriteFd && 0==bInMemory ){ 5470 pCsr->pFile = fopen(zFile, "rb"); 5471 if( pCsr->pFile==0 ){ 5472 zipfileCursorErr(pCsr, "cannot open file: %s", zFile); 5473 rc = SQLITE_ERROR; 5474 }else{ 5475 rc = zipfileReadEOCD(pTab, 0, 0, pCsr->pFile, &pCsr->eocd); 5476 if( rc==SQLITE_OK ){ 5477 if( pCsr->eocd.nEntry==0 ){ 5478 pCsr->bEof = 1; 5479 }else{ 5480 pCsr->iNextOff = pCsr->eocd.iOffset; 5481 rc = zipfileNext(cur); 5482 } 5483 } 5484 } 5485 }else{ 5486 pCsr->bNoop = 1; 5487 pCsr->pCurrent = pCsr->pFreeEntry ? pCsr->pFreeEntry : pTab->pFirstEntry; 5488 rc = zipfileNext(cur); 5489 } 5490 5491 return rc; 5492 } 5493 5494 /* 5495 ** xBestIndex callback. 5496 */ 5497 static int zipfileBestIndex( 5498 sqlite3_vtab *tab, 5499 sqlite3_index_info *pIdxInfo 5500 ){ 5501 int i; 5502 int idx = -1; 5503 int unusable = 0; 5504 5505 for(i=0; i<pIdxInfo->nConstraint; i++){ 5506 const struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i]; 5507 if( pCons->iColumn!=ZIPFILE_F_COLUMN_IDX ) continue; 5508 if( pCons->usable==0 ){ 5509 unusable = 1; 5510 }else if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 5511 idx = i; 5512 } 5513 } 5514 if( idx>=0 ){ 5515 pIdxInfo->aConstraintUsage[idx].argvIndex = 1; 5516 pIdxInfo->aConstraintUsage[idx].omit = 1; 5517 pIdxInfo->estimatedCost = 1000.0; 5518 pIdxInfo->idxNum = 1; 5519 }else if( unusable ){ 5520 return SQLITE_CONSTRAINT; 5521 } 5522 return SQLITE_OK; 5523 } 5524 5525 static ZipfileEntry *zipfileNewEntry(const char *zPath){ 5526 ZipfileEntry *pNew; 5527 pNew = sqlite3_malloc(sizeof(ZipfileEntry)); 5528 if( pNew ){ 5529 memset(pNew, 0, sizeof(ZipfileEntry)); 5530 pNew->cds.zFile = sqlite3_mprintf("%s", zPath); 5531 if( pNew->cds.zFile==0 ){ 5532 sqlite3_free(pNew); 5533 pNew = 0; 5534 } 5535 } 5536 return pNew; 5537 } 5538 5539 static int zipfileSerializeLFH(ZipfileEntry *pEntry, u8 *aBuf){ 5540 ZipfileCDS *pCds = &pEntry->cds; 5541 u8 *a = aBuf; 5542 5543 pCds->nExtra = 9; 5544 5545 /* Write the LFH itself */ 5546 zipfileWrite32(a, ZIPFILE_SIGNATURE_LFH); 5547 zipfileWrite16(a, pCds->iVersionExtract); 5548 zipfileWrite16(a, pCds->flags); 5549 zipfileWrite16(a, pCds->iCompression); 5550 zipfileWrite16(a, pCds->mTime); 5551 zipfileWrite16(a, pCds->mDate); 5552 zipfileWrite32(a, pCds->crc32); 5553 zipfileWrite32(a, pCds->szCompressed); 5554 zipfileWrite32(a, pCds->szUncompressed); 5555 zipfileWrite16(a, (u16)pCds->nFile); 5556 zipfileWrite16(a, pCds->nExtra); 5557 assert( a==&aBuf[ZIPFILE_LFH_FIXED_SZ] ); 5558 5559 /* Add the file name */ 5560 memcpy(a, pCds->zFile, (int)pCds->nFile); 5561 a += (int)pCds->nFile; 5562 5563 /* The "extra" data */ 5564 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP); 5565 zipfileWrite16(a, 5); 5566 *a++ = 0x01; 5567 zipfileWrite32(a, pEntry->mUnixTime); 5568 5569 return a-aBuf; 5570 } 5571 5572 static int zipfileAppendEntry( 5573 ZipfileTab *pTab, 5574 ZipfileEntry *pEntry, 5575 const u8 *pData, 5576 int nData 5577 ){ 5578 u8 *aBuf = pTab->aBuffer; 5579 int nBuf; 5580 int rc; 5581 5582 nBuf = zipfileSerializeLFH(pEntry, aBuf); 5583 rc = zipfileAppendData(pTab, aBuf, nBuf); 5584 if( rc==SQLITE_OK ){ 5585 pEntry->iDataOff = pTab->szCurrent; 5586 rc = zipfileAppendData(pTab, pData, nData); 5587 } 5588 5589 return rc; 5590 } 5591 5592 static int zipfileGetMode( 5593 sqlite3_value *pVal, 5594 int bIsDir, /* If true, default to directory */ 5595 u32 *pMode, /* OUT: Mode value */ 5596 char **pzErr /* OUT: Error message */ 5597 ){ 5598 const char *z = (const char*)sqlite3_value_text(pVal); 5599 u32 mode = 0; 5600 if( z==0 ){ 5601 mode = (bIsDir ? (S_IFDIR + 0755) : (S_IFREG + 0644)); 5602 }else if( z[0]>='0' && z[0]<='9' ){ 5603 mode = (unsigned int)sqlite3_value_int(pVal); 5604 }else{ 5605 const char zTemplate[11] = "-rwxrwxrwx"; 5606 int i; 5607 if( strlen(z)!=10 ) goto parse_error; 5608 switch( z[0] ){ 5609 case '-': mode |= S_IFREG; break; 5610 case 'd': mode |= S_IFDIR; break; 5611 case 'l': mode |= S_IFLNK; break; 5612 default: goto parse_error; 5613 } 5614 for(i=1; i<10; i++){ 5615 if( z[i]==zTemplate[i] ) mode |= 1 << (9-i); 5616 else if( z[i]!='-' ) goto parse_error; 5617 } 5618 } 5619 if( ((mode & S_IFDIR)==0)==bIsDir ){ 5620 /* The "mode" attribute is a directory, but data has been specified. 5621 ** Or vice-versa - no data but "mode" is a file or symlink. */ 5622 *pzErr = sqlite3_mprintf("zipfile: mode does not match data"); 5623 return SQLITE_CONSTRAINT; 5624 } 5625 *pMode = mode; 5626 return SQLITE_OK; 5627 5628 parse_error: 5629 *pzErr = sqlite3_mprintf("zipfile: parse error in mode: %s", z); 5630 return SQLITE_ERROR; 5631 } 5632 5633 /* 5634 ** Both (const char*) arguments point to nul-terminated strings. Argument 5635 ** nB is the value of strlen(zB). This function returns 0 if the strings are 5636 ** identical, ignoring any trailing '/' character in either path. */ 5637 static int zipfileComparePath(const char *zA, const char *zB, int nB){ 5638 int nA = (int)strlen(zA); 5639 if( zA[nA-1]=='/' ) nA--; 5640 if( zB[nB-1]=='/' ) nB--; 5641 if( nA==nB && memcmp(zA, zB, nA)==0 ) return 0; 5642 return 1; 5643 } 5644 5645 static int zipfileBegin(sqlite3_vtab *pVtab){ 5646 ZipfileTab *pTab = (ZipfileTab*)pVtab; 5647 int rc = SQLITE_OK; 5648 5649 assert( pTab->pWriteFd==0 ); 5650 5651 /* Open a write fd on the file. Also load the entire central directory 5652 ** structure into memory. During the transaction any new file data is 5653 ** appended to the archive file, but the central directory is accumulated 5654 ** in main-memory until the transaction is committed. */ 5655 pTab->pWriteFd = fopen(pTab->zFile, "ab+"); 5656 if( pTab->pWriteFd==0 ){ 5657 pTab->base.zErrMsg = sqlite3_mprintf( 5658 "zipfile: failed to open file %s for writing", pTab->zFile 5659 ); 5660 rc = SQLITE_ERROR; 5661 }else{ 5662 fseek(pTab->pWriteFd, 0, SEEK_END); 5663 pTab->szCurrent = pTab->szOrig = (i64)ftell(pTab->pWriteFd); 5664 rc = zipfileLoadDirectory(pTab, 0, 0); 5665 } 5666 5667 if( rc!=SQLITE_OK ){ 5668 zipfileCleanupTransaction(pTab); 5669 } 5670 5671 return rc; 5672 } 5673 5674 /* 5675 ** Return the current time as a 32-bit timestamp in UNIX epoch format (like 5676 ** time(2)). 5677 */ 5678 static u32 zipfileTime(void){ 5679 sqlite3_vfs *pVfs = sqlite3_vfs_find(0); 5680 u32 ret; 5681 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ 5682 i64 ms; 5683 pVfs->xCurrentTimeInt64(pVfs, &ms); 5684 ret = (u32)((ms/1000) - ((i64)24405875 * 8640)); 5685 }else{ 5686 double day; 5687 pVfs->xCurrentTime(pVfs, &day); 5688 ret = (u32)((day - 2440587.5) * 86400); 5689 } 5690 return ret; 5691 } 5692 5693 /* 5694 ** Return a 32-bit timestamp in UNIX epoch format. 5695 ** 5696 ** If the value passed as the only argument is either NULL or an SQL NULL, 5697 ** return the current time. Otherwise, return the value stored in (*pVal) 5698 ** cast to a 32-bit unsigned integer. 5699 */ 5700 static u32 zipfileGetTime(sqlite3_value *pVal){ 5701 if( pVal==0 || sqlite3_value_type(pVal)==SQLITE_NULL ){ 5702 return zipfileTime(); 5703 } 5704 return (u32)sqlite3_value_int64(pVal); 5705 } 5706 5707 /* 5708 ** Unless it is NULL, entry pOld is currently part of the pTab->pFirstEntry 5709 ** linked list. Remove it from the list and free the object. 5710 */ 5711 static void zipfileRemoveEntryFromList(ZipfileTab *pTab, ZipfileEntry *pOld){ 5712 if( pOld ){ 5713 ZipfileEntry **pp; 5714 for(pp=&pTab->pFirstEntry; (*pp)!=pOld; pp=&((*pp)->pNext)); 5715 *pp = (*pp)->pNext; 5716 zipfileEntryFree(pOld); 5717 } 5718 } 5719 5720 /* 5721 ** xUpdate method. 5722 */ 5723 static int zipfileUpdate( 5724 sqlite3_vtab *pVtab, 5725 int nVal, 5726 sqlite3_value **apVal, 5727 sqlite_int64 *pRowid 5728 ){ 5729 ZipfileTab *pTab = (ZipfileTab*)pVtab; 5730 int rc = SQLITE_OK; /* Return Code */ 5731 ZipfileEntry *pNew = 0; /* New in-memory CDS entry */ 5732 5733 u32 mode = 0; /* Mode for new entry */ 5734 u32 mTime = 0; /* Modification time for new entry */ 5735 i64 sz = 0; /* Uncompressed size */ 5736 const char *zPath = 0; /* Path for new entry */ 5737 int nPath = 0; /* strlen(zPath) */ 5738 const u8 *pData = 0; /* Pointer to buffer containing content */ 5739 int nData = 0; /* Size of pData buffer in bytes */ 5740 int iMethod = 0; /* Compression method for new entry */ 5741 u8 *pFree = 0; /* Free this */ 5742 char *zFree = 0; /* Also free this */ 5743 ZipfileEntry *pOld = 0; 5744 ZipfileEntry *pOld2 = 0; 5745 int bUpdate = 0; /* True for an update that modifies "name" */ 5746 int bIsDir = 0; 5747 u32 iCrc32 = 0; 5748 5749 if( pTab->pWriteFd==0 ){ 5750 rc = zipfileBegin(pVtab); 5751 if( rc!=SQLITE_OK ) return rc; 5752 } 5753 5754 /* If this is a DELETE or UPDATE, find the archive entry to delete. */ 5755 if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){ 5756 const char *zDelete = (const char*)sqlite3_value_text(apVal[0]); 5757 int nDelete = (int)strlen(zDelete); 5758 if( nVal>1 ){ 5759 const char *zUpdate = (const char*)sqlite3_value_text(apVal[1]); 5760 if( zUpdate && zipfileComparePath(zUpdate, zDelete, nDelete)!=0 ){ 5761 bUpdate = 1; 5762 } 5763 } 5764 for(pOld=pTab->pFirstEntry; 1; pOld=pOld->pNext){ 5765 if( zipfileComparePath(pOld->cds.zFile, zDelete, nDelete)==0 ){ 5766 break; 5767 } 5768 assert( pOld->pNext ); 5769 } 5770 } 5771 5772 if( nVal>1 ){ 5773 /* Check that "sz" and "rawdata" are both NULL: */ 5774 if( sqlite3_value_type(apVal[5])!=SQLITE_NULL ){ 5775 zipfileTableErr(pTab, "sz must be NULL"); 5776 rc = SQLITE_CONSTRAINT; 5777 } 5778 if( sqlite3_value_type(apVal[6])!=SQLITE_NULL ){ 5779 zipfileTableErr(pTab, "rawdata must be NULL"); 5780 rc = SQLITE_CONSTRAINT; 5781 } 5782 5783 if( rc==SQLITE_OK ){ 5784 if( sqlite3_value_type(apVal[7])==SQLITE_NULL ){ 5785 /* data=NULL. A directory */ 5786 bIsDir = 1; 5787 }else{ 5788 /* Value specified for "data", and possibly "method". This must be 5789 ** a regular file or a symlink. */ 5790 const u8 *aIn = sqlite3_value_blob(apVal[7]); 5791 int nIn = sqlite3_value_bytes(apVal[7]); 5792 int bAuto = sqlite3_value_type(apVal[8])==SQLITE_NULL; 5793 5794 iMethod = sqlite3_value_int(apVal[8]); 5795 sz = nIn; 5796 pData = aIn; 5797 nData = nIn; 5798 if( iMethod!=0 && iMethod!=8 ){ 5799 zipfileTableErr(pTab, "unknown compression method: %d", iMethod); 5800 rc = SQLITE_CONSTRAINT; 5801 }else{ 5802 if( bAuto || iMethod ){ 5803 int nCmp; 5804 rc = zipfileDeflate(aIn, nIn, &pFree, &nCmp, &pTab->base.zErrMsg); 5805 if( rc==SQLITE_OK ){ 5806 if( iMethod || nCmp<nIn ){ 5807 iMethod = 8; 5808 pData = pFree; 5809 nData = nCmp; 5810 } 5811 } 5812 } 5813 iCrc32 = crc32(0, aIn, nIn); 5814 } 5815 } 5816 } 5817 5818 if( rc==SQLITE_OK ){ 5819 rc = zipfileGetMode(apVal[3], bIsDir, &mode, &pTab->base.zErrMsg); 5820 } 5821 5822 if( rc==SQLITE_OK ){ 5823 zPath = (const char*)sqlite3_value_text(apVal[2]); 5824 nPath = (int)strlen(zPath); 5825 mTime = zipfileGetTime(apVal[4]); 5826 } 5827 5828 if( rc==SQLITE_OK && bIsDir ){ 5829 /* For a directory, check that the last character in the path is a 5830 ** '/'. This appears to be required for compatibility with info-zip 5831 ** (the unzip command on unix). It does not create directories 5832 ** otherwise. */ 5833 if( zPath[nPath-1]!='/' ){ 5834 zFree = sqlite3_mprintf("%s/", zPath); 5835 if( zFree==0 ){ rc = SQLITE_NOMEM; } 5836 zPath = (const char*)zFree; 5837 nPath++; 5838 } 5839 } 5840 5841 /* Check that we're not inserting a duplicate entry -OR- updating an 5842 ** entry with a path, thereby making it into a duplicate. */ 5843 if( (pOld==0 || bUpdate) && rc==SQLITE_OK ){ 5844 ZipfileEntry *p; 5845 for(p=pTab->pFirstEntry; p; p=p->pNext){ 5846 if( zipfileComparePath(p->cds.zFile, zPath, nPath)==0 ){ 5847 switch( sqlite3_vtab_on_conflict(pTab->db) ){ 5848 case SQLITE_IGNORE: { 5849 goto zipfile_update_done; 5850 } 5851 case SQLITE_REPLACE: { 5852 pOld2 = p; 5853 break; 5854 } 5855 default: { 5856 zipfileTableErr(pTab, "duplicate name: \"%s\"", zPath); 5857 rc = SQLITE_CONSTRAINT; 5858 break; 5859 } 5860 } 5861 break; 5862 } 5863 } 5864 } 5865 5866 if( rc==SQLITE_OK ){ 5867 /* Create the new CDS record. */ 5868 pNew = zipfileNewEntry(zPath); 5869 if( pNew==0 ){ 5870 rc = SQLITE_NOMEM; 5871 }else{ 5872 pNew->cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY; 5873 pNew->cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED; 5874 pNew->cds.flags = ZIPFILE_NEWENTRY_FLAGS; 5875 pNew->cds.iCompression = (u16)iMethod; 5876 zipfileMtimeToDos(&pNew->cds, mTime); 5877 pNew->cds.crc32 = iCrc32; 5878 pNew->cds.szCompressed = nData; 5879 pNew->cds.szUncompressed = (u32)sz; 5880 pNew->cds.iExternalAttr = (mode<<16); 5881 pNew->cds.iOffset = (u32)pTab->szCurrent; 5882 pNew->cds.nFile = (u16)nPath; 5883 pNew->mUnixTime = (u32)mTime; 5884 rc = zipfileAppendEntry(pTab, pNew, pData, nData); 5885 zipfileAddEntry(pTab, pOld, pNew); 5886 } 5887 } 5888 } 5889 5890 if( rc==SQLITE_OK && (pOld || pOld2) ){ 5891 ZipfileCsr *pCsr; 5892 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){ 5893 if( pCsr->pCurrent && (pCsr->pCurrent==pOld || pCsr->pCurrent==pOld2) ){ 5894 pCsr->pCurrent = pCsr->pCurrent->pNext; 5895 pCsr->bNoop = 1; 5896 } 5897 } 5898 5899 zipfileRemoveEntryFromList(pTab, pOld); 5900 zipfileRemoveEntryFromList(pTab, pOld2); 5901 } 5902 5903 zipfile_update_done: 5904 sqlite3_free(pFree); 5905 sqlite3_free(zFree); 5906 return rc; 5907 } 5908 5909 static int zipfileSerializeEOCD(ZipfileEOCD *p, u8 *aBuf){ 5910 u8 *a = aBuf; 5911 zipfileWrite32(a, ZIPFILE_SIGNATURE_EOCD); 5912 zipfileWrite16(a, p->iDisk); 5913 zipfileWrite16(a, p->iFirstDisk); 5914 zipfileWrite16(a, p->nEntry); 5915 zipfileWrite16(a, p->nEntryTotal); 5916 zipfileWrite32(a, p->nSize); 5917 zipfileWrite32(a, p->iOffset); 5918 zipfileWrite16(a, 0); /* Size of trailing comment in bytes*/ 5919 5920 return a-aBuf; 5921 } 5922 5923 static int zipfileAppendEOCD(ZipfileTab *pTab, ZipfileEOCD *p){ 5924 int nBuf = zipfileSerializeEOCD(p, pTab->aBuffer); 5925 assert( nBuf==ZIPFILE_EOCD_FIXED_SZ ); 5926 return zipfileAppendData(pTab, pTab->aBuffer, nBuf); 5927 } 5928 5929 /* 5930 ** Serialize the CDS structure into buffer aBuf[]. Return the number 5931 ** of bytes written. 5932 */ 5933 static int zipfileSerializeCDS(ZipfileEntry *pEntry, u8 *aBuf){ 5934 u8 *a = aBuf; 5935 ZipfileCDS *pCDS = &pEntry->cds; 5936 5937 if( pEntry->aExtra==0 ){ 5938 pCDS->nExtra = 9; 5939 } 5940 5941 zipfileWrite32(a, ZIPFILE_SIGNATURE_CDS); 5942 zipfileWrite16(a, pCDS->iVersionMadeBy); 5943 zipfileWrite16(a, pCDS->iVersionExtract); 5944 zipfileWrite16(a, pCDS->flags); 5945 zipfileWrite16(a, pCDS->iCompression); 5946 zipfileWrite16(a, pCDS->mTime); 5947 zipfileWrite16(a, pCDS->mDate); 5948 zipfileWrite32(a, pCDS->crc32); 5949 zipfileWrite32(a, pCDS->szCompressed); 5950 zipfileWrite32(a, pCDS->szUncompressed); 5951 assert( a==&aBuf[ZIPFILE_CDS_NFILE_OFF] ); 5952 zipfileWrite16(a, pCDS->nFile); 5953 zipfileWrite16(a, pCDS->nExtra); 5954 zipfileWrite16(a, pCDS->nComment); 5955 zipfileWrite16(a, pCDS->iDiskStart); 5956 zipfileWrite16(a, pCDS->iInternalAttr); 5957 zipfileWrite32(a, pCDS->iExternalAttr); 5958 zipfileWrite32(a, pCDS->iOffset); 5959 5960 memcpy(a, pCDS->zFile, pCDS->nFile); 5961 a += pCDS->nFile; 5962 5963 if( pEntry->aExtra ){ 5964 int n = (int)pCDS->nExtra + (int)pCDS->nComment; 5965 memcpy(a, pEntry->aExtra, n); 5966 a += n; 5967 }else{ 5968 assert( pCDS->nExtra==9 ); 5969 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP); 5970 zipfileWrite16(a, 5); 5971 *a++ = 0x01; 5972 zipfileWrite32(a, pEntry->mUnixTime); 5973 } 5974 5975 return a-aBuf; 5976 } 5977 5978 static int zipfileCommit(sqlite3_vtab *pVtab){ 5979 ZipfileTab *pTab = (ZipfileTab*)pVtab; 5980 int rc = SQLITE_OK; 5981 if( pTab->pWriteFd ){ 5982 i64 iOffset = pTab->szCurrent; 5983 ZipfileEntry *p; 5984 ZipfileEOCD eocd; 5985 int nEntry = 0; 5986 5987 /* Write out all entries */ 5988 for(p=pTab->pFirstEntry; rc==SQLITE_OK && p; p=p->pNext){ 5989 int n = zipfileSerializeCDS(p, pTab->aBuffer); 5990 rc = zipfileAppendData(pTab, pTab->aBuffer, n); 5991 nEntry++; 5992 } 5993 5994 /* Write out the EOCD record */ 5995 eocd.iDisk = 0; 5996 eocd.iFirstDisk = 0; 5997 eocd.nEntry = (u16)nEntry; 5998 eocd.nEntryTotal = (u16)nEntry; 5999 eocd.nSize = (u32)(pTab->szCurrent - iOffset); 6000 eocd.iOffset = (u32)iOffset; 6001 rc = zipfileAppendEOCD(pTab, &eocd); 6002 6003 zipfileCleanupTransaction(pTab); 6004 } 6005 return rc; 6006 } 6007 6008 static int zipfileRollback(sqlite3_vtab *pVtab){ 6009 return zipfileCommit(pVtab); 6010 } 6011 6012 static ZipfileCsr *zipfileFindCursor(ZipfileTab *pTab, i64 iId){ 6013 ZipfileCsr *pCsr; 6014 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){ 6015 if( iId==pCsr->iId ) break; 6016 } 6017 return pCsr; 6018 } 6019 6020 static void zipfileFunctionCds( 6021 sqlite3_context *context, 6022 int argc, 6023 sqlite3_value **argv 6024 ){ 6025 ZipfileCsr *pCsr; 6026 ZipfileTab *pTab = (ZipfileTab*)sqlite3_user_data(context); 6027 assert( argc>0 ); 6028 6029 pCsr = zipfileFindCursor(pTab, sqlite3_value_int64(argv[0])); 6030 if( pCsr ){ 6031 ZipfileCDS *p = &pCsr->pCurrent->cds; 6032 char *zRes = sqlite3_mprintf("{" 6033 "\"version-made-by\" : %u, " 6034 "\"version-to-extract\" : %u, " 6035 "\"flags\" : %u, " 6036 "\"compression\" : %u, " 6037 "\"time\" : %u, " 6038 "\"date\" : %u, " 6039 "\"crc32\" : %u, " 6040 "\"compressed-size\" : %u, " 6041 "\"uncompressed-size\" : %u, " 6042 "\"file-name-length\" : %u, " 6043 "\"extra-field-length\" : %u, " 6044 "\"file-comment-length\" : %u, " 6045 "\"disk-number-start\" : %u, " 6046 "\"internal-attr\" : %u, " 6047 "\"external-attr\" : %u, " 6048 "\"offset\" : %u }", 6049 (u32)p->iVersionMadeBy, (u32)p->iVersionExtract, 6050 (u32)p->flags, (u32)p->iCompression, 6051 (u32)p->mTime, (u32)p->mDate, 6052 (u32)p->crc32, (u32)p->szCompressed, 6053 (u32)p->szUncompressed, (u32)p->nFile, 6054 (u32)p->nExtra, (u32)p->nComment, 6055 (u32)p->iDiskStart, (u32)p->iInternalAttr, 6056 (u32)p->iExternalAttr, (u32)p->iOffset 6057 ); 6058 6059 if( zRes==0 ){ 6060 sqlite3_result_error_nomem(context); 6061 }else{ 6062 sqlite3_result_text(context, zRes, -1, SQLITE_TRANSIENT); 6063 sqlite3_free(zRes); 6064 } 6065 } 6066 } 6067 6068 /* 6069 ** xFindFunction method. 6070 */ 6071 static int zipfileFindFunction( 6072 sqlite3_vtab *pVtab, /* Virtual table handle */ 6073 int nArg, /* Number of SQL function arguments */ 6074 const char *zName, /* Name of SQL function */ 6075 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */ 6076 void **ppArg /* OUT: User data for *pxFunc */ 6077 ){ 6078 if( sqlite3_stricmp("zipfile_cds", zName)==0 ){ 6079 *pxFunc = zipfileFunctionCds; 6080 *ppArg = (void*)pVtab; 6081 return 1; 6082 } 6083 return 0; 6084 } 6085 6086 typedef struct ZipfileBuffer ZipfileBuffer; 6087 struct ZipfileBuffer { 6088 u8 *a; /* Pointer to buffer */ 6089 int n; /* Size of buffer in bytes */ 6090 int nAlloc; /* Byte allocated at a[] */ 6091 }; 6092 6093 typedef struct ZipfileCtx ZipfileCtx; 6094 struct ZipfileCtx { 6095 int nEntry; 6096 ZipfileBuffer body; 6097 ZipfileBuffer cds; 6098 }; 6099 6100 static int zipfileBufferGrow(ZipfileBuffer *pBuf, int nByte){ 6101 if( pBuf->n+nByte>pBuf->nAlloc ){ 6102 u8 *aNew; 6103 sqlite3_int64 nNew = pBuf->n ? pBuf->n*2 : 512; 6104 int nReq = pBuf->n + nByte; 6105 6106 while( nNew<nReq ) nNew = nNew*2; 6107 aNew = sqlite3_realloc64(pBuf->a, nNew); 6108 if( aNew==0 ) return SQLITE_NOMEM; 6109 pBuf->a = aNew; 6110 pBuf->nAlloc = (int)nNew; 6111 } 6112 return SQLITE_OK; 6113 } 6114 6115 /* 6116 ** xStep() callback for the zipfile() aggregate. This can be called in 6117 ** any of the following ways: 6118 ** 6119 ** SELECT zipfile(name,data) ... 6120 ** SELECT zipfile(name,mode,mtime,data) ... 6121 ** SELECT zipfile(name,mode,mtime,data,method) ... 6122 */ 6123 void zipfileStep(sqlite3_context *pCtx, int nVal, sqlite3_value **apVal){ 6124 ZipfileCtx *p; /* Aggregate function context */ 6125 ZipfileEntry e; /* New entry to add to zip archive */ 6126 6127 sqlite3_value *pName = 0; 6128 sqlite3_value *pMode = 0; 6129 sqlite3_value *pMtime = 0; 6130 sqlite3_value *pData = 0; 6131 sqlite3_value *pMethod = 0; 6132 6133 int bIsDir = 0; 6134 u32 mode; 6135 int rc = SQLITE_OK; 6136 char *zErr = 0; 6137 6138 int iMethod = -1; /* Compression method to use (0 or 8) */ 6139 6140 const u8 *aData = 0; /* Possibly compressed data for new entry */ 6141 int nData = 0; /* Size of aData[] in bytes */ 6142 int szUncompressed = 0; /* Size of data before compression */ 6143 u8 *aFree = 0; /* Free this before returning */ 6144 u32 iCrc32 = 0; /* crc32 of uncompressed data */ 6145 6146 char *zName = 0; /* Path (name) of new entry */ 6147 int nName = 0; /* Size of zName in bytes */ 6148 char *zFree = 0; /* Free this before returning */ 6149 int nByte; 6150 6151 memset(&e, 0, sizeof(e)); 6152 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx)); 6153 if( p==0 ) return; 6154 6155 /* Martial the arguments into stack variables */ 6156 if( nVal!=2 && nVal!=4 && nVal!=5 ){ 6157 zErr = sqlite3_mprintf("wrong number of arguments to function zipfile()"); 6158 rc = SQLITE_ERROR; 6159 goto zipfile_step_out; 6160 } 6161 pName = apVal[0]; 6162 if( nVal==2 ){ 6163 pData = apVal[1]; 6164 }else{ 6165 pMode = apVal[1]; 6166 pMtime = apVal[2]; 6167 pData = apVal[3]; 6168 if( nVal==5 ){ 6169 pMethod = apVal[4]; 6170 } 6171 } 6172 6173 /* Check that the 'name' parameter looks ok. */ 6174 zName = (char*)sqlite3_value_text(pName); 6175 nName = sqlite3_value_bytes(pName); 6176 if( zName==0 ){ 6177 zErr = sqlite3_mprintf("first argument to zipfile() must be non-NULL"); 6178 rc = SQLITE_ERROR; 6179 goto zipfile_step_out; 6180 } 6181 6182 /* Inspect the 'method' parameter. This must be either 0 (store), 8 (use 6183 ** deflate compression) or NULL (choose automatically). */ 6184 if( pMethod && SQLITE_NULL!=sqlite3_value_type(pMethod) ){ 6185 iMethod = (int)sqlite3_value_int64(pMethod); 6186 if( iMethod!=0 && iMethod!=8 ){ 6187 zErr = sqlite3_mprintf("illegal method value: %d", iMethod); 6188 rc = SQLITE_ERROR; 6189 goto zipfile_step_out; 6190 } 6191 } 6192 6193 /* Now inspect the data. If this is NULL, then the new entry must be a 6194 ** directory. Otherwise, figure out whether or not the data should 6195 ** be deflated or simply stored in the zip archive. */ 6196 if( sqlite3_value_type(pData)==SQLITE_NULL ){ 6197 bIsDir = 1; 6198 iMethod = 0; 6199 }else{ 6200 aData = sqlite3_value_blob(pData); 6201 szUncompressed = nData = sqlite3_value_bytes(pData); 6202 iCrc32 = crc32(0, aData, nData); 6203 if( iMethod<0 || iMethod==8 ){ 6204 int nOut = 0; 6205 rc = zipfileDeflate(aData, nData, &aFree, &nOut, &zErr); 6206 if( rc!=SQLITE_OK ){ 6207 goto zipfile_step_out; 6208 } 6209 if( iMethod==8 || nOut<nData ){ 6210 aData = aFree; 6211 nData = nOut; 6212 iMethod = 8; 6213 }else{ 6214 iMethod = 0; 6215 } 6216 } 6217 } 6218 6219 /* Decode the "mode" argument. */ 6220 rc = zipfileGetMode(pMode, bIsDir, &mode, &zErr); 6221 if( rc ) goto zipfile_step_out; 6222 6223 /* Decode the "mtime" argument. */ 6224 e.mUnixTime = zipfileGetTime(pMtime); 6225 6226 /* If this is a directory entry, ensure that there is exactly one '/' 6227 ** at the end of the path. Or, if this is not a directory and the path 6228 ** ends in '/' it is an error. */ 6229 if( bIsDir==0 ){ 6230 if( zName[nName-1]=='/' ){ 6231 zErr = sqlite3_mprintf("non-directory name must not end with /"); 6232 rc = SQLITE_ERROR; 6233 goto zipfile_step_out; 6234 } 6235 }else{ 6236 if( zName[nName-1]!='/' ){ 6237 zName = zFree = sqlite3_mprintf("%s/", zName); 6238 nName++; 6239 if( zName==0 ){ 6240 rc = SQLITE_NOMEM; 6241 goto zipfile_step_out; 6242 } 6243 }else{ 6244 while( nName>1 && zName[nName-2]=='/' ) nName--; 6245 } 6246 } 6247 6248 /* Assemble the ZipfileEntry object for the new zip archive entry */ 6249 e.cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY; 6250 e.cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED; 6251 e.cds.flags = ZIPFILE_NEWENTRY_FLAGS; 6252 e.cds.iCompression = (u16)iMethod; 6253 zipfileMtimeToDos(&e.cds, (u32)e.mUnixTime); 6254 e.cds.crc32 = iCrc32; 6255 e.cds.szCompressed = nData; 6256 e.cds.szUncompressed = szUncompressed; 6257 e.cds.iExternalAttr = (mode<<16); 6258 e.cds.iOffset = p->body.n; 6259 e.cds.nFile = (u16)nName; 6260 e.cds.zFile = zName; 6261 6262 /* Append the LFH to the body of the new archive */ 6263 nByte = ZIPFILE_LFH_FIXED_SZ + e.cds.nFile + 9; 6264 if( (rc = zipfileBufferGrow(&p->body, nByte)) ) goto zipfile_step_out; 6265 p->body.n += zipfileSerializeLFH(&e, &p->body.a[p->body.n]); 6266 6267 /* Append the data to the body of the new archive */ 6268 if( nData>0 ){ 6269 if( (rc = zipfileBufferGrow(&p->body, nData)) ) goto zipfile_step_out; 6270 memcpy(&p->body.a[p->body.n], aData, nData); 6271 p->body.n += nData; 6272 } 6273 6274 /* Append the CDS record to the directory of the new archive */ 6275 nByte = ZIPFILE_CDS_FIXED_SZ + e.cds.nFile + 9; 6276 if( (rc = zipfileBufferGrow(&p->cds, nByte)) ) goto zipfile_step_out; 6277 p->cds.n += zipfileSerializeCDS(&e, &p->cds.a[p->cds.n]); 6278 6279 /* Increment the count of entries in the archive */ 6280 p->nEntry++; 6281 6282 zipfile_step_out: 6283 sqlite3_free(aFree); 6284 sqlite3_free(zFree); 6285 if( rc ){ 6286 if( zErr ){ 6287 sqlite3_result_error(pCtx, zErr, -1); 6288 }else{ 6289 sqlite3_result_error_code(pCtx, rc); 6290 } 6291 } 6292 sqlite3_free(zErr); 6293 } 6294 6295 /* 6296 ** xFinalize() callback for zipfile aggregate function. 6297 */ 6298 void zipfileFinal(sqlite3_context *pCtx){ 6299 ZipfileCtx *p; 6300 ZipfileEOCD eocd; 6301 sqlite3_int64 nZip; 6302 u8 *aZip; 6303 6304 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx)); 6305 if( p==0 ) return; 6306 if( p->nEntry>0 ){ 6307 memset(&eocd, 0, sizeof(eocd)); 6308 eocd.nEntry = (u16)p->nEntry; 6309 eocd.nEntryTotal = (u16)p->nEntry; 6310 eocd.nSize = p->cds.n; 6311 eocd.iOffset = p->body.n; 6312 6313 nZip = p->body.n + p->cds.n + ZIPFILE_EOCD_FIXED_SZ; 6314 aZip = (u8*)sqlite3_malloc64(nZip); 6315 if( aZip==0 ){ 6316 sqlite3_result_error_nomem(pCtx); 6317 }else{ 6318 memcpy(aZip, p->body.a, p->body.n); 6319 memcpy(&aZip[p->body.n], p->cds.a, p->cds.n); 6320 zipfileSerializeEOCD(&eocd, &aZip[p->body.n + p->cds.n]); 6321 sqlite3_result_blob(pCtx, aZip, (int)nZip, zipfileFree); 6322 } 6323 } 6324 6325 sqlite3_free(p->body.a); 6326 sqlite3_free(p->cds.a); 6327 } 6328 6329 6330 /* 6331 ** Register the "zipfile" virtual table. 6332 */ 6333 static int zipfileRegister(sqlite3 *db){ 6334 static sqlite3_module zipfileModule = { 6335 1, /* iVersion */ 6336 zipfileConnect, /* xCreate */ 6337 zipfileConnect, /* xConnect */ 6338 zipfileBestIndex, /* xBestIndex */ 6339 zipfileDisconnect, /* xDisconnect */ 6340 zipfileDisconnect, /* xDestroy */ 6341 zipfileOpen, /* xOpen - open a cursor */ 6342 zipfileClose, /* xClose - close a cursor */ 6343 zipfileFilter, /* xFilter - configure scan constraints */ 6344 zipfileNext, /* xNext - advance a cursor */ 6345 zipfileEof, /* xEof - check for end of scan */ 6346 zipfileColumn, /* xColumn - read data */ 6347 0, /* xRowid - read data */ 6348 zipfileUpdate, /* xUpdate */ 6349 zipfileBegin, /* xBegin */ 6350 0, /* xSync */ 6351 zipfileCommit, /* xCommit */ 6352 zipfileRollback, /* xRollback */ 6353 zipfileFindFunction, /* xFindMethod */ 6354 0, /* xRename */ 6355 }; 6356 6357 int rc = sqlite3_create_module(db, "zipfile" , &zipfileModule, 0); 6358 if( rc==SQLITE_OK ) rc = sqlite3_overload_function(db, "zipfile_cds", -1); 6359 if( rc==SQLITE_OK ){ 6360 rc = sqlite3_create_function(db, "zipfile", -1, SQLITE_UTF8, 0, 0, 6361 zipfileStep, zipfileFinal 6362 ); 6363 } 6364 return rc; 6365 } 6366 #else /* SQLITE_OMIT_VIRTUALTABLE */ 6367 # define zipfileRegister(x) SQLITE_OK 6368 #endif 6369 6370 #ifdef _WIN32 6371 6372 #endif 6373 int sqlite3_zipfile_init( 6374 sqlite3 *db, 6375 char **pzErrMsg, 6376 const sqlite3_api_routines *pApi 6377 ){ 6378 SQLITE_EXTENSION_INIT2(pApi); 6379 (void)pzErrMsg; /* Unused parameter */ 6380 return zipfileRegister(db); 6381 } 6382 6383 /************************* End ../ext/misc/zipfile.c ********************/ 6384 /************************* Begin ../ext/misc/sqlar.c ******************/ 6385 /* 6386 ** 2017-12-17 6387 ** 6388 ** The author disclaims copyright to this source code. In place of 6389 ** a legal notice, here is a blessing: 6390 ** 6391 ** May you do good and not evil. 6392 ** May you find forgiveness for yourself and forgive others. 6393 ** May you share freely, never taking more than you give. 6394 ** 6395 ****************************************************************************** 6396 ** 6397 ** Utility functions sqlar_compress() and sqlar_uncompress(). Useful 6398 ** for working with sqlar archives and used by the shell tool's built-in 6399 ** sqlar support. 6400 */ 6401 SQLITE_EXTENSION_INIT1 6402 #include <zlib.h> 6403 6404 /* 6405 ** Implementation of the "sqlar_compress(X)" SQL function. 6406 ** 6407 ** If the type of X is SQLITE_BLOB, and compressing that blob using 6408 ** zlib utility function compress() yields a smaller blob, return the 6409 ** compressed blob. Otherwise, return a copy of X. 6410 ** 6411 ** SQLar uses the "zlib format" for compressed content. The zlib format 6412 ** contains a two-byte identification header and a four-byte checksum at 6413 ** the end. This is different from ZIP which uses the raw deflate format. 6414 ** 6415 ** Future enhancements to SQLar might add support for new compression formats. 6416 ** If so, those new formats will be identified by alternative headers in the 6417 ** compressed data. 6418 */ 6419 static void sqlarCompressFunc( 6420 sqlite3_context *context, 6421 int argc, 6422 sqlite3_value **argv 6423 ){ 6424 assert( argc==1 ); 6425 if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){ 6426 const Bytef *pData = sqlite3_value_blob(argv[0]); 6427 uLong nData = sqlite3_value_bytes(argv[0]); 6428 uLongf nOut = compressBound(nData); 6429 Bytef *pOut; 6430 6431 pOut = (Bytef*)sqlite3_malloc(nOut); 6432 if( pOut==0 ){ 6433 sqlite3_result_error_nomem(context); 6434 return; 6435 }else{ 6436 if( Z_OK!=compress(pOut, &nOut, pData, nData) ){ 6437 sqlite3_result_error(context, "error in compress()", -1); 6438 }else if( nOut<nData ){ 6439 sqlite3_result_blob(context, pOut, nOut, SQLITE_TRANSIENT); 6440 }else{ 6441 sqlite3_result_value(context, argv[0]); 6442 } 6443 sqlite3_free(pOut); 6444 } 6445 }else{ 6446 sqlite3_result_value(context, argv[0]); 6447 } 6448 } 6449 6450 /* 6451 ** Implementation of the "sqlar_uncompress(X,SZ)" SQL function 6452 ** 6453 ** Parameter SZ is interpreted as an integer. If it is less than or 6454 ** equal to zero, then this function returns a copy of X. Or, if 6455 ** SZ is equal to the size of X when interpreted as a blob, also 6456 ** return a copy of X. Otherwise, decompress blob X using zlib 6457 ** utility function uncompress() and return the results (another 6458 ** blob). 6459 */ 6460 static void sqlarUncompressFunc( 6461 sqlite3_context *context, 6462 int argc, 6463 sqlite3_value **argv 6464 ){ 6465 uLong nData; 6466 uLongf sz; 6467 6468 assert( argc==2 ); 6469 sz = sqlite3_value_int(argv[1]); 6470 6471 if( sz<=0 || sz==(nData = sqlite3_value_bytes(argv[0])) ){ 6472 sqlite3_result_value(context, argv[0]); 6473 }else{ 6474 const Bytef *pData= sqlite3_value_blob(argv[0]); 6475 Bytef *pOut = sqlite3_malloc(sz); 6476 if( Z_OK!=uncompress(pOut, &sz, pData, nData) ){ 6477 sqlite3_result_error(context, "error in uncompress()", -1); 6478 }else{ 6479 sqlite3_result_blob(context, pOut, sz, SQLITE_TRANSIENT); 6480 } 6481 sqlite3_free(pOut); 6482 } 6483 } 6484 6485 6486 #ifdef _WIN32 6487 6488 #endif 6489 int sqlite3_sqlar_init( 6490 sqlite3 *db, 6491 char **pzErrMsg, 6492 const sqlite3_api_routines *pApi 6493 ){ 6494 int rc = SQLITE_OK; 6495 SQLITE_EXTENSION_INIT2(pApi); 6496 (void)pzErrMsg; /* Unused parameter */ 6497 rc = sqlite3_create_function(db, "sqlar_compress", 1, SQLITE_UTF8, 0, 6498 sqlarCompressFunc, 0, 0); 6499 if( rc==SQLITE_OK ){ 6500 rc = sqlite3_create_function(db, "sqlar_uncompress", 2, SQLITE_UTF8, 0, 6501 sqlarUncompressFunc, 0, 0); 6502 } 6503 return rc; 6504 } 6505 6506 /************************* End ../ext/misc/sqlar.c ********************/ 6507 #endif 6508 /************************* Begin ../ext/expert/sqlite3expert.h ******************/ 6509 /* 6510 ** 2017 April 07 6511 ** 6512 ** The author disclaims copyright to this source code. In place of 6513 ** a legal notice, here is a blessing: 6514 ** 6515 ** May you do good and not evil. 6516 ** May you find forgiveness for yourself and forgive others. 6517 ** May you share freely, never taking more than you give. 6518 ** 6519 ************************************************************************* 6520 */ 6521 6522 6523 6524 typedef struct sqlite3expert sqlite3expert; 6525 6526 /* 6527 ** Create a new sqlite3expert object. 6528 ** 6529 ** If successful, a pointer to the new object is returned and (*pzErr) set 6530 ** to NULL. Or, if an error occurs, NULL is returned and (*pzErr) set to 6531 ** an English-language error message. In this case it is the responsibility 6532 ** of the caller to eventually free the error message buffer using 6533 ** sqlite3_free(). 6534 */ 6535 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErr); 6536 6537 /* 6538 ** Configure an sqlite3expert object. 6539 ** 6540 ** EXPERT_CONFIG_SAMPLE: 6541 ** By default, sqlite3_expert_analyze() generates sqlite_stat1 data for 6542 ** each candidate index. This involves scanning and sorting the entire 6543 ** contents of each user database table once for each candidate index 6544 ** associated with the table. For large databases, this can be 6545 ** prohibitively slow. This option allows the sqlite3expert object to 6546 ** be configured so that sqlite_stat1 data is instead generated based on a 6547 ** subset of each table, or so that no sqlite_stat1 data is used at all. 6548 ** 6549 ** A single integer argument is passed to this option. If the value is less 6550 ** than or equal to zero, then no sqlite_stat1 data is generated or used by 6551 ** the analysis - indexes are recommended based on the database schema only. 6552 ** Or, if the value is 100 or greater, complete sqlite_stat1 data is 6553 ** generated for each candidate index (this is the default). Finally, if the 6554 ** value falls between 0 and 100, then it represents the percentage of user 6555 ** table rows that should be considered when generating sqlite_stat1 data. 6556 ** 6557 ** Examples: 6558 ** 6559 ** // Do not generate any sqlite_stat1 data 6560 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 0); 6561 ** 6562 ** // Generate sqlite_stat1 data based on 10% of the rows in each table. 6563 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 10); 6564 */ 6565 int sqlite3_expert_config(sqlite3expert *p, int op, ...); 6566 6567 #define EXPERT_CONFIG_SAMPLE 1 /* int */ 6568 6569 /* 6570 ** Specify zero or more SQL statements to be included in the analysis. 6571 ** 6572 ** Buffer zSql must contain zero or more complete SQL statements. This 6573 ** function parses all statements contained in the buffer and adds them 6574 ** to the internal list of statements to analyze. If successful, SQLITE_OK 6575 ** is returned and (*pzErr) set to NULL. Or, if an error occurs - for example 6576 ** due to a error in the SQL - an SQLite error code is returned and (*pzErr) 6577 ** may be set to point to an English language error message. In this case 6578 ** the caller is responsible for eventually freeing the error message buffer 6579 ** using sqlite3_free(). 6580 ** 6581 ** If an error does occur while processing one of the statements in the 6582 ** buffer passed as the second argument, none of the statements in the 6583 ** buffer are added to the analysis. 6584 ** 6585 ** This function must be called before sqlite3_expert_analyze(). If a call 6586 ** to this function is made on an sqlite3expert object that has already 6587 ** been passed to sqlite3_expert_analyze() SQLITE_MISUSE is returned 6588 ** immediately and no statements are added to the analysis. 6589 */ 6590 int sqlite3_expert_sql( 6591 sqlite3expert *p, /* From a successful sqlite3_expert_new() */ 6592 const char *zSql, /* SQL statement(s) to add */ 6593 char **pzErr /* OUT: Error message (if any) */ 6594 ); 6595 6596 6597 /* 6598 ** This function is called after the sqlite3expert object has been configured 6599 ** with all SQL statements using sqlite3_expert_sql() to actually perform 6600 ** the analysis. Once this function has been called, it is not possible to 6601 ** add further SQL statements to the analysis. 6602 ** 6603 ** If successful, SQLITE_OK is returned and (*pzErr) is set to NULL. Or, if 6604 ** an error occurs, an SQLite error code is returned and (*pzErr) set to 6605 ** point to a buffer containing an English language error message. In this 6606 ** case it is the responsibility of the caller to eventually free the buffer 6607 ** using sqlite3_free(). 6608 ** 6609 ** If an error does occur within this function, the sqlite3expert object 6610 ** is no longer useful for any purpose. At that point it is no longer 6611 ** possible to add further SQL statements to the object or to re-attempt 6612 ** the analysis. The sqlite3expert object must still be freed using a call 6613 ** sqlite3_expert_destroy(). 6614 */ 6615 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr); 6616 6617 /* 6618 ** Return the total number of statements loaded using sqlite3_expert_sql(). 6619 ** The total number of SQL statements may be different from the total number 6620 ** to calls to sqlite3_expert_sql(). 6621 */ 6622 int sqlite3_expert_count(sqlite3expert*); 6623 6624 /* 6625 ** Return a component of the report. 6626 ** 6627 ** This function is called after sqlite3_expert_analyze() to extract the 6628 ** results of the analysis. Each call to this function returns either a 6629 ** NULL pointer or a pointer to a buffer containing a nul-terminated string. 6630 ** The value passed as the third argument must be one of the EXPERT_REPORT_* 6631 ** #define constants defined below. 6632 ** 6633 ** For some EXPERT_REPORT_* parameters, the buffer returned contains 6634 ** information relating to a specific SQL statement. In these cases that 6635 ** SQL statement is identified by the value passed as the second argument. 6636 ** SQL statements are numbered from 0 in the order in which they are parsed. 6637 ** If an out-of-range value (less than zero or equal to or greater than the 6638 ** value returned by sqlite3_expert_count()) is passed as the second argument 6639 ** along with such an EXPERT_REPORT_* parameter, NULL is always returned. 6640 ** 6641 ** EXPERT_REPORT_SQL: 6642 ** Return the text of SQL statement iStmt. 6643 ** 6644 ** EXPERT_REPORT_INDEXES: 6645 ** Return a buffer containing the CREATE INDEX statements for all recommended 6646 ** indexes for statement iStmt. If there are no new recommeded indexes, NULL 6647 ** is returned. 6648 ** 6649 ** EXPERT_REPORT_PLAN: 6650 ** Return a buffer containing the EXPLAIN QUERY PLAN output for SQL query 6651 ** iStmt after the proposed indexes have been added to the database schema. 6652 ** 6653 ** EXPERT_REPORT_CANDIDATES: 6654 ** Return a pointer to a buffer containing the CREATE INDEX statements 6655 ** for all indexes that were tested (for all SQL statements). The iStmt 6656 ** parameter is ignored for EXPERT_REPORT_CANDIDATES calls. 6657 */ 6658 const char *sqlite3_expert_report(sqlite3expert*, int iStmt, int eReport); 6659 6660 /* 6661 ** Values for the third argument passed to sqlite3_expert_report(). 6662 */ 6663 #define EXPERT_REPORT_SQL 1 6664 #define EXPERT_REPORT_INDEXES 2 6665 #define EXPERT_REPORT_PLAN 3 6666 #define EXPERT_REPORT_CANDIDATES 4 6667 6668 /* 6669 ** Free an (sqlite3expert*) handle and all associated resources. There 6670 ** should be one call to this function for each successful call to 6671 ** sqlite3-expert_new(). 6672 */ 6673 void sqlite3_expert_destroy(sqlite3expert*); 6674 6675 6676 6677 /************************* End ../ext/expert/sqlite3expert.h ********************/ 6678 /************************* Begin ../ext/expert/sqlite3expert.c ******************/ 6679 /* 6680 ** 2017 April 09 6681 ** 6682 ** The author disclaims copyright to this source code. In place of 6683 ** a legal notice, here is a blessing: 6684 ** 6685 ** May you do good and not evil. 6686 ** May you find forgiveness for yourself and forgive others. 6687 ** May you share freely, never taking more than you give. 6688 ** 6689 ************************************************************************* 6690 */ 6691 #include <assert.h> 6692 #include <string.h> 6693 #include <stdio.h> 6694 6695 #ifndef SQLITE_OMIT_VIRTUALTABLE 6696 6697 /* typedef sqlite3_int64 i64; */ 6698 /* typedef sqlite3_uint64 u64; */ 6699 6700 typedef struct IdxColumn IdxColumn; 6701 typedef struct IdxConstraint IdxConstraint; 6702 typedef struct IdxScan IdxScan; 6703 typedef struct IdxStatement IdxStatement; 6704 typedef struct IdxTable IdxTable; 6705 typedef struct IdxWrite IdxWrite; 6706 6707 #define STRLEN (int)strlen 6708 6709 /* 6710 ** A temp table name that we assume no user database will actually use. 6711 ** If this assumption proves incorrect triggers on the table with the 6712 ** conflicting name will be ignored. 6713 */ 6714 #define UNIQUE_TABLE_NAME "t592690916721053953805701627921227776" 6715 6716 /* 6717 ** A single constraint. Equivalent to either "col = ?" or "col < ?" (or 6718 ** any other type of single-ended range constraint on a column). 6719 ** 6720 ** pLink: 6721 ** Used to temporarily link IdxConstraint objects into lists while 6722 ** creating candidate indexes. 6723 */ 6724 struct IdxConstraint { 6725 char *zColl; /* Collation sequence */ 6726 int bRange; /* True for range, false for eq */ 6727 int iCol; /* Constrained table column */ 6728 int bFlag; /* Used by idxFindCompatible() */ 6729 int bDesc; /* True if ORDER BY <expr> DESC */ 6730 IdxConstraint *pNext; /* Next constraint in pEq or pRange list */ 6731 IdxConstraint *pLink; /* See above */ 6732 }; 6733 6734 /* 6735 ** A single scan of a single table. 6736 */ 6737 struct IdxScan { 6738 IdxTable *pTab; /* Associated table object */ 6739 int iDb; /* Database containing table zTable */ 6740 i64 covering; /* Mask of columns required for cov. index */ 6741 IdxConstraint *pOrder; /* ORDER BY columns */ 6742 IdxConstraint *pEq; /* List of == constraints */ 6743 IdxConstraint *pRange; /* List of < constraints */ 6744 IdxScan *pNextScan; /* Next IdxScan object for same analysis */ 6745 }; 6746 6747 /* 6748 ** Information regarding a single database table. Extracted from 6749 ** "PRAGMA table_info" by function idxGetTableInfo(). 6750 */ 6751 struct IdxColumn { 6752 char *zName; 6753 char *zColl; 6754 int iPk; 6755 }; 6756 struct IdxTable { 6757 int nCol; 6758 char *zName; /* Table name */ 6759 IdxColumn *aCol; 6760 IdxTable *pNext; /* Next table in linked list of all tables */ 6761 }; 6762 6763 /* 6764 ** An object of the following type is created for each unique table/write-op 6765 ** seen. The objects are stored in a singly-linked list beginning at 6766 ** sqlite3expert.pWrite. 6767 */ 6768 struct IdxWrite { 6769 IdxTable *pTab; 6770 int eOp; /* SQLITE_UPDATE, DELETE or INSERT */ 6771 IdxWrite *pNext; 6772 }; 6773 6774 /* 6775 ** Each statement being analyzed is represented by an instance of this 6776 ** structure. 6777 */ 6778 struct IdxStatement { 6779 int iId; /* Statement number */ 6780 char *zSql; /* SQL statement */ 6781 char *zIdx; /* Indexes */ 6782 char *zEQP; /* Plan */ 6783 IdxStatement *pNext; 6784 }; 6785 6786 6787 /* 6788 ** A hash table for storing strings. With space for a payload string 6789 ** with each entry. Methods are: 6790 ** 6791 ** idxHashInit() 6792 ** idxHashClear() 6793 ** idxHashAdd() 6794 ** idxHashSearch() 6795 */ 6796 #define IDX_HASH_SIZE 1023 6797 typedef struct IdxHashEntry IdxHashEntry; 6798 typedef struct IdxHash IdxHash; 6799 struct IdxHashEntry { 6800 char *zKey; /* nul-terminated key */ 6801 char *zVal; /* nul-terminated value string */ 6802 char *zVal2; /* nul-terminated value string 2 */ 6803 IdxHashEntry *pHashNext; /* Next entry in same hash bucket */ 6804 IdxHashEntry *pNext; /* Next entry in hash */ 6805 }; 6806 struct IdxHash { 6807 IdxHashEntry *pFirst; 6808 IdxHashEntry *aHash[IDX_HASH_SIZE]; 6809 }; 6810 6811 /* 6812 ** sqlite3expert object. 6813 */ 6814 struct sqlite3expert { 6815 int iSample; /* Percentage of tables to sample for stat1 */ 6816 sqlite3 *db; /* User database */ 6817 sqlite3 *dbm; /* In-memory db for this analysis */ 6818 sqlite3 *dbv; /* Vtab schema for this analysis */ 6819 IdxTable *pTable; /* List of all IdxTable objects */ 6820 IdxScan *pScan; /* List of scan objects */ 6821 IdxWrite *pWrite; /* List of write objects */ 6822 IdxStatement *pStatement; /* List of IdxStatement objects */ 6823 int bRun; /* True once analysis has run */ 6824 char **pzErrmsg; 6825 int rc; /* Error code from whereinfo hook */ 6826 IdxHash hIdx; /* Hash containing all candidate indexes */ 6827 char *zCandidates; /* For EXPERT_REPORT_CANDIDATES */ 6828 }; 6829 6830 6831 /* 6832 ** Allocate and return nByte bytes of zeroed memory using sqlite3_malloc(). 6833 ** If the allocation fails, set *pRc to SQLITE_NOMEM and return NULL. 6834 */ 6835 static void *idxMalloc(int *pRc, int nByte){ 6836 void *pRet; 6837 assert( *pRc==SQLITE_OK ); 6838 assert( nByte>0 ); 6839 pRet = sqlite3_malloc(nByte); 6840 if( pRet ){ 6841 memset(pRet, 0, nByte); 6842 }else{ 6843 *pRc = SQLITE_NOMEM; 6844 } 6845 return pRet; 6846 } 6847 6848 /* 6849 ** Initialize an IdxHash hash table. 6850 */ 6851 static void idxHashInit(IdxHash *pHash){ 6852 memset(pHash, 0, sizeof(IdxHash)); 6853 } 6854 6855 /* 6856 ** Reset an IdxHash hash table. 6857 */ 6858 static void idxHashClear(IdxHash *pHash){ 6859 int i; 6860 for(i=0; i<IDX_HASH_SIZE; i++){ 6861 IdxHashEntry *pEntry; 6862 IdxHashEntry *pNext; 6863 for(pEntry=pHash->aHash[i]; pEntry; pEntry=pNext){ 6864 pNext = pEntry->pHashNext; 6865 sqlite3_free(pEntry->zVal2); 6866 sqlite3_free(pEntry); 6867 } 6868 } 6869 memset(pHash, 0, sizeof(IdxHash)); 6870 } 6871 6872 /* 6873 ** Return the index of the hash bucket that the string specified by the 6874 ** arguments to this function belongs. 6875 */ 6876 static int idxHashString(const char *z, int n){ 6877 unsigned int ret = 0; 6878 int i; 6879 for(i=0; i<n; i++){ 6880 ret += (ret<<3) + (unsigned char)(z[i]); 6881 } 6882 return (int)(ret % IDX_HASH_SIZE); 6883 } 6884 6885 /* 6886 ** If zKey is already present in the hash table, return non-zero and do 6887 ** nothing. Otherwise, add an entry with key zKey and payload string zVal to 6888 ** the hash table passed as the second argument. 6889 */ 6890 static int idxHashAdd( 6891 int *pRc, 6892 IdxHash *pHash, 6893 const char *zKey, 6894 const char *zVal 6895 ){ 6896 int nKey = STRLEN(zKey); 6897 int iHash = idxHashString(zKey, nKey); 6898 int nVal = (zVal ? STRLEN(zVal) : 0); 6899 IdxHashEntry *pEntry; 6900 assert( iHash>=0 ); 6901 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){ 6902 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){ 6903 return 1; 6904 } 6905 } 6906 pEntry = idxMalloc(pRc, sizeof(IdxHashEntry) + nKey+1 + nVal+1); 6907 if( pEntry ){ 6908 pEntry->zKey = (char*)&pEntry[1]; 6909 memcpy(pEntry->zKey, zKey, nKey); 6910 if( zVal ){ 6911 pEntry->zVal = &pEntry->zKey[nKey+1]; 6912 memcpy(pEntry->zVal, zVal, nVal); 6913 } 6914 pEntry->pHashNext = pHash->aHash[iHash]; 6915 pHash->aHash[iHash] = pEntry; 6916 6917 pEntry->pNext = pHash->pFirst; 6918 pHash->pFirst = pEntry; 6919 } 6920 return 0; 6921 } 6922 6923 /* 6924 ** If zKey/nKey is present in the hash table, return a pointer to the 6925 ** hash-entry object. 6926 */ 6927 static IdxHashEntry *idxHashFind(IdxHash *pHash, const char *zKey, int nKey){ 6928 int iHash; 6929 IdxHashEntry *pEntry; 6930 if( nKey<0 ) nKey = STRLEN(zKey); 6931 iHash = idxHashString(zKey, nKey); 6932 assert( iHash>=0 ); 6933 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){ 6934 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){ 6935 return pEntry; 6936 } 6937 } 6938 return 0; 6939 } 6940 6941 /* 6942 ** If the hash table contains an entry with a key equal to the string 6943 ** passed as the final two arguments to this function, return a pointer 6944 ** to the payload string. Otherwise, if zKey/nKey is not present in the 6945 ** hash table, return NULL. 6946 */ 6947 static const char *idxHashSearch(IdxHash *pHash, const char *zKey, int nKey){ 6948 IdxHashEntry *pEntry = idxHashFind(pHash, zKey, nKey); 6949 if( pEntry ) return pEntry->zVal; 6950 return 0; 6951 } 6952 6953 /* 6954 ** Allocate and return a new IdxConstraint object. Set the IdxConstraint.zColl 6955 ** variable to point to a copy of nul-terminated string zColl. 6956 */ 6957 static IdxConstraint *idxNewConstraint(int *pRc, const char *zColl){ 6958 IdxConstraint *pNew; 6959 int nColl = STRLEN(zColl); 6960 6961 assert( *pRc==SQLITE_OK ); 6962 pNew = (IdxConstraint*)idxMalloc(pRc, sizeof(IdxConstraint) * nColl + 1); 6963 if( pNew ){ 6964 pNew->zColl = (char*)&pNew[1]; 6965 memcpy(pNew->zColl, zColl, nColl+1); 6966 } 6967 return pNew; 6968 } 6969 6970 /* 6971 ** An error associated with database handle db has just occurred. Pass 6972 ** the error message to callback function xOut. 6973 */ 6974 static void idxDatabaseError( 6975 sqlite3 *db, /* Database handle */ 6976 char **pzErrmsg /* Write error here */ 6977 ){ 6978 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); 6979 } 6980 6981 /* 6982 ** Prepare an SQL statement. 6983 */ 6984 static int idxPrepareStmt( 6985 sqlite3 *db, /* Database handle to compile against */ 6986 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */ 6987 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */ 6988 const char *zSql /* SQL statement to compile */ 6989 ){ 6990 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); 6991 if( rc!=SQLITE_OK ){ 6992 *ppStmt = 0; 6993 idxDatabaseError(db, pzErrmsg); 6994 } 6995 return rc; 6996 } 6997 6998 /* 6999 ** Prepare an SQL statement using the results of a printf() formatting. 7000 */ 7001 static int idxPrintfPrepareStmt( 7002 sqlite3 *db, /* Database handle to compile against */ 7003 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */ 7004 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */ 7005 const char *zFmt, /* printf() format of SQL statement */ 7006 ... /* Trailing printf() arguments */ 7007 ){ 7008 va_list ap; 7009 int rc; 7010 char *zSql; 7011 va_start(ap, zFmt); 7012 zSql = sqlite3_vmprintf(zFmt, ap); 7013 if( zSql==0 ){ 7014 rc = SQLITE_NOMEM; 7015 }else{ 7016 rc = idxPrepareStmt(db, ppStmt, pzErrmsg, zSql); 7017 sqlite3_free(zSql); 7018 } 7019 va_end(ap); 7020 return rc; 7021 } 7022 7023 7024 /************************************************************************* 7025 ** Beginning of virtual table implementation. 7026 */ 7027 typedef struct ExpertVtab ExpertVtab; 7028 struct ExpertVtab { 7029 sqlite3_vtab base; 7030 IdxTable *pTab; 7031 sqlite3expert *pExpert; 7032 }; 7033 7034 typedef struct ExpertCsr ExpertCsr; 7035 struct ExpertCsr { 7036 sqlite3_vtab_cursor base; 7037 sqlite3_stmt *pData; 7038 }; 7039 7040 static char *expertDequote(const char *zIn){ 7041 int n = STRLEN(zIn); 7042 char *zRet = sqlite3_malloc(n); 7043 7044 assert( zIn[0]=='\'' ); 7045 assert( zIn[n-1]=='\'' ); 7046 7047 if( zRet ){ 7048 int iOut = 0; 7049 int iIn = 0; 7050 for(iIn=1; iIn<(n-1); iIn++){ 7051 if( zIn[iIn]=='\'' ){ 7052 assert( zIn[iIn+1]=='\'' ); 7053 iIn++; 7054 } 7055 zRet[iOut++] = zIn[iIn]; 7056 } 7057 zRet[iOut] = '\0'; 7058 } 7059 7060 return zRet; 7061 } 7062 7063 /* 7064 ** This function is the implementation of both the xConnect and xCreate 7065 ** methods of the r-tree virtual table. 7066 ** 7067 ** argv[0] -> module name 7068 ** argv[1] -> database name 7069 ** argv[2] -> table name 7070 ** argv[...] -> column names... 7071 */ 7072 static int expertConnect( 7073 sqlite3 *db, 7074 void *pAux, 7075 int argc, const char *const*argv, 7076 sqlite3_vtab **ppVtab, 7077 char **pzErr 7078 ){ 7079 sqlite3expert *pExpert = (sqlite3expert*)pAux; 7080 ExpertVtab *p = 0; 7081 int rc; 7082 7083 if( argc!=4 ){ 7084 *pzErr = sqlite3_mprintf("internal error!"); 7085 rc = SQLITE_ERROR; 7086 }else{ 7087 char *zCreateTable = expertDequote(argv[3]); 7088 if( zCreateTable ){ 7089 rc = sqlite3_declare_vtab(db, zCreateTable); 7090 if( rc==SQLITE_OK ){ 7091 p = idxMalloc(&rc, sizeof(ExpertVtab)); 7092 } 7093 if( rc==SQLITE_OK ){ 7094 p->pExpert = pExpert; 7095 p->pTab = pExpert->pTable; 7096 assert( sqlite3_stricmp(p->pTab->zName, argv[2])==0 ); 7097 } 7098 sqlite3_free(zCreateTable); 7099 }else{ 7100 rc = SQLITE_NOMEM; 7101 } 7102 } 7103 7104 *ppVtab = (sqlite3_vtab*)p; 7105 return rc; 7106 } 7107 7108 static int expertDisconnect(sqlite3_vtab *pVtab){ 7109 ExpertVtab *p = (ExpertVtab*)pVtab; 7110 sqlite3_free(p); 7111 return SQLITE_OK; 7112 } 7113 7114 static int expertBestIndex(sqlite3_vtab *pVtab, sqlite3_index_info *pIdxInfo){ 7115 ExpertVtab *p = (ExpertVtab*)pVtab; 7116 int rc = SQLITE_OK; 7117 int n = 0; 7118 IdxScan *pScan; 7119 const int opmask = 7120 SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_GT | 7121 SQLITE_INDEX_CONSTRAINT_LT | SQLITE_INDEX_CONSTRAINT_GE | 7122 SQLITE_INDEX_CONSTRAINT_LE; 7123 7124 pScan = idxMalloc(&rc, sizeof(IdxScan)); 7125 if( pScan ){ 7126 int i; 7127 7128 /* Link the new scan object into the list */ 7129 pScan->pTab = p->pTab; 7130 pScan->pNextScan = p->pExpert->pScan; 7131 p->pExpert->pScan = pScan; 7132 7133 /* Add the constraints to the IdxScan object */ 7134 for(i=0; i<pIdxInfo->nConstraint; i++){ 7135 struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i]; 7136 if( pCons->usable 7137 && pCons->iColumn>=0 7138 && p->pTab->aCol[pCons->iColumn].iPk==0 7139 && (pCons->op & opmask) 7140 ){ 7141 IdxConstraint *pNew; 7142 const char *zColl = sqlite3_vtab_collation(pIdxInfo, i); 7143 pNew = idxNewConstraint(&rc, zColl); 7144 if( pNew ){ 7145 pNew->iCol = pCons->iColumn; 7146 if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 7147 pNew->pNext = pScan->pEq; 7148 pScan->pEq = pNew; 7149 }else{ 7150 pNew->bRange = 1; 7151 pNew->pNext = pScan->pRange; 7152 pScan->pRange = pNew; 7153 } 7154 } 7155 n++; 7156 pIdxInfo->aConstraintUsage[i].argvIndex = n; 7157 } 7158 } 7159 7160 /* Add the ORDER BY to the IdxScan object */ 7161 for(i=pIdxInfo->nOrderBy-1; i>=0; i--){ 7162 int iCol = pIdxInfo->aOrderBy[i].iColumn; 7163 if( iCol>=0 ){ 7164 IdxConstraint *pNew = idxNewConstraint(&rc, p->pTab->aCol[iCol].zColl); 7165 if( pNew ){ 7166 pNew->iCol = iCol; 7167 pNew->bDesc = pIdxInfo->aOrderBy[i].desc; 7168 pNew->pNext = pScan->pOrder; 7169 pNew->pLink = pScan->pOrder; 7170 pScan->pOrder = pNew; 7171 n++; 7172 } 7173 } 7174 } 7175 } 7176 7177 pIdxInfo->estimatedCost = 1000000.0 / (n+1); 7178 return rc; 7179 } 7180 7181 static int expertUpdate( 7182 sqlite3_vtab *pVtab, 7183 int nData, 7184 sqlite3_value **azData, 7185 sqlite_int64 *pRowid 7186 ){ 7187 (void)pVtab; 7188 (void)nData; 7189 (void)azData; 7190 (void)pRowid; 7191 return SQLITE_OK; 7192 } 7193 7194 /* 7195 ** Virtual table module xOpen method. 7196 */ 7197 static int expertOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ 7198 int rc = SQLITE_OK; 7199 ExpertCsr *pCsr; 7200 (void)pVTab; 7201 pCsr = idxMalloc(&rc, sizeof(ExpertCsr)); 7202 *ppCursor = (sqlite3_vtab_cursor*)pCsr; 7203 return rc; 7204 } 7205 7206 /* 7207 ** Virtual table module xClose method. 7208 */ 7209 static int expertClose(sqlite3_vtab_cursor *cur){ 7210 ExpertCsr *pCsr = (ExpertCsr*)cur; 7211 sqlite3_finalize(pCsr->pData); 7212 sqlite3_free(pCsr); 7213 return SQLITE_OK; 7214 } 7215 7216 /* 7217 ** Virtual table module xEof method. 7218 ** 7219 ** Return non-zero if the cursor does not currently point to a valid 7220 ** record (i.e if the scan has finished), or zero otherwise. 7221 */ 7222 static int expertEof(sqlite3_vtab_cursor *cur){ 7223 ExpertCsr *pCsr = (ExpertCsr*)cur; 7224 return pCsr->pData==0; 7225 } 7226 7227 /* 7228 ** Virtual table module xNext method. 7229 */ 7230 static int expertNext(sqlite3_vtab_cursor *cur){ 7231 ExpertCsr *pCsr = (ExpertCsr*)cur; 7232 int rc = SQLITE_OK; 7233 7234 assert( pCsr->pData ); 7235 rc = sqlite3_step(pCsr->pData); 7236 if( rc!=SQLITE_ROW ){ 7237 rc = sqlite3_finalize(pCsr->pData); 7238 pCsr->pData = 0; 7239 }else{ 7240 rc = SQLITE_OK; 7241 } 7242 7243 return rc; 7244 } 7245 7246 /* 7247 ** Virtual table module xRowid method. 7248 */ 7249 static int expertRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 7250 (void)cur; 7251 *pRowid = 0; 7252 return SQLITE_OK; 7253 } 7254 7255 /* 7256 ** Virtual table module xColumn method. 7257 */ 7258 static int expertColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ 7259 ExpertCsr *pCsr = (ExpertCsr*)cur; 7260 sqlite3_value *pVal; 7261 pVal = sqlite3_column_value(pCsr->pData, i); 7262 if( pVal ){ 7263 sqlite3_result_value(ctx, pVal); 7264 } 7265 return SQLITE_OK; 7266 } 7267 7268 /* 7269 ** Virtual table module xFilter method. 7270 */ 7271 static int expertFilter( 7272 sqlite3_vtab_cursor *cur, 7273 int idxNum, const char *idxStr, 7274 int argc, sqlite3_value **argv 7275 ){ 7276 ExpertCsr *pCsr = (ExpertCsr*)cur; 7277 ExpertVtab *pVtab = (ExpertVtab*)(cur->pVtab); 7278 sqlite3expert *pExpert = pVtab->pExpert; 7279 int rc; 7280 7281 (void)idxNum; 7282 (void)idxStr; 7283 (void)argc; 7284 (void)argv; 7285 rc = sqlite3_finalize(pCsr->pData); 7286 pCsr->pData = 0; 7287 if( rc==SQLITE_OK ){ 7288 rc = idxPrintfPrepareStmt(pExpert->db, &pCsr->pData, &pVtab->base.zErrMsg, 7289 "SELECT * FROM main.%Q WHERE sample()", pVtab->pTab->zName 7290 ); 7291 } 7292 7293 if( rc==SQLITE_OK ){ 7294 rc = expertNext(cur); 7295 } 7296 return rc; 7297 } 7298 7299 static int idxRegisterVtab(sqlite3expert *p){ 7300 static sqlite3_module expertModule = { 7301 2, /* iVersion */ 7302 expertConnect, /* xCreate - create a table */ 7303 expertConnect, /* xConnect - connect to an existing table */ 7304 expertBestIndex, /* xBestIndex - Determine search strategy */ 7305 expertDisconnect, /* xDisconnect - Disconnect from a table */ 7306 expertDisconnect, /* xDestroy - Drop a table */ 7307 expertOpen, /* xOpen - open a cursor */ 7308 expertClose, /* xClose - close a cursor */ 7309 expertFilter, /* xFilter - configure scan constraints */ 7310 expertNext, /* xNext - advance a cursor */ 7311 expertEof, /* xEof */ 7312 expertColumn, /* xColumn - read data */ 7313 expertRowid, /* xRowid - read data */ 7314 expertUpdate, /* xUpdate - write data */ 7315 0, /* xBegin - begin transaction */ 7316 0, /* xSync - sync transaction */ 7317 0, /* xCommit - commit transaction */ 7318 0, /* xRollback - rollback transaction */ 7319 0, /* xFindFunction - function overloading */ 7320 0, /* xRename - rename the table */ 7321 0, /* xSavepoint */ 7322 0, /* xRelease */ 7323 0, /* xRollbackTo */ 7324 0, /* xShadowName */ 7325 }; 7326 7327 return sqlite3_create_module(p->dbv, "expert", &expertModule, (void*)p); 7328 } 7329 /* 7330 ** End of virtual table implementation. 7331 *************************************************************************/ 7332 /* 7333 ** Finalize SQL statement pStmt. If (*pRc) is SQLITE_OK when this function 7334 ** is called, set it to the return value of sqlite3_finalize() before 7335 ** returning. Otherwise, discard the sqlite3_finalize() return value. 7336 */ 7337 static void idxFinalize(int *pRc, sqlite3_stmt *pStmt){ 7338 int rc = sqlite3_finalize(pStmt); 7339 if( *pRc==SQLITE_OK ) *pRc = rc; 7340 } 7341 7342 /* 7343 ** Attempt to allocate an IdxTable structure corresponding to table zTab 7344 ** in the main database of connection db. If successful, set (*ppOut) to 7345 ** point to the new object and return SQLITE_OK. Otherwise, return an 7346 ** SQLite error code and set (*ppOut) to NULL. In this case *pzErrmsg may be 7347 ** set to point to an error string. 7348 ** 7349 ** It is the responsibility of the caller to eventually free either the 7350 ** IdxTable object or error message using sqlite3_free(). 7351 */ 7352 static int idxGetTableInfo( 7353 sqlite3 *db, /* Database connection to read details from */ 7354 const char *zTab, /* Table name */ 7355 IdxTable **ppOut, /* OUT: New object (if successful) */ 7356 char **pzErrmsg /* OUT: Error message (if not) */ 7357 ){ 7358 sqlite3_stmt *p1 = 0; 7359 int nCol = 0; 7360 int nTab = STRLEN(zTab); 7361 int nByte = sizeof(IdxTable) + nTab + 1; 7362 IdxTable *pNew = 0; 7363 int rc, rc2; 7364 char *pCsr = 0; 7365 7366 rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_info=%Q", zTab); 7367 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){ 7368 const char *zCol = (const char*)sqlite3_column_text(p1, 1); 7369 nByte += 1 + STRLEN(zCol); 7370 rc = sqlite3_table_column_metadata( 7371 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0 7372 ); 7373 nByte += 1 + STRLEN(zCol); 7374 nCol++; 7375 } 7376 rc2 = sqlite3_reset(p1); 7377 if( rc==SQLITE_OK ) rc = rc2; 7378 7379 nByte += sizeof(IdxColumn) * nCol; 7380 if( rc==SQLITE_OK ){ 7381 pNew = idxMalloc(&rc, nByte); 7382 } 7383 if( rc==SQLITE_OK ){ 7384 pNew->aCol = (IdxColumn*)&pNew[1]; 7385 pNew->nCol = nCol; 7386 pCsr = (char*)&pNew->aCol[nCol]; 7387 } 7388 7389 nCol = 0; 7390 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){ 7391 const char *zCol = (const char*)sqlite3_column_text(p1, 1); 7392 int nCopy = STRLEN(zCol) + 1; 7393 pNew->aCol[nCol].zName = pCsr; 7394 pNew->aCol[nCol].iPk = sqlite3_column_int(p1, 5); 7395 memcpy(pCsr, zCol, nCopy); 7396 pCsr += nCopy; 7397 7398 rc = sqlite3_table_column_metadata( 7399 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0 7400 ); 7401 if( rc==SQLITE_OK ){ 7402 nCopy = STRLEN(zCol) + 1; 7403 pNew->aCol[nCol].zColl = pCsr; 7404 memcpy(pCsr, zCol, nCopy); 7405 pCsr += nCopy; 7406 } 7407 7408 nCol++; 7409 } 7410 idxFinalize(&rc, p1); 7411 7412 if( rc!=SQLITE_OK ){ 7413 sqlite3_free(pNew); 7414 pNew = 0; 7415 }else{ 7416 pNew->zName = pCsr; 7417 memcpy(pNew->zName, zTab, nTab+1); 7418 } 7419 7420 *ppOut = pNew; 7421 return rc; 7422 } 7423 7424 /* 7425 ** This function is a no-op if *pRc is set to anything other than 7426 ** SQLITE_OK when it is called. 7427 ** 7428 ** If *pRc is initially set to SQLITE_OK, then the text specified by 7429 ** the printf() style arguments is appended to zIn and the result returned 7430 ** in a buffer allocated by sqlite3_malloc(). sqlite3_free() is called on 7431 ** zIn before returning. 7432 */ 7433 static char *idxAppendText(int *pRc, char *zIn, const char *zFmt, ...){ 7434 va_list ap; 7435 char *zAppend = 0; 7436 char *zRet = 0; 7437 int nIn = zIn ? STRLEN(zIn) : 0; 7438 int nAppend = 0; 7439 va_start(ap, zFmt); 7440 if( *pRc==SQLITE_OK ){ 7441 zAppend = sqlite3_vmprintf(zFmt, ap); 7442 if( zAppend ){ 7443 nAppend = STRLEN(zAppend); 7444 zRet = (char*)sqlite3_malloc(nIn + nAppend + 1); 7445 } 7446 if( zAppend && zRet ){ 7447 if( nIn ) memcpy(zRet, zIn, nIn); 7448 memcpy(&zRet[nIn], zAppend, nAppend+1); 7449 }else{ 7450 sqlite3_free(zRet); 7451 zRet = 0; 7452 *pRc = SQLITE_NOMEM; 7453 } 7454 sqlite3_free(zAppend); 7455 sqlite3_free(zIn); 7456 } 7457 va_end(ap); 7458 return zRet; 7459 } 7460 7461 /* 7462 ** Return true if zId must be quoted in order to use it as an SQL 7463 ** identifier, or false otherwise. 7464 */ 7465 static int idxIdentifierRequiresQuotes(const char *zId){ 7466 int i; 7467 for(i=0; zId[i]; i++){ 7468 if( !(zId[i]=='_') 7469 && !(zId[i]>='0' && zId[i]<='9') 7470 && !(zId[i]>='a' && zId[i]<='z') 7471 && !(zId[i]>='A' && zId[i]<='Z') 7472 ){ 7473 return 1; 7474 } 7475 } 7476 return 0; 7477 } 7478 7479 /* 7480 ** This function appends an index column definition suitable for constraint 7481 ** pCons to the string passed as zIn and returns the result. 7482 */ 7483 static char *idxAppendColDefn( 7484 int *pRc, /* IN/OUT: Error code */ 7485 char *zIn, /* Column defn accumulated so far */ 7486 IdxTable *pTab, /* Table index will be created on */ 7487 IdxConstraint *pCons 7488 ){ 7489 char *zRet = zIn; 7490 IdxColumn *p = &pTab->aCol[pCons->iCol]; 7491 if( zRet ) zRet = idxAppendText(pRc, zRet, ", "); 7492 7493 if( idxIdentifierRequiresQuotes(p->zName) ){ 7494 zRet = idxAppendText(pRc, zRet, "%Q", p->zName); 7495 }else{ 7496 zRet = idxAppendText(pRc, zRet, "%s", p->zName); 7497 } 7498 7499 if( sqlite3_stricmp(p->zColl, pCons->zColl) ){ 7500 if( idxIdentifierRequiresQuotes(pCons->zColl) ){ 7501 zRet = idxAppendText(pRc, zRet, " COLLATE %Q", pCons->zColl); 7502 }else{ 7503 zRet = idxAppendText(pRc, zRet, " COLLATE %s", pCons->zColl); 7504 } 7505 } 7506 7507 if( pCons->bDesc ){ 7508 zRet = idxAppendText(pRc, zRet, " DESC"); 7509 } 7510 return zRet; 7511 } 7512 7513 /* 7514 ** Search database dbm for an index compatible with the one idxCreateFromCons() 7515 ** would create from arguments pScan, pEq and pTail. If no error occurs and 7516 ** such an index is found, return non-zero. Or, if no such index is found, 7517 ** return zero. 7518 ** 7519 ** If an error occurs, set *pRc to an SQLite error code and return zero. 7520 */ 7521 static int idxFindCompatible( 7522 int *pRc, /* OUT: Error code */ 7523 sqlite3* dbm, /* Database to search */ 7524 IdxScan *pScan, /* Scan for table to search for index on */ 7525 IdxConstraint *pEq, /* List of == constraints */ 7526 IdxConstraint *pTail /* List of range constraints */ 7527 ){ 7528 const char *zTbl = pScan->pTab->zName; 7529 sqlite3_stmt *pIdxList = 0; 7530 IdxConstraint *pIter; 7531 int nEq = 0; /* Number of elements in pEq */ 7532 int rc; 7533 7534 /* Count the elements in list pEq */ 7535 for(pIter=pEq; pIter; pIter=pIter->pLink) nEq++; 7536 7537 rc = idxPrintfPrepareStmt(dbm, &pIdxList, 0, "PRAGMA index_list=%Q", zTbl); 7538 while( rc==SQLITE_OK && sqlite3_step(pIdxList)==SQLITE_ROW ){ 7539 int bMatch = 1; 7540 IdxConstraint *pT = pTail; 7541 sqlite3_stmt *pInfo = 0; 7542 const char *zIdx = (const char*)sqlite3_column_text(pIdxList, 1); 7543 7544 /* Zero the IdxConstraint.bFlag values in the pEq list */ 7545 for(pIter=pEq; pIter; pIter=pIter->pLink) pIter->bFlag = 0; 7546 7547 rc = idxPrintfPrepareStmt(dbm, &pInfo, 0, "PRAGMA index_xInfo=%Q", zIdx); 7548 while( rc==SQLITE_OK && sqlite3_step(pInfo)==SQLITE_ROW ){ 7549 int iIdx = sqlite3_column_int(pInfo, 0); 7550 int iCol = sqlite3_column_int(pInfo, 1); 7551 const char *zColl = (const char*)sqlite3_column_text(pInfo, 4); 7552 7553 if( iIdx<nEq ){ 7554 for(pIter=pEq; pIter; pIter=pIter->pLink){ 7555 if( pIter->bFlag ) continue; 7556 if( pIter->iCol!=iCol ) continue; 7557 if( sqlite3_stricmp(pIter->zColl, zColl) ) continue; 7558 pIter->bFlag = 1; 7559 break; 7560 } 7561 if( pIter==0 ){ 7562 bMatch = 0; 7563 break; 7564 } 7565 }else{ 7566 if( pT ){ 7567 if( pT->iCol!=iCol || sqlite3_stricmp(pT->zColl, zColl) ){ 7568 bMatch = 0; 7569 break; 7570 } 7571 pT = pT->pLink; 7572 } 7573 } 7574 } 7575 idxFinalize(&rc, pInfo); 7576 7577 if( rc==SQLITE_OK && bMatch ){ 7578 sqlite3_finalize(pIdxList); 7579 return 1; 7580 } 7581 } 7582 idxFinalize(&rc, pIdxList); 7583 7584 *pRc = rc; 7585 return 0; 7586 } 7587 7588 static int idxCreateFromCons( 7589 sqlite3expert *p, 7590 IdxScan *pScan, 7591 IdxConstraint *pEq, 7592 IdxConstraint *pTail 7593 ){ 7594 sqlite3 *dbm = p->dbm; 7595 int rc = SQLITE_OK; 7596 if( (pEq || pTail) && 0==idxFindCompatible(&rc, dbm, pScan, pEq, pTail) ){ 7597 IdxTable *pTab = pScan->pTab; 7598 char *zCols = 0; 7599 char *zIdx = 0; 7600 IdxConstraint *pCons; 7601 unsigned int h = 0; 7602 const char *zFmt; 7603 7604 for(pCons=pEq; pCons; pCons=pCons->pLink){ 7605 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons); 7606 } 7607 for(pCons=pTail; pCons; pCons=pCons->pLink){ 7608 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons); 7609 } 7610 7611 if( rc==SQLITE_OK ){ 7612 /* Hash the list of columns to come up with a name for the index */ 7613 const char *zTable = pScan->pTab->zName; 7614 char *zName; /* Index name */ 7615 int i; 7616 for(i=0; zCols[i]; i++){ 7617 h += ((h<<3) + zCols[i]); 7618 } 7619 zName = sqlite3_mprintf("%s_idx_%08x", zTable, h); 7620 if( zName==0 ){ 7621 rc = SQLITE_NOMEM; 7622 }else{ 7623 if( idxIdentifierRequiresQuotes(zTable) ){ 7624 zFmt = "CREATE INDEX '%q' ON %Q(%s)"; 7625 }else{ 7626 zFmt = "CREATE INDEX %s ON %s(%s)"; 7627 } 7628 zIdx = sqlite3_mprintf(zFmt, zName, zTable, zCols); 7629 if( !zIdx ){ 7630 rc = SQLITE_NOMEM; 7631 }else{ 7632 rc = sqlite3_exec(dbm, zIdx, 0, 0, p->pzErrmsg); 7633 idxHashAdd(&rc, &p->hIdx, zName, zIdx); 7634 } 7635 sqlite3_free(zName); 7636 sqlite3_free(zIdx); 7637 } 7638 } 7639 7640 sqlite3_free(zCols); 7641 } 7642 return rc; 7643 } 7644 7645 /* 7646 ** Return true if list pList (linked by IdxConstraint.pLink) contains 7647 ** a constraint compatible with *p. Otherwise return false. 7648 */ 7649 static int idxFindConstraint(IdxConstraint *pList, IdxConstraint *p){ 7650 IdxConstraint *pCmp; 7651 for(pCmp=pList; pCmp; pCmp=pCmp->pLink){ 7652 if( p->iCol==pCmp->iCol ) return 1; 7653 } 7654 return 0; 7655 } 7656 7657 static int idxCreateFromWhere( 7658 sqlite3expert *p, 7659 IdxScan *pScan, /* Create indexes for this scan */ 7660 IdxConstraint *pTail /* range/ORDER BY constraints for inclusion */ 7661 ){ 7662 IdxConstraint *p1 = 0; 7663 IdxConstraint *pCon; 7664 int rc; 7665 7666 /* Gather up all the == constraints. */ 7667 for(pCon=pScan->pEq; pCon; pCon=pCon->pNext){ 7668 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){ 7669 pCon->pLink = p1; 7670 p1 = pCon; 7671 } 7672 } 7673 7674 /* Create an index using the == constraints collected above. And the 7675 ** range constraint/ORDER BY terms passed in by the caller, if any. */ 7676 rc = idxCreateFromCons(p, pScan, p1, pTail); 7677 7678 /* If no range/ORDER BY passed by the caller, create a version of the 7679 ** index for each range constraint. */ 7680 if( pTail==0 ){ 7681 for(pCon=pScan->pRange; rc==SQLITE_OK && pCon; pCon=pCon->pNext){ 7682 assert( pCon->pLink==0 ); 7683 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){ 7684 rc = idxCreateFromCons(p, pScan, p1, pCon); 7685 } 7686 } 7687 } 7688 7689 return rc; 7690 } 7691 7692 /* 7693 ** Create candidate indexes in database [dbm] based on the data in 7694 ** linked-list pScan. 7695 */ 7696 static int idxCreateCandidates(sqlite3expert *p){ 7697 int rc = SQLITE_OK; 7698 IdxScan *pIter; 7699 7700 for(pIter=p->pScan; pIter && rc==SQLITE_OK; pIter=pIter->pNextScan){ 7701 rc = idxCreateFromWhere(p, pIter, 0); 7702 if( rc==SQLITE_OK && pIter->pOrder ){ 7703 rc = idxCreateFromWhere(p, pIter, pIter->pOrder); 7704 } 7705 } 7706 7707 return rc; 7708 } 7709 7710 /* 7711 ** Free all elements of the linked list starting at pConstraint. 7712 */ 7713 static void idxConstraintFree(IdxConstraint *pConstraint){ 7714 IdxConstraint *pNext; 7715 IdxConstraint *p; 7716 7717 for(p=pConstraint; p; p=pNext){ 7718 pNext = p->pNext; 7719 sqlite3_free(p); 7720 } 7721 } 7722 7723 /* 7724 ** Free all elements of the linked list starting from pScan up until pLast 7725 ** (pLast is not freed). 7726 */ 7727 static void idxScanFree(IdxScan *pScan, IdxScan *pLast){ 7728 IdxScan *p; 7729 IdxScan *pNext; 7730 for(p=pScan; p!=pLast; p=pNext){ 7731 pNext = p->pNextScan; 7732 idxConstraintFree(p->pOrder); 7733 idxConstraintFree(p->pEq); 7734 idxConstraintFree(p->pRange); 7735 sqlite3_free(p); 7736 } 7737 } 7738 7739 /* 7740 ** Free all elements of the linked list starting from pStatement up 7741 ** until pLast (pLast is not freed). 7742 */ 7743 static void idxStatementFree(IdxStatement *pStatement, IdxStatement *pLast){ 7744 IdxStatement *p; 7745 IdxStatement *pNext; 7746 for(p=pStatement; p!=pLast; p=pNext){ 7747 pNext = p->pNext; 7748 sqlite3_free(p->zEQP); 7749 sqlite3_free(p->zIdx); 7750 sqlite3_free(p); 7751 } 7752 } 7753 7754 /* 7755 ** Free the linked list of IdxTable objects starting at pTab. 7756 */ 7757 static void idxTableFree(IdxTable *pTab){ 7758 IdxTable *pIter; 7759 IdxTable *pNext; 7760 for(pIter=pTab; pIter; pIter=pNext){ 7761 pNext = pIter->pNext; 7762 sqlite3_free(pIter); 7763 } 7764 } 7765 7766 /* 7767 ** Free the linked list of IdxWrite objects starting at pTab. 7768 */ 7769 static void idxWriteFree(IdxWrite *pTab){ 7770 IdxWrite *pIter; 7771 IdxWrite *pNext; 7772 for(pIter=pTab; pIter; pIter=pNext){ 7773 pNext = pIter->pNext; 7774 sqlite3_free(pIter); 7775 } 7776 } 7777 7778 7779 7780 /* 7781 ** This function is called after candidate indexes have been created. It 7782 ** runs all the queries to see which indexes they prefer, and populates 7783 ** IdxStatement.zIdx and IdxStatement.zEQP with the results. 7784 */ 7785 int idxFindIndexes( 7786 sqlite3expert *p, 7787 char **pzErr /* OUT: Error message (sqlite3_malloc) */ 7788 ){ 7789 IdxStatement *pStmt; 7790 sqlite3 *dbm = p->dbm; 7791 int rc = SQLITE_OK; 7792 7793 IdxHash hIdx; 7794 idxHashInit(&hIdx); 7795 7796 for(pStmt=p->pStatement; rc==SQLITE_OK && pStmt; pStmt=pStmt->pNext){ 7797 IdxHashEntry *pEntry; 7798 sqlite3_stmt *pExplain = 0; 7799 idxHashClear(&hIdx); 7800 rc = idxPrintfPrepareStmt(dbm, &pExplain, pzErr, 7801 "EXPLAIN QUERY PLAN %s", pStmt->zSql 7802 ); 7803 while( rc==SQLITE_OK && sqlite3_step(pExplain)==SQLITE_ROW ){ 7804 /* int iId = sqlite3_column_int(pExplain, 0); */ 7805 /* int iParent = sqlite3_column_int(pExplain, 1); */ 7806 /* int iNotUsed = sqlite3_column_int(pExplain, 2); */ 7807 const char *zDetail = (const char*)sqlite3_column_text(pExplain, 3); 7808 int nDetail = STRLEN(zDetail); 7809 int i; 7810 7811 for(i=0; i<nDetail; i++){ 7812 const char *zIdx = 0; 7813 if( memcmp(&zDetail[i], " USING INDEX ", 13)==0 ){ 7814 zIdx = &zDetail[i+13]; 7815 }else if( memcmp(&zDetail[i], " USING COVERING INDEX ", 22)==0 ){ 7816 zIdx = &zDetail[i+22]; 7817 } 7818 if( zIdx ){ 7819 const char *zSql; 7820 int nIdx = 0; 7821 while( zIdx[nIdx]!='\0' && (zIdx[nIdx]!=' ' || zIdx[nIdx+1]!='(') ){ 7822 nIdx++; 7823 } 7824 zSql = idxHashSearch(&p->hIdx, zIdx, nIdx); 7825 if( zSql ){ 7826 idxHashAdd(&rc, &hIdx, zSql, 0); 7827 if( rc ) goto find_indexes_out; 7828 } 7829 break; 7830 } 7831 } 7832 7833 if( zDetail[0]!='-' ){ 7834 pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail); 7835 } 7836 } 7837 7838 for(pEntry=hIdx.pFirst; pEntry; pEntry=pEntry->pNext){ 7839 pStmt->zIdx = idxAppendText(&rc, pStmt->zIdx, "%s;\n", pEntry->zKey); 7840 } 7841 7842 idxFinalize(&rc, pExplain); 7843 } 7844 7845 find_indexes_out: 7846 idxHashClear(&hIdx); 7847 return rc; 7848 } 7849 7850 static int idxAuthCallback( 7851 void *pCtx, 7852 int eOp, 7853 const char *z3, 7854 const char *z4, 7855 const char *zDb, 7856 const char *zTrigger 7857 ){ 7858 int rc = SQLITE_OK; 7859 (void)z4; 7860 (void)zTrigger; 7861 if( eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE || eOp==SQLITE_DELETE ){ 7862 if( sqlite3_stricmp(zDb, "main")==0 ){ 7863 sqlite3expert *p = (sqlite3expert*)pCtx; 7864 IdxTable *pTab; 7865 for(pTab=p->pTable; pTab; pTab=pTab->pNext){ 7866 if( 0==sqlite3_stricmp(z3, pTab->zName) ) break; 7867 } 7868 if( pTab ){ 7869 IdxWrite *pWrite; 7870 for(pWrite=p->pWrite; pWrite; pWrite=pWrite->pNext){ 7871 if( pWrite->pTab==pTab && pWrite->eOp==eOp ) break; 7872 } 7873 if( pWrite==0 ){ 7874 pWrite = idxMalloc(&rc, sizeof(IdxWrite)); 7875 if( rc==SQLITE_OK ){ 7876 pWrite->pTab = pTab; 7877 pWrite->eOp = eOp; 7878 pWrite->pNext = p->pWrite; 7879 p->pWrite = pWrite; 7880 } 7881 } 7882 } 7883 } 7884 } 7885 return rc; 7886 } 7887 7888 static int idxProcessOneTrigger( 7889 sqlite3expert *p, 7890 IdxWrite *pWrite, 7891 char **pzErr 7892 ){ 7893 static const char *zInt = UNIQUE_TABLE_NAME; 7894 static const char *zDrop = "DROP TABLE " UNIQUE_TABLE_NAME; 7895 IdxTable *pTab = pWrite->pTab; 7896 const char *zTab = pTab->zName; 7897 const char *zSql = 7898 "SELECT 'CREATE TEMP' || substr(sql, 7) FROM sqlite_master " 7899 "WHERE tbl_name = %Q AND type IN ('table', 'trigger') " 7900 "ORDER BY type;"; 7901 sqlite3_stmt *pSelect = 0; 7902 int rc = SQLITE_OK; 7903 char *zWrite = 0; 7904 7905 /* Create the table and its triggers in the temp schema */ 7906 rc = idxPrintfPrepareStmt(p->db, &pSelect, pzErr, zSql, zTab, zTab); 7907 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSelect) ){ 7908 const char *zCreate = (const char*)sqlite3_column_text(pSelect, 0); 7909 rc = sqlite3_exec(p->dbv, zCreate, 0, 0, pzErr); 7910 } 7911 idxFinalize(&rc, pSelect); 7912 7913 /* Rename the table in the temp schema to zInt */ 7914 if( rc==SQLITE_OK ){ 7915 char *z = sqlite3_mprintf("ALTER TABLE temp.%Q RENAME TO %Q", zTab, zInt); 7916 if( z==0 ){ 7917 rc = SQLITE_NOMEM; 7918 }else{ 7919 rc = sqlite3_exec(p->dbv, z, 0, 0, pzErr); 7920 sqlite3_free(z); 7921 } 7922 } 7923 7924 switch( pWrite->eOp ){ 7925 case SQLITE_INSERT: { 7926 int i; 7927 zWrite = idxAppendText(&rc, zWrite, "INSERT INTO %Q VALUES(", zInt); 7928 for(i=0; i<pTab->nCol; i++){ 7929 zWrite = idxAppendText(&rc, zWrite, "%s?", i==0 ? "" : ", "); 7930 } 7931 zWrite = idxAppendText(&rc, zWrite, ")"); 7932 break; 7933 } 7934 case SQLITE_UPDATE: { 7935 int i; 7936 zWrite = idxAppendText(&rc, zWrite, "UPDATE %Q SET ", zInt); 7937 for(i=0; i<pTab->nCol; i++){ 7938 zWrite = idxAppendText(&rc, zWrite, "%s%Q=?", i==0 ? "" : ", ", 7939 pTab->aCol[i].zName 7940 ); 7941 } 7942 break; 7943 } 7944 default: { 7945 assert( pWrite->eOp==SQLITE_DELETE ); 7946 if( rc==SQLITE_OK ){ 7947 zWrite = sqlite3_mprintf("DELETE FROM %Q", zInt); 7948 if( zWrite==0 ) rc = SQLITE_NOMEM; 7949 } 7950 } 7951 } 7952 7953 if( rc==SQLITE_OK ){ 7954 sqlite3_stmt *pX = 0; 7955 rc = sqlite3_prepare_v2(p->dbv, zWrite, -1, &pX, 0); 7956 idxFinalize(&rc, pX); 7957 if( rc!=SQLITE_OK ){ 7958 idxDatabaseError(p->dbv, pzErr); 7959 } 7960 } 7961 sqlite3_free(zWrite); 7962 7963 if( rc==SQLITE_OK ){ 7964 rc = sqlite3_exec(p->dbv, zDrop, 0, 0, pzErr); 7965 } 7966 7967 return rc; 7968 } 7969 7970 static int idxProcessTriggers(sqlite3expert *p, char **pzErr){ 7971 int rc = SQLITE_OK; 7972 IdxWrite *pEnd = 0; 7973 IdxWrite *pFirst = p->pWrite; 7974 7975 while( rc==SQLITE_OK && pFirst!=pEnd ){ 7976 IdxWrite *pIter; 7977 for(pIter=pFirst; rc==SQLITE_OK && pIter!=pEnd; pIter=pIter->pNext){ 7978 rc = idxProcessOneTrigger(p, pIter, pzErr); 7979 } 7980 pEnd = pFirst; 7981 pFirst = p->pWrite; 7982 } 7983 7984 return rc; 7985 } 7986 7987 7988 static int idxCreateVtabSchema(sqlite3expert *p, char **pzErrmsg){ 7989 int rc = idxRegisterVtab(p); 7990 sqlite3_stmt *pSchema = 0; 7991 7992 /* For each table in the main db schema: 7993 ** 7994 ** 1) Add an entry to the p->pTable list, and 7995 ** 2) Create the equivalent virtual table in dbv. 7996 */ 7997 rc = idxPrepareStmt(p->db, &pSchema, pzErrmsg, 7998 "SELECT type, name, sql, 1 FROM sqlite_master " 7999 "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%%' " 8000 " UNION ALL " 8001 "SELECT type, name, sql, 2 FROM sqlite_master " 8002 "WHERE type = 'trigger'" 8003 " AND tbl_name IN(SELECT name FROM sqlite_master WHERE type = 'view') " 8004 "ORDER BY 4, 1" 8005 ); 8006 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSchema) ){ 8007 const char *zType = (const char*)sqlite3_column_text(pSchema, 0); 8008 const char *zName = (const char*)sqlite3_column_text(pSchema, 1); 8009 const char *zSql = (const char*)sqlite3_column_text(pSchema, 2); 8010 8011 if( zType[0]=='v' || zType[1]=='r' ){ 8012 rc = sqlite3_exec(p->dbv, zSql, 0, 0, pzErrmsg); 8013 }else{ 8014 IdxTable *pTab; 8015 rc = idxGetTableInfo(p->db, zName, &pTab, pzErrmsg); 8016 if( rc==SQLITE_OK ){ 8017 int i; 8018 char *zInner = 0; 8019 char *zOuter = 0; 8020 pTab->pNext = p->pTable; 8021 p->pTable = pTab; 8022 8023 /* The statement the vtab will pass to sqlite3_declare_vtab() */ 8024 zInner = idxAppendText(&rc, 0, "CREATE TABLE x("); 8025 for(i=0; i<pTab->nCol; i++){ 8026 zInner = idxAppendText(&rc, zInner, "%s%Q COLLATE %s", 8027 (i==0 ? "" : ", "), pTab->aCol[i].zName, pTab->aCol[i].zColl 8028 ); 8029 } 8030 zInner = idxAppendText(&rc, zInner, ")"); 8031 8032 /* The CVT statement to create the vtab */ 8033 zOuter = idxAppendText(&rc, 0, 8034 "CREATE VIRTUAL TABLE %Q USING expert(%Q)", zName, zInner 8035 ); 8036 if( rc==SQLITE_OK ){ 8037 rc = sqlite3_exec(p->dbv, zOuter, 0, 0, pzErrmsg); 8038 } 8039 sqlite3_free(zInner); 8040 sqlite3_free(zOuter); 8041 } 8042 } 8043 } 8044 idxFinalize(&rc, pSchema); 8045 return rc; 8046 } 8047 8048 struct IdxSampleCtx { 8049 int iTarget; 8050 double target; /* Target nRet/nRow value */ 8051 double nRow; /* Number of rows seen */ 8052 double nRet; /* Number of rows returned */ 8053 }; 8054 8055 static void idxSampleFunc( 8056 sqlite3_context *pCtx, 8057 int argc, 8058 sqlite3_value **argv 8059 ){ 8060 struct IdxSampleCtx *p = (struct IdxSampleCtx*)sqlite3_user_data(pCtx); 8061 int bRet; 8062 8063 (void)argv; 8064 assert( argc==0 ); 8065 if( p->nRow==0.0 ){ 8066 bRet = 1; 8067 }else{ 8068 bRet = (p->nRet / p->nRow) <= p->target; 8069 if( bRet==0 ){ 8070 unsigned short rnd; 8071 sqlite3_randomness(2, (void*)&rnd); 8072 bRet = ((int)rnd % 100) <= p->iTarget; 8073 } 8074 } 8075 8076 sqlite3_result_int(pCtx, bRet); 8077 p->nRow += 1.0; 8078 p->nRet += (double)bRet; 8079 } 8080 8081 struct IdxRemCtx { 8082 int nSlot; 8083 struct IdxRemSlot { 8084 int eType; /* SQLITE_NULL, INTEGER, REAL, TEXT, BLOB */ 8085 i64 iVal; /* SQLITE_INTEGER value */ 8086 double rVal; /* SQLITE_FLOAT value */ 8087 int nByte; /* Bytes of space allocated at z */ 8088 int n; /* Size of buffer z */ 8089 char *z; /* SQLITE_TEXT/BLOB value */ 8090 } aSlot[1]; 8091 }; 8092 8093 /* 8094 ** Implementation of scalar function rem(). 8095 */ 8096 static void idxRemFunc( 8097 sqlite3_context *pCtx, 8098 int argc, 8099 sqlite3_value **argv 8100 ){ 8101 struct IdxRemCtx *p = (struct IdxRemCtx*)sqlite3_user_data(pCtx); 8102 struct IdxRemSlot *pSlot; 8103 int iSlot; 8104 assert( argc==2 ); 8105 8106 iSlot = sqlite3_value_int(argv[0]); 8107 assert( iSlot<=p->nSlot ); 8108 pSlot = &p->aSlot[iSlot]; 8109 8110 switch( pSlot->eType ){ 8111 case SQLITE_NULL: 8112 /* no-op */ 8113 break; 8114 8115 case SQLITE_INTEGER: 8116 sqlite3_result_int64(pCtx, pSlot->iVal); 8117 break; 8118 8119 case SQLITE_FLOAT: 8120 sqlite3_result_double(pCtx, pSlot->rVal); 8121 break; 8122 8123 case SQLITE_BLOB: 8124 sqlite3_result_blob(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT); 8125 break; 8126 8127 case SQLITE_TEXT: 8128 sqlite3_result_text(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT); 8129 break; 8130 } 8131 8132 pSlot->eType = sqlite3_value_type(argv[1]); 8133 switch( pSlot->eType ){ 8134 case SQLITE_NULL: 8135 /* no-op */ 8136 break; 8137 8138 case SQLITE_INTEGER: 8139 pSlot->iVal = sqlite3_value_int64(argv[1]); 8140 break; 8141 8142 case SQLITE_FLOAT: 8143 pSlot->rVal = sqlite3_value_double(argv[1]); 8144 break; 8145 8146 case SQLITE_BLOB: 8147 case SQLITE_TEXT: { 8148 int nByte = sqlite3_value_bytes(argv[1]); 8149 if( nByte>pSlot->nByte ){ 8150 char *zNew = (char*)sqlite3_realloc(pSlot->z, nByte*2); 8151 if( zNew==0 ){ 8152 sqlite3_result_error_nomem(pCtx); 8153 return; 8154 } 8155 pSlot->nByte = nByte*2; 8156 pSlot->z = zNew; 8157 } 8158 pSlot->n = nByte; 8159 if( pSlot->eType==SQLITE_BLOB ){ 8160 memcpy(pSlot->z, sqlite3_value_blob(argv[1]), nByte); 8161 }else{ 8162 memcpy(pSlot->z, sqlite3_value_text(argv[1]), nByte); 8163 } 8164 break; 8165 } 8166 } 8167 } 8168 8169 static int idxLargestIndex(sqlite3 *db, int *pnMax, char **pzErr){ 8170 int rc = SQLITE_OK; 8171 const char *zMax = 8172 "SELECT max(i.seqno) FROM " 8173 " sqlite_master AS s, " 8174 " pragma_index_list(s.name) AS l, " 8175 " pragma_index_info(l.name) AS i " 8176 "WHERE s.type = 'table'"; 8177 sqlite3_stmt *pMax = 0; 8178 8179 *pnMax = 0; 8180 rc = idxPrepareStmt(db, &pMax, pzErr, zMax); 8181 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ 8182 *pnMax = sqlite3_column_int(pMax, 0) + 1; 8183 } 8184 idxFinalize(&rc, pMax); 8185 8186 return rc; 8187 } 8188 8189 static int idxPopulateOneStat1( 8190 sqlite3expert *p, 8191 sqlite3_stmt *pIndexXInfo, 8192 sqlite3_stmt *pWriteStat, 8193 const char *zTab, 8194 const char *zIdx, 8195 char **pzErr 8196 ){ 8197 char *zCols = 0; 8198 char *zOrder = 0; 8199 char *zQuery = 0; 8200 int nCol = 0; 8201 int i; 8202 sqlite3_stmt *pQuery = 0; 8203 int *aStat = 0; 8204 int rc = SQLITE_OK; 8205 8206 assert( p->iSample>0 ); 8207 8208 /* Formulate the query text */ 8209 sqlite3_bind_text(pIndexXInfo, 1, zIdx, -1, SQLITE_STATIC); 8210 while( SQLITE_OK==rc && SQLITE_ROW==sqlite3_step(pIndexXInfo) ){ 8211 const char *zComma = zCols==0 ? "" : ", "; 8212 const char *zName = (const char*)sqlite3_column_text(pIndexXInfo, 0); 8213 const char *zColl = (const char*)sqlite3_column_text(pIndexXInfo, 1); 8214 zCols = idxAppendText(&rc, zCols, 8215 "%sx.%Q IS rem(%d, x.%Q) COLLATE %s", zComma, zName, nCol, zName, zColl 8216 ); 8217 zOrder = idxAppendText(&rc, zOrder, "%s%d", zComma, ++nCol); 8218 } 8219 sqlite3_reset(pIndexXInfo); 8220 if( rc==SQLITE_OK ){ 8221 if( p->iSample==100 ){ 8222 zQuery = sqlite3_mprintf( 8223 "SELECT %s FROM %Q x ORDER BY %s", zCols, zTab, zOrder 8224 ); 8225 }else{ 8226 zQuery = sqlite3_mprintf( 8227 "SELECT %s FROM temp."UNIQUE_TABLE_NAME" x ORDER BY %s", zCols, zOrder 8228 ); 8229 } 8230 } 8231 sqlite3_free(zCols); 8232 sqlite3_free(zOrder); 8233 8234 /* Formulate the query text */ 8235 if( rc==SQLITE_OK ){ 8236 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv); 8237 rc = idxPrepareStmt(dbrem, &pQuery, pzErr, zQuery); 8238 } 8239 sqlite3_free(zQuery); 8240 8241 if( rc==SQLITE_OK ){ 8242 aStat = (int*)idxMalloc(&rc, sizeof(int)*(nCol+1)); 8243 } 8244 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){ 8245 IdxHashEntry *pEntry; 8246 char *zStat = 0; 8247 for(i=0; i<=nCol; i++) aStat[i] = 1; 8248 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){ 8249 aStat[0]++; 8250 for(i=0; i<nCol; i++){ 8251 if( sqlite3_column_int(pQuery, i)==0 ) break; 8252 } 8253 for(/*no-op*/; i<nCol; i++){ 8254 aStat[i+1]++; 8255 } 8256 } 8257 8258 if( rc==SQLITE_OK ){ 8259 int s0 = aStat[0]; 8260 zStat = sqlite3_mprintf("%d", s0); 8261 if( zStat==0 ) rc = SQLITE_NOMEM; 8262 for(i=1; rc==SQLITE_OK && i<=nCol; i++){ 8263 zStat = idxAppendText(&rc, zStat, " %d", (s0+aStat[i]/2) / aStat[i]); 8264 } 8265 } 8266 8267 if( rc==SQLITE_OK ){ 8268 sqlite3_bind_text(pWriteStat, 1, zTab, -1, SQLITE_STATIC); 8269 sqlite3_bind_text(pWriteStat, 2, zIdx, -1, SQLITE_STATIC); 8270 sqlite3_bind_text(pWriteStat, 3, zStat, -1, SQLITE_STATIC); 8271 sqlite3_step(pWriteStat); 8272 rc = sqlite3_reset(pWriteStat); 8273 } 8274 8275 pEntry = idxHashFind(&p->hIdx, zIdx, STRLEN(zIdx)); 8276 if( pEntry ){ 8277 assert( pEntry->zVal2==0 ); 8278 pEntry->zVal2 = zStat; 8279 }else{ 8280 sqlite3_free(zStat); 8281 } 8282 } 8283 sqlite3_free(aStat); 8284 idxFinalize(&rc, pQuery); 8285 8286 return rc; 8287 } 8288 8289 static int idxBuildSampleTable(sqlite3expert *p, const char *zTab){ 8290 int rc; 8291 char *zSql; 8292 8293 rc = sqlite3_exec(p->dbv,"DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0); 8294 if( rc!=SQLITE_OK ) return rc; 8295 8296 zSql = sqlite3_mprintf( 8297 "CREATE TABLE temp." UNIQUE_TABLE_NAME " AS SELECT * FROM %Q", zTab 8298 ); 8299 if( zSql==0 ) return SQLITE_NOMEM; 8300 rc = sqlite3_exec(p->dbv, zSql, 0, 0, 0); 8301 sqlite3_free(zSql); 8302 8303 return rc; 8304 } 8305 8306 /* 8307 ** This function is called as part of sqlite3_expert_analyze(). Candidate 8308 ** indexes have already been created in database sqlite3expert.dbm, this 8309 ** function populates sqlite_stat1 table in the same database. 8310 ** 8311 ** The stat1 data is generated by querying the 8312 */ 8313 static int idxPopulateStat1(sqlite3expert *p, char **pzErr){ 8314 int rc = SQLITE_OK; 8315 int nMax =0; 8316 struct IdxRemCtx *pCtx = 0; 8317 struct IdxSampleCtx samplectx; 8318 int i; 8319 i64 iPrev = -100000; 8320 sqlite3_stmt *pAllIndex = 0; 8321 sqlite3_stmt *pIndexXInfo = 0; 8322 sqlite3_stmt *pWrite = 0; 8323 8324 const char *zAllIndex = 8325 "SELECT s.rowid, s.name, l.name FROM " 8326 " sqlite_master AS s, " 8327 " pragma_index_list(s.name) AS l " 8328 "WHERE s.type = 'table'"; 8329 const char *zIndexXInfo = 8330 "SELECT name, coll FROM pragma_index_xinfo(?) WHERE key"; 8331 const char *zWrite = "INSERT INTO sqlite_stat1 VALUES(?, ?, ?)"; 8332 8333 /* If iSample==0, no sqlite_stat1 data is required. */ 8334 if( p->iSample==0 ) return SQLITE_OK; 8335 8336 rc = idxLargestIndex(p->dbm, &nMax, pzErr); 8337 if( nMax<=0 || rc!=SQLITE_OK ) return rc; 8338 8339 rc = sqlite3_exec(p->dbm, "ANALYZE; PRAGMA writable_schema=1", 0, 0, 0); 8340 8341 if( rc==SQLITE_OK ){ 8342 int nByte = sizeof(struct IdxRemCtx) + (sizeof(struct IdxRemSlot) * nMax); 8343 pCtx = (struct IdxRemCtx*)idxMalloc(&rc, nByte); 8344 } 8345 8346 if( rc==SQLITE_OK ){ 8347 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv); 8348 rc = sqlite3_create_function( 8349 dbrem, "rem", 2, SQLITE_UTF8, (void*)pCtx, idxRemFunc, 0, 0 8350 ); 8351 } 8352 if( rc==SQLITE_OK ){ 8353 rc = sqlite3_create_function( 8354 p->db, "sample", 0, SQLITE_UTF8, (void*)&samplectx, idxSampleFunc, 0, 0 8355 ); 8356 } 8357 8358 if( rc==SQLITE_OK ){ 8359 pCtx->nSlot = nMax+1; 8360 rc = idxPrepareStmt(p->dbm, &pAllIndex, pzErr, zAllIndex); 8361 } 8362 if( rc==SQLITE_OK ){ 8363 rc = idxPrepareStmt(p->dbm, &pIndexXInfo, pzErr, zIndexXInfo); 8364 } 8365 if( rc==SQLITE_OK ){ 8366 rc = idxPrepareStmt(p->dbm, &pWrite, pzErr, zWrite); 8367 } 8368 8369 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pAllIndex) ){ 8370 i64 iRowid = sqlite3_column_int64(pAllIndex, 0); 8371 const char *zTab = (const char*)sqlite3_column_text(pAllIndex, 1); 8372 const char *zIdx = (const char*)sqlite3_column_text(pAllIndex, 2); 8373 if( p->iSample<100 && iPrev!=iRowid ){ 8374 samplectx.target = (double)p->iSample / 100.0; 8375 samplectx.iTarget = p->iSample; 8376 samplectx.nRow = 0.0; 8377 samplectx.nRet = 0.0; 8378 rc = idxBuildSampleTable(p, zTab); 8379 if( rc!=SQLITE_OK ) break; 8380 } 8381 rc = idxPopulateOneStat1(p, pIndexXInfo, pWrite, zTab, zIdx, pzErr); 8382 iPrev = iRowid; 8383 } 8384 if( rc==SQLITE_OK && p->iSample<100 ){ 8385 rc = sqlite3_exec(p->dbv, 8386 "DROP TABLE IF EXISTS temp." UNIQUE_TABLE_NAME, 0,0,0 8387 ); 8388 } 8389 8390 idxFinalize(&rc, pAllIndex); 8391 idxFinalize(&rc, pIndexXInfo); 8392 idxFinalize(&rc, pWrite); 8393 8394 for(i=0; i<pCtx->nSlot; i++){ 8395 sqlite3_free(pCtx->aSlot[i].z); 8396 } 8397 sqlite3_free(pCtx); 8398 8399 if( rc==SQLITE_OK ){ 8400 rc = sqlite3_exec(p->dbm, "ANALYZE sqlite_master", 0, 0, 0); 8401 } 8402 8403 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0); 8404 return rc; 8405 } 8406 8407 /* 8408 ** Allocate a new sqlite3expert object. 8409 */ 8410 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErrmsg){ 8411 int rc = SQLITE_OK; 8412 sqlite3expert *pNew; 8413 8414 pNew = (sqlite3expert*)idxMalloc(&rc, sizeof(sqlite3expert)); 8415 8416 /* Open two in-memory databases to work with. The "vtab database" (dbv) 8417 ** will contain a virtual table corresponding to each real table in 8418 ** the user database schema, and a copy of each view. It is used to 8419 ** collect information regarding the WHERE, ORDER BY and other clauses 8420 ** of the user's query. 8421 */ 8422 if( rc==SQLITE_OK ){ 8423 pNew->db = db; 8424 pNew->iSample = 100; 8425 rc = sqlite3_open(":memory:", &pNew->dbv); 8426 } 8427 if( rc==SQLITE_OK ){ 8428 rc = sqlite3_open(":memory:", &pNew->dbm); 8429 if( rc==SQLITE_OK ){ 8430 sqlite3_db_config(pNew->dbm, SQLITE_DBCONFIG_TRIGGER_EQP, 1, (int*)0); 8431 } 8432 } 8433 8434 8435 /* Copy the entire schema of database [db] into [dbm]. */ 8436 if( rc==SQLITE_OK ){ 8437 sqlite3_stmt *pSql; 8438 rc = idxPrintfPrepareStmt(pNew->db, &pSql, pzErrmsg, 8439 "SELECT sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%%'" 8440 " AND sql NOT LIKE 'CREATE VIRTUAL %%'" 8441 ); 8442 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 8443 const char *zSql = (const char*)sqlite3_column_text(pSql, 0); 8444 rc = sqlite3_exec(pNew->dbm, zSql, 0, 0, pzErrmsg); 8445 } 8446 idxFinalize(&rc, pSql); 8447 } 8448 8449 /* Create the vtab schema */ 8450 if( rc==SQLITE_OK ){ 8451 rc = idxCreateVtabSchema(pNew, pzErrmsg); 8452 } 8453 8454 /* Register the auth callback with dbv */ 8455 if( rc==SQLITE_OK ){ 8456 sqlite3_set_authorizer(pNew->dbv, idxAuthCallback, (void*)pNew); 8457 } 8458 8459 /* If an error has occurred, free the new object and reutrn NULL. Otherwise, 8460 ** return the new sqlite3expert handle. */ 8461 if( rc!=SQLITE_OK ){ 8462 sqlite3_expert_destroy(pNew); 8463 pNew = 0; 8464 } 8465 return pNew; 8466 } 8467 8468 /* 8469 ** Configure an sqlite3expert object. 8470 */ 8471 int sqlite3_expert_config(sqlite3expert *p, int op, ...){ 8472 int rc = SQLITE_OK; 8473 va_list ap; 8474 va_start(ap, op); 8475 switch( op ){ 8476 case EXPERT_CONFIG_SAMPLE: { 8477 int iVal = va_arg(ap, int); 8478 if( iVal<0 ) iVal = 0; 8479 if( iVal>100 ) iVal = 100; 8480 p->iSample = iVal; 8481 break; 8482 } 8483 default: 8484 rc = SQLITE_NOTFOUND; 8485 break; 8486 } 8487 8488 va_end(ap); 8489 return rc; 8490 } 8491 8492 /* 8493 ** Add an SQL statement to the analysis. 8494 */ 8495 int sqlite3_expert_sql( 8496 sqlite3expert *p, /* From sqlite3_expert_new() */ 8497 const char *zSql, /* SQL statement to add */ 8498 char **pzErr /* OUT: Error message (if any) */ 8499 ){ 8500 IdxScan *pScanOrig = p->pScan; 8501 IdxStatement *pStmtOrig = p->pStatement; 8502 int rc = SQLITE_OK; 8503 const char *zStmt = zSql; 8504 8505 if( p->bRun ) return SQLITE_MISUSE; 8506 8507 while( rc==SQLITE_OK && zStmt && zStmt[0] ){ 8508 sqlite3_stmt *pStmt = 0; 8509 rc = sqlite3_prepare_v2(p->dbv, zStmt, -1, &pStmt, &zStmt); 8510 if( rc==SQLITE_OK ){ 8511 if( pStmt ){ 8512 IdxStatement *pNew; 8513 const char *z = sqlite3_sql(pStmt); 8514 int n = STRLEN(z); 8515 pNew = (IdxStatement*)idxMalloc(&rc, sizeof(IdxStatement) + n+1); 8516 if( rc==SQLITE_OK ){ 8517 pNew->zSql = (char*)&pNew[1]; 8518 memcpy(pNew->zSql, z, n+1); 8519 pNew->pNext = p->pStatement; 8520 if( p->pStatement ) pNew->iId = p->pStatement->iId+1; 8521 p->pStatement = pNew; 8522 } 8523 sqlite3_finalize(pStmt); 8524 } 8525 }else{ 8526 idxDatabaseError(p->dbv, pzErr); 8527 } 8528 } 8529 8530 if( rc!=SQLITE_OK ){ 8531 idxScanFree(p->pScan, pScanOrig); 8532 idxStatementFree(p->pStatement, pStmtOrig); 8533 p->pScan = pScanOrig; 8534 p->pStatement = pStmtOrig; 8535 } 8536 8537 return rc; 8538 } 8539 8540 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr){ 8541 int rc; 8542 IdxHashEntry *pEntry; 8543 8544 /* Do trigger processing to collect any extra IdxScan structures */ 8545 rc = idxProcessTriggers(p, pzErr); 8546 8547 /* Create candidate indexes within the in-memory database file */ 8548 if( rc==SQLITE_OK ){ 8549 rc = idxCreateCandidates(p); 8550 } 8551 8552 /* Generate the stat1 data */ 8553 if( rc==SQLITE_OK ){ 8554 rc = idxPopulateStat1(p, pzErr); 8555 } 8556 8557 /* Formulate the EXPERT_REPORT_CANDIDATES text */ 8558 for(pEntry=p->hIdx.pFirst; pEntry; pEntry=pEntry->pNext){ 8559 p->zCandidates = idxAppendText(&rc, p->zCandidates, 8560 "%s;%s%s\n", pEntry->zVal, 8561 pEntry->zVal2 ? " -- stat1: " : "", pEntry->zVal2 8562 ); 8563 } 8564 8565 /* Figure out which of the candidate indexes are preferred by the query 8566 ** planner and report the results to the user. */ 8567 if( rc==SQLITE_OK ){ 8568 rc = idxFindIndexes(p, pzErr); 8569 } 8570 8571 if( rc==SQLITE_OK ){ 8572 p->bRun = 1; 8573 } 8574 return rc; 8575 } 8576 8577 /* 8578 ** Return the total number of statements that have been added to this 8579 ** sqlite3expert using sqlite3_expert_sql(). 8580 */ 8581 int sqlite3_expert_count(sqlite3expert *p){ 8582 int nRet = 0; 8583 if( p->pStatement ) nRet = p->pStatement->iId+1; 8584 return nRet; 8585 } 8586 8587 /* 8588 ** Return a component of the report. 8589 */ 8590 const char *sqlite3_expert_report(sqlite3expert *p, int iStmt, int eReport){ 8591 const char *zRet = 0; 8592 IdxStatement *pStmt; 8593 8594 if( p->bRun==0 ) return 0; 8595 for(pStmt=p->pStatement; pStmt && pStmt->iId!=iStmt; pStmt=pStmt->pNext); 8596 switch( eReport ){ 8597 case EXPERT_REPORT_SQL: 8598 if( pStmt ) zRet = pStmt->zSql; 8599 break; 8600 case EXPERT_REPORT_INDEXES: 8601 if( pStmt ) zRet = pStmt->zIdx; 8602 break; 8603 case EXPERT_REPORT_PLAN: 8604 if( pStmt ) zRet = pStmt->zEQP; 8605 break; 8606 case EXPERT_REPORT_CANDIDATES: 8607 zRet = p->zCandidates; 8608 break; 8609 } 8610 return zRet; 8611 } 8612 8613 /* 8614 ** Free an sqlite3expert object. 8615 */ 8616 void sqlite3_expert_destroy(sqlite3expert *p){ 8617 if( p ){ 8618 sqlite3_close(p->dbm); 8619 sqlite3_close(p->dbv); 8620 idxScanFree(p->pScan, 0); 8621 idxStatementFree(p->pStatement, 0); 8622 idxTableFree(p->pTable); 8623 idxWriteFree(p->pWrite); 8624 idxHashClear(&p->hIdx); 8625 sqlite3_free(p->zCandidates); 8626 sqlite3_free(p); 8627 } 8628 } 8629 8630 #endif /* ifndef SQLITE_OMIT_VIRTUAL_TABLE */ 8631 8632 /************************* End ../ext/expert/sqlite3expert.c ********************/ 8633 8634 #if defined(SQLITE_ENABLE_SESSION) 8635 /* 8636 ** State information for a single open session 8637 */ 8638 typedef struct OpenSession OpenSession; 8639 struct OpenSession { 8640 char *zName; /* Symbolic name for this session */ 8641 int nFilter; /* Number of xFilter rejection GLOB patterns */ 8642 char **azFilter; /* Array of xFilter rejection GLOB patterns */ 8643 sqlite3_session *p; /* The open session */ 8644 }; 8645 #endif 8646 8647 /* 8648 ** Shell output mode information from before ".explain on", 8649 ** saved so that it can be restored by ".explain off" 8650 */ 8651 typedef struct SavedModeInfo SavedModeInfo; 8652 struct SavedModeInfo { 8653 int valid; /* Is there legit data in here? */ 8654 int mode; /* Mode prior to ".explain on" */ 8655 int showHeader; /* The ".header" setting prior to ".explain on" */ 8656 int colWidth[100]; /* Column widths prior to ".explain on" */ 8657 }; 8658 8659 typedef struct ExpertInfo ExpertInfo; 8660 struct ExpertInfo { 8661 sqlite3expert *pExpert; 8662 int bVerbose; 8663 }; 8664 8665 /* A single line in the EQP output */ 8666 typedef struct EQPGraphRow EQPGraphRow; 8667 struct EQPGraphRow { 8668 int iEqpId; /* ID for this row */ 8669 int iParentId; /* ID of the parent row */ 8670 EQPGraphRow *pNext; /* Next row in sequence */ 8671 char zText[1]; /* Text to display for this row */ 8672 }; 8673 8674 /* All EQP output is collected into an instance of the following */ 8675 typedef struct EQPGraph EQPGraph; 8676 struct EQPGraph { 8677 EQPGraphRow *pRow; /* Linked list of all rows of the EQP output */ 8678 EQPGraphRow *pLast; /* Last element of the pRow list */ 8679 char zPrefix[100]; /* Graph prefix */ 8680 }; 8681 8682 /* 8683 ** State information about the database connection is contained in an 8684 ** instance of the following structure. 8685 */ 8686 typedef struct ShellState ShellState; 8687 struct ShellState { 8688 sqlite3 *db; /* The database */ 8689 u8 autoExplain; /* Automatically turn on .explain mode */ 8690 u8 autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */ 8691 u8 autoEQPtest; /* autoEQP is in test mode */ 8692 u8 autoEQPtrace; /* autoEQP is in trace mode */ 8693 u8 statsOn; /* True to display memory stats before each finalize */ 8694 u8 scanstatsOn; /* True to display scan stats before each finalize */ 8695 u8 openMode; /* SHELL_OPEN_NORMAL, _APPENDVFS, or _ZIPFILE */ 8696 u8 doXdgOpen; /* Invoke start/open/xdg-open in output_reset() */ 8697 u8 nEqpLevel; /* Depth of the EQP output graph */ 8698 u8 eTraceType; /* SHELL_TRACE_* value for type of trace */ 8699 unsigned mEqpLines; /* Mask of veritical lines in the EQP output graph */ 8700 int outCount; /* Revert to stdout when reaching zero */ 8701 int cnt; /* Number of records displayed so far */ 8702 int lineno; /* Line number of last line read from in */ 8703 FILE *in; /* Read commands from this stream */ 8704 FILE *out; /* Write results here */ 8705 FILE *traceOut; /* Output for sqlite3_trace() */ 8706 int nErr; /* Number of errors seen */ 8707 int mode; /* An output mode setting */ 8708 int modePrior; /* Saved mode */ 8709 int cMode; /* temporary output mode for the current query */ 8710 int normalMode; /* Output mode before ".explain on" */ 8711 int writableSchema; /* True if PRAGMA writable_schema=ON */ 8712 int showHeader; /* True to show column names in List or Column mode */ 8713 int nCheck; /* Number of ".check" commands run */ 8714 unsigned nProgress; /* Number of progress callbacks encountered */ 8715 unsigned mxProgress; /* Maximum progress callbacks before failing */ 8716 unsigned flgProgress; /* Flags for the progress callback */ 8717 unsigned shellFlgs; /* Various flags */ 8718 sqlite3_int64 szMax; /* --maxsize argument to .open */ 8719 char *zDestTable; /* Name of destination table when MODE_Insert */ 8720 char *zTempFile; /* Temporary file that might need deleting */ 8721 char zTestcase[30]; /* Name of current test case */ 8722 char colSeparator[20]; /* Column separator character for several modes */ 8723 char rowSeparator[20]; /* Row separator character for MODE_Ascii */ 8724 char colSepPrior[20]; /* Saved column separator */ 8725 char rowSepPrior[20]; /* Saved row separator */ 8726 int colWidth[100]; /* Requested width of each column when in column mode*/ 8727 int actualWidth[100]; /* Actual width of each column */ 8728 char nullValue[20]; /* The text to print when a NULL comes back from 8729 ** the database */ 8730 char outfile[FILENAME_MAX]; /* Filename for *out */ 8731 const char *zDbFilename; /* name of the database file */ 8732 char *zFreeOnClose; /* Filename to free when closing */ 8733 const char *zVfs; /* Name of VFS to use */ 8734 sqlite3_stmt *pStmt; /* Current statement if any. */ 8735 FILE *pLog; /* Write log output here */ 8736 int *aiIndent; /* Array of indents used in MODE_Explain */ 8737 int nIndent; /* Size of array aiIndent[] */ 8738 int iIndent; /* Index of current op in aiIndent[] */ 8739 EQPGraph sGraph; /* Information for the graphical EXPLAIN QUERY PLAN */ 8740 #if defined(SQLITE_ENABLE_SESSION) 8741 int nSession; /* Number of active sessions */ 8742 OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */ 8743 #endif 8744 ExpertInfo expert; /* Valid if previous command was ".expert OPT..." */ 8745 }; 8746 8747 8748 /* Allowed values for ShellState.autoEQP 8749 */ 8750 #define AUTOEQP_off 0 /* Automatic EXPLAIN QUERY PLAN is off */ 8751 #define AUTOEQP_on 1 /* Automatic EQP is on */ 8752 #define AUTOEQP_trigger 2 /* On and also show plans for triggers */ 8753 #define AUTOEQP_full 3 /* Show full EXPLAIN */ 8754 8755 /* Allowed values for ShellState.openMode 8756 */ 8757 #define SHELL_OPEN_UNSPEC 0 /* No open-mode specified */ 8758 #define SHELL_OPEN_NORMAL 1 /* Normal database file */ 8759 #define SHELL_OPEN_APPENDVFS 2 /* Use appendvfs */ 8760 #define SHELL_OPEN_ZIPFILE 3 /* Use the zipfile virtual table */ 8761 #define SHELL_OPEN_READONLY 4 /* Open a normal database read-only */ 8762 #define SHELL_OPEN_DESERIALIZE 5 /* Open using sqlite3_deserialize() */ 8763 #define SHELL_OPEN_HEXDB 6 /* Use "dbtotxt" output as data source */ 8764 8765 /* Allowed values for ShellState.eTraceType 8766 */ 8767 #define SHELL_TRACE_PLAIN 0 /* Show input SQL text */ 8768 #define SHELL_TRACE_EXPANDED 1 /* Show expanded SQL text */ 8769 #define SHELL_TRACE_NORMALIZED 2 /* Show normalized SQL text */ 8770 8771 /* Bits in the ShellState.flgProgress variable */ 8772 #define SHELL_PROGRESS_QUIET 0x01 /* Omit announcing every progress callback */ 8773 #define SHELL_PROGRESS_RESET 0x02 /* Reset the count when the progres 8774 ** callback limit is reached, and for each 8775 ** top-level SQL statement */ 8776 #define SHELL_PROGRESS_ONCE 0x04 /* Cancel the --limit after firing once */ 8777 8778 /* 8779 ** These are the allowed shellFlgs values 8780 */ 8781 #define SHFLG_Pagecache 0x00000001 /* The --pagecache option is used */ 8782 #define SHFLG_Lookaside 0x00000002 /* Lookaside memory is used */ 8783 #define SHFLG_Backslash 0x00000004 /* The --backslash option is used */ 8784 #define SHFLG_PreserveRowid 0x00000008 /* .dump preserves rowid values */ 8785 #define SHFLG_Newlines 0x00000010 /* .dump --newline flag */ 8786 #define SHFLG_CountChanges 0x00000020 /* .changes setting */ 8787 #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */ 8788 8789 /* 8790 ** Macros for testing and setting shellFlgs 8791 */ 8792 #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0) 8793 #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X)) 8794 #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X))) 8795 8796 /* 8797 ** These are the allowed modes. 8798 */ 8799 #define MODE_Line 0 /* One column per line. Blank line between records */ 8800 #define MODE_Column 1 /* One record per line in neat columns */ 8801 #define MODE_List 2 /* One record per line with a separator */ 8802 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ 8803 #define MODE_Html 4 /* Generate an XHTML table */ 8804 #define MODE_Insert 5 /* Generate SQL "insert" statements */ 8805 #define MODE_Quote 6 /* Quote values as for SQL */ 8806 #define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */ 8807 #define MODE_Csv 8 /* Quote strings, numbers are plain */ 8808 #define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */ 8809 #define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */ 8810 #define MODE_Pretty 11 /* Pretty-print schemas */ 8811 #define MODE_EQP 12 /* Converts EXPLAIN QUERY PLAN output into a graph */ 8812 8813 static const char *modeDescr[] = { 8814 "line", 8815 "column", 8816 "list", 8817 "semi", 8818 "html", 8819 "insert", 8820 "quote", 8821 "tcl", 8822 "csv", 8823 "explain", 8824 "ascii", 8825 "prettyprint", 8826 "eqp" 8827 }; 8828 8829 /* 8830 ** These are the column/row/line separators used by the various 8831 ** import/export modes. 8832 */ 8833 #define SEP_Column "|" 8834 #define SEP_Row "\n" 8835 #define SEP_Tab "\t" 8836 #define SEP_Space " " 8837 #define SEP_Comma "," 8838 #define SEP_CrLf "\r\n" 8839 #define SEP_Unit "\x1F" 8840 #define SEP_Record "\x1E" 8841 8842 /* 8843 ** A callback for the sqlite3_log() interface. 8844 */ 8845 static void shellLog(void *pArg, int iErrCode, const char *zMsg){ 8846 ShellState *p = (ShellState*)pArg; 8847 if( p->pLog==0 ) return; 8848 utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg); 8849 fflush(p->pLog); 8850 } 8851 8852 /* 8853 ** SQL function: shell_putsnl(X) 8854 ** 8855 ** Write the text X to the screen (or whatever output is being directed) 8856 ** adding a newline at the end, and then return X. 8857 */ 8858 static void shellPutsFunc( 8859 sqlite3_context *pCtx, 8860 int nVal, 8861 sqlite3_value **apVal 8862 ){ 8863 ShellState *p = (ShellState*)sqlite3_user_data(pCtx); 8864 (void)nVal; 8865 utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0])); 8866 sqlite3_result_value(pCtx, apVal[0]); 8867 } 8868 8869 /* 8870 ** SQL function: edit(VALUE) 8871 ** edit(VALUE,EDITOR) 8872 ** 8873 ** These steps: 8874 ** 8875 ** (1) Write VALUE into a temporary file. 8876 ** (2) Run program EDITOR on that temporary file. 8877 ** (3) Read the temporary file back and return its content as the result. 8878 ** (4) Delete the temporary file 8879 ** 8880 ** If the EDITOR argument is omitted, use the value in the VISUAL 8881 ** environment variable. If still there is no EDITOR, through an error. 8882 ** 8883 ** Also throw an error if the EDITOR program returns a non-zero exit code. 8884 */ 8885 #ifndef SQLITE_NOHAVE_SYSTEM 8886 static void editFunc( 8887 sqlite3_context *context, 8888 int argc, 8889 sqlite3_value **argv 8890 ){ 8891 const char *zEditor; 8892 char *zTempFile = 0; 8893 sqlite3 *db; 8894 char *zCmd = 0; 8895 int bBin; 8896 int rc; 8897 int hasCRNL = 0; 8898 FILE *f = 0; 8899 sqlite3_int64 sz; 8900 sqlite3_int64 x; 8901 unsigned char *p = 0; 8902 8903 if( argc==2 ){ 8904 zEditor = (const char*)sqlite3_value_text(argv[1]); 8905 }else{ 8906 zEditor = getenv("VISUAL"); 8907 } 8908 if( zEditor==0 ){ 8909 sqlite3_result_error(context, "no editor for edit()", -1); 8910 return; 8911 } 8912 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 8913 sqlite3_result_error(context, "NULL input to edit()", -1); 8914 return; 8915 } 8916 db = sqlite3_context_db_handle(context); 8917 zTempFile = 0; 8918 sqlite3_file_control(db, 0, SQLITE_FCNTL_TEMPFILENAME, &zTempFile); 8919 if( zTempFile==0 ){ 8920 sqlite3_uint64 r = 0; 8921 sqlite3_randomness(sizeof(r), &r); 8922 zTempFile = sqlite3_mprintf("temp%llx", r); 8923 if( zTempFile==0 ){ 8924 sqlite3_result_error_nomem(context); 8925 return; 8926 } 8927 } 8928 bBin = sqlite3_value_type(argv[0])==SQLITE_BLOB; 8929 /* When writing the file to be edited, do \n to \r\n conversions on systems 8930 ** that want \r\n line endings */ 8931 f = fopen(zTempFile, bBin ? "wb" : "w"); 8932 if( f==0 ){ 8933 sqlite3_result_error(context, "edit() cannot open temp file", -1); 8934 goto edit_func_end; 8935 } 8936 sz = sqlite3_value_bytes(argv[0]); 8937 if( bBin ){ 8938 x = fwrite(sqlite3_value_blob(argv[0]), 1, sz, f); 8939 }else{ 8940 const char *z = (const char*)sqlite3_value_text(argv[0]); 8941 /* Remember whether or not the value originally contained \r\n */ 8942 if( z && strstr(z,"\r\n")!=0 ) hasCRNL = 1; 8943 x = fwrite(sqlite3_value_text(argv[0]), 1, sz, f); 8944 } 8945 fclose(f); 8946 f = 0; 8947 if( x!=sz ){ 8948 sqlite3_result_error(context, "edit() could not write the whole file", -1); 8949 goto edit_func_end; 8950 } 8951 zCmd = sqlite3_mprintf("%s \"%s\"", zEditor, zTempFile); 8952 if( zCmd==0 ){ 8953 sqlite3_result_error_nomem(context); 8954 goto edit_func_end; 8955 } 8956 rc = system(zCmd); 8957 sqlite3_free(zCmd); 8958 if( rc ){ 8959 sqlite3_result_error(context, "EDITOR returned non-zero", -1); 8960 goto edit_func_end; 8961 } 8962 f = fopen(zTempFile, "rb"); 8963 if( f==0 ){ 8964 sqlite3_result_error(context, 8965 "edit() cannot reopen temp file after edit", -1); 8966 goto edit_func_end; 8967 } 8968 fseek(f, 0, SEEK_END); 8969 sz = ftell(f); 8970 rewind(f); 8971 p = sqlite3_malloc64( sz+(bBin==0) ); 8972 if( p==0 ){ 8973 sqlite3_result_error_nomem(context); 8974 goto edit_func_end; 8975 } 8976 x = fread(p, 1, sz, f); 8977 fclose(f); 8978 f = 0; 8979 if( x!=sz ){ 8980 sqlite3_result_error(context, "could not read back the whole file", -1); 8981 goto edit_func_end; 8982 } 8983 if( bBin ){ 8984 sqlite3_result_blob64(context, p, sz, sqlite3_free); 8985 }else{ 8986 sqlite3_int64 i, j; 8987 if( hasCRNL ){ 8988 /* If the original contains \r\n then do no conversions back to \n */ 8989 j = sz; 8990 }else{ 8991 /* If the file did not originally contain \r\n then convert any new 8992 ** \r\n back into \n */ 8993 for(i=j=0; i<sz; i++){ 8994 if( p[i]=='\r' && p[i+1]=='\n' ) i++; 8995 p[j++] = p[i]; 8996 } 8997 sz = j; 8998 p[sz] = 0; 8999 } 9000 sqlite3_result_text64(context, (const char*)p, sz, 9001 sqlite3_free, SQLITE_UTF8); 9002 } 9003 p = 0; 9004 9005 edit_func_end: 9006 if( f ) fclose(f); 9007 unlink(zTempFile); 9008 sqlite3_free(zTempFile); 9009 sqlite3_free(p); 9010 } 9011 #endif /* SQLITE_NOHAVE_SYSTEM */ 9012 9013 /* 9014 ** Save or restore the current output mode 9015 */ 9016 static void outputModePush(ShellState *p){ 9017 p->modePrior = p->mode; 9018 memcpy(p->colSepPrior, p->colSeparator, sizeof(p->colSeparator)); 9019 memcpy(p->rowSepPrior, p->rowSeparator, sizeof(p->rowSeparator)); 9020 } 9021 static void outputModePop(ShellState *p){ 9022 p->mode = p->modePrior; 9023 memcpy(p->colSeparator, p->colSepPrior, sizeof(p->colSeparator)); 9024 memcpy(p->rowSeparator, p->rowSepPrior, sizeof(p->rowSeparator)); 9025 } 9026 9027 /* 9028 ** Output the given string as a hex-encoded blob (eg. X'1234' ) 9029 */ 9030 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ 9031 int i; 9032 char *zBlob = (char *)pBlob; 9033 raw_printf(out,"X'"); 9034 for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); } 9035 raw_printf(out,"'"); 9036 } 9037 9038 /* 9039 ** Find a string that is not found anywhere in z[]. Return a pointer 9040 ** to that string. 9041 ** 9042 ** Try to use zA and zB first. If both of those are already found in z[] 9043 ** then make up some string and store it in the buffer zBuf. 9044 */ 9045 static const char *unused_string( 9046 const char *z, /* Result must not appear anywhere in z */ 9047 const char *zA, const char *zB, /* Try these first */ 9048 char *zBuf /* Space to store a generated string */ 9049 ){ 9050 unsigned i = 0; 9051 if( strstr(z, zA)==0 ) return zA; 9052 if( strstr(z, zB)==0 ) return zB; 9053 do{ 9054 sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++); 9055 }while( strstr(z,zBuf)!=0 ); 9056 return zBuf; 9057 } 9058 9059 /* 9060 ** Output the given string as a quoted string using SQL quoting conventions. 9061 ** 9062 ** See also: output_quoted_escaped_string() 9063 */ 9064 static void output_quoted_string(FILE *out, const char *z){ 9065 int i; 9066 char c; 9067 setBinaryMode(out, 1); 9068 for(i=0; (c = z[i])!=0 && c!='\''; i++){} 9069 if( c==0 ){ 9070 utf8_printf(out,"'%s'",z); 9071 }else{ 9072 raw_printf(out, "'"); 9073 while( *z ){ 9074 for(i=0; (c = z[i])!=0 && c!='\''; i++){} 9075 if( c=='\'' ) i++; 9076 if( i ){ 9077 utf8_printf(out, "%.*s", i, z); 9078 z += i; 9079 } 9080 if( c=='\'' ){ 9081 raw_printf(out, "'"); 9082 continue; 9083 } 9084 if( c==0 ){ 9085 break; 9086 } 9087 z++; 9088 } 9089 raw_printf(out, "'"); 9090 } 9091 setTextMode(out, 1); 9092 } 9093 9094 /* 9095 ** Output the given string as a quoted string using SQL quoting conventions. 9096 ** Additionallly , escape the "\n" and "\r" characters so that they do not 9097 ** get corrupted by end-of-line translation facilities in some operating 9098 ** systems. 9099 ** 9100 ** This is like output_quoted_string() but with the addition of the \r\n 9101 ** escape mechanism. 9102 */ 9103 static void output_quoted_escaped_string(FILE *out, const char *z){ 9104 int i; 9105 char c; 9106 setBinaryMode(out, 1); 9107 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){} 9108 if( c==0 ){ 9109 utf8_printf(out,"'%s'",z); 9110 }else{ 9111 const char *zNL = 0; 9112 const char *zCR = 0; 9113 int nNL = 0; 9114 int nCR = 0; 9115 char zBuf1[20], zBuf2[20]; 9116 for(i=0; z[i]; i++){ 9117 if( z[i]=='\n' ) nNL++; 9118 if( z[i]=='\r' ) nCR++; 9119 } 9120 if( nNL ){ 9121 raw_printf(out, "replace("); 9122 zNL = unused_string(z, "\\n", "\\012", zBuf1); 9123 } 9124 if( nCR ){ 9125 raw_printf(out, "replace("); 9126 zCR = unused_string(z, "\\r", "\\015", zBuf2); 9127 } 9128 raw_printf(out, "'"); 9129 while( *z ){ 9130 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){} 9131 if( c=='\'' ) i++; 9132 if( i ){ 9133 utf8_printf(out, "%.*s", i, z); 9134 z += i; 9135 } 9136 if( c=='\'' ){ 9137 raw_printf(out, "'"); 9138 continue; 9139 } 9140 if( c==0 ){ 9141 break; 9142 } 9143 z++; 9144 if( c=='\n' ){ 9145 raw_printf(out, "%s", zNL); 9146 continue; 9147 } 9148 raw_printf(out, "%s", zCR); 9149 } 9150 raw_printf(out, "'"); 9151 if( nCR ){ 9152 raw_printf(out, ",'%s',char(13))", zCR); 9153 } 9154 if( nNL ){ 9155 raw_printf(out, ",'%s',char(10))", zNL); 9156 } 9157 } 9158 setTextMode(out, 1); 9159 } 9160 9161 /* 9162 ** Output the given string as a quoted according to C or TCL quoting rules. 9163 */ 9164 static void output_c_string(FILE *out, const char *z){ 9165 unsigned int c; 9166 fputc('"', out); 9167 while( (c = *(z++))!=0 ){ 9168 if( c=='\\' ){ 9169 fputc(c, out); 9170 fputc(c, out); 9171 }else if( c=='"' ){ 9172 fputc('\\', out); 9173 fputc('"', out); 9174 }else if( c=='\t' ){ 9175 fputc('\\', out); 9176 fputc('t', out); 9177 }else if( c=='\n' ){ 9178 fputc('\\', out); 9179 fputc('n', out); 9180 }else if( c=='\r' ){ 9181 fputc('\\', out); 9182 fputc('r', out); 9183 }else if( !isprint(c&0xff) ){ 9184 raw_printf(out, "\\%03o", c&0xff); 9185 }else{ 9186 fputc(c, out); 9187 } 9188 } 9189 fputc('"', out); 9190 } 9191 9192 /* 9193 ** Output the given string with characters that are special to 9194 ** HTML escaped. 9195 */ 9196 static void output_html_string(FILE *out, const char *z){ 9197 int i; 9198 if( z==0 ) z = ""; 9199 while( *z ){ 9200 for(i=0; z[i] 9201 && z[i]!='<' 9202 && z[i]!='&' 9203 && z[i]!='>' 9204 && z[i]!='\"' 9205 && z[i]!='\''; 9206 i++){} 9207 if( i>0 ){ 9208 utf8_printf(out,"%.*s",i,z); 9209 } 9210 if( z[i]=='<' ){ 9211 raw_printf(out,"<"); 9212 }else if( z[i]=='&' ){ 9213 raw_printf(out,"&"); 9214 }else if( z[i]=='>' ){ 9215 raw_printf(out,">"); 9216 }else if( z[i]=='\"' ){ 9217 raw_printf(out,"""); 9218 }else if( z[i]=='\'' ){ 9219 raw_printf(out,"'"); 9220 }else{ 9221 break; 9222 } 9223 z += i + 1; 9224 } 9225 } 9226 9227 /* 9228 ** If a field contains any character identified by a 1 in the following 9229 ** array, then the string must be quoted for CSV. 9230 */ 9231 static const char needCsvQuote[] = { 9232 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9233 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9234 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 9235 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9236 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9238 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9240 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9241 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9242 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9243 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9244 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9245 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9246 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9247 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9248 }; 9249 9250 /* 9251 ** Output a single term of CSV. Actually, p->colSeparator is used for 9252 ** the separator, which may or may not be a comma. p->nullValue is 9253 ** the null value. Strings are quoted if necessary. The separator 9254 ** is only issued if bSep is true. 9255 */ 9256 static void output_csv(ShellState *p, const char *z, int bSep){ 9257 FILE *out = p->out; 9258 if( z==0 ){ 9259 utf8_printf(out,"%s",p->nullValue); 9260 }else{ 9261 int i; 9262 int nSep = strlen30(p->colSeparator); 9263 for(i=0; z[i]; i++){ 9264 if( needCsvQuote[((unsigned char*)z)[i]] 9265 || (z[i]==p->colSeparator[0] && 9266 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){ 9267 i = 0; 9268 break; 9269 } 9270 } 9271 if( i==0 ){ 9272 char *zQuoted = sqlite3_mprintf("\"%w\"", z); 9273 utf8_printf(out, "%s", zQuoted); 9274 sqlite3_free(zQuoted); 9275 }else{ 9276 utf8_printf(out, "%s", z); 9277 } 9278 } 9279 if( bSep ){ 9280 utf8_printf(p->out, "%s", p->colSeparator); 9281 } 9282 } 9283 9284 /* 9285 ** This routine runs when the user presses Ctrl-C 9286 */ 9287 static void interrupt_handler(int NotUsed){ 9288 UNUSED_PARAMETER(NotUsed); 9289 seenInterrupt++; 9290 if( seenInterrupt>2 ) exit(1); 9291 if( globalDb ) sqlite3_interrupt(globalDb); 9292 } 9293 9294 #if (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 9295 /* 9296 ** This routine runs for console events (e.g. Ctrl-C) on Win32 9297 */ 9298 static BOOL WINAPI ConsoleCtrlHandler( 9299 DWORD dwCtrlType /* One of the CTRL_*_EVENT constants */ 9300 ){ 9301 if( dwCtrlType==CTRL_C_EVENT ){ 9302 interrupt_handler(0); 9303 return TRUE; 9304 } 9305 return FALSE; 9306 } 9307 #endif 9308 9309 #ifndef SQLITE_OMIT_AUTHORIZATION 9310 /* 9311 ** When the ".auth ON" is set, the following authorizer callback is 9312 ** invoked. It always returns SQLITE_OK. 9313 */ 9314 static int shellAuth( 9315 void *pClientData, 9316 int op, 9317 const char *zA1, 9318 const char *zA2, 9319 const char *zA3, 9320 const char *zA4 9321 ){ 9322 ShellState *p = (ShellState*)pClientData; 9323 static const char *azAction[] = { 0, 9324 "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX", 9325 "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW", 9326 "CREATE_TRIGGER", "CREATE_VIEW", "DELETE", 9327 "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX", 9328 "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW", 9329 "DROP_TRIGGER", "DROP_VIEW", "INSERT", 9330 "PRAGMA", "READ", "SELECT", 9331 "TRANSACTION", "UPDATE", "ATTACH", 9332 "DETACH", "ALTER_TABLE", "REINDEX", 9333 "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE", 9334 "FUNCTION", "SAVEPOINT", "RECURSIVE" 9335 }; 9336 int i; 9337 const char *az[4]; 9338 az[0] = zA1; 9339 az[1] = zA2; 9340 az[2] = zA3; 9341 az[3] = zA4; 9342 utf8_printf(p->out, "authorizer: %s", azAction[op]); 9343 for(i=0; i<4; i++){ 9344 raw_printf(p->out, " "); 9345 if( az[i] ){ 9346 output_c_string(p->out, az[i]); 9347 }else{ 9348 raw_printf(p->out, "NULL"); 9349 } 9350 } 9351 raw_printf(p->out, "\n"); 9352 return SQLITE_OK; 9353 } 9354 #endif 9355 9356 /* 9357 ** Print a schema statement. Part of MODE_Semi and MODE_Pretty output. 9358 ** 9359 ** This routine converts some CREATE TABLE statements for shadow tables 9360 ** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements. 9361 */ 9362 static void printSchemaLine(FILE *out, const char *z, const char *zTail){ 9363 if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){ 9364 utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail); 9365 }else{ 9366 utf8_printf(out, "%s%s", z, zTail); 9367 } 9368 } 9369 static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){ 9370 char c = z[n]; 9371 z[n] = 0; 9372 printSchemaLine(out, z, zTail); 9373 z[n] = c; 9374 } 9375 9376 /* 9377 ** Return true if string z[] has nothing but whitespace and comments to the 9378 ** end of the first line. 9379 */ 9380 static int wsToEol(const char *z){ 9381 int i; 9382 for(i=0; z[i]; i++){ 9383 if( z[i]=='\n' ) return 1; 9384 if( IsSpace(z[i]) ) continue; 9385 if( z[i]=='-' && z[i+1]=='-' ) return 1; 9386 return 0; 9387 } 9388 return 1; 9389 } 9390 9391 /* 9392 ** Add a new entry to the EXPLAIN QUERY PLAN data 9393 */ 9394 static void eqp_append(ShellState *p, int iEqpId, int p2, const char *zText){ 9395 EQPGraphRow *pNew; 9396 int nText = strlen30(zText); 9397 if( p->autoEQPtest ){ 9398 utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText); 9399 } 9400 pNew = sqlite3_malloc64( sizeof(*pNew) + nText ); 9401 if( pNew==0 ) shell_out_of_memory(); 9402 pNew->iEqpId = iEqpId; 9403 pNew->iParentId = p2; 9404 memcpy(pNew->zText, zText, nText+1); 9405 pNew->pNext = 0; 9406 if( p->sGraph.pLast ){ 9407 p->sGraph.pLast->pNext = pNew; 9408 }else{ 9409 p->sGraph.pRow = pNew; 9410 } 9411 p->sGraph.pLast = pNew; 9412 } 9413 9414 /* 9415 ** Free and reset the EXPLAIN QUERY PLAN data that has been collected 9416 ** in p->sGraph. 9417 */ 9418 static void eqp_reset(ShellState *p){ 9419 EQPGraphRow *pRow, *pNext; 9420 for(pRow = p->sGraph.pRow; pRow; pRow = pNext){ 9421 pNext = pRow->pNext; 9422 sqlite3_free(pRow); 9423 } 9424 memset(&p->sGraph, 0, sizeof(p->sGraph)); 9425 } 9426 9427 /* Return the next EXPLAIN QUERY PLAN line with iEqpId that occurs after 9428 ** pOld, or return the first such line if pOld is NULL 9429 */ 9430 static EQPGraphRow *eqp_next_row(ShellState *p, int iEqpId, EQPGraphRow *pOld){ 9431 EQPGraphRow *pRow = pOld ? pOld->pNext : p->sGraph.pRow; 9432 while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext; 9433 return pRow; 9434 } 9435 9436 /* Render a single level of the graph that has iEqpId as its parent. Called 9437 ** recursively to render sublevels. 9438 */ 9439 static void eqp_render_level(ShellState *p, int iEqpId){ 9440 EQPGraphRow *pRow, *pNext; 9441 int n = strlen30(p->sGraph.zPrefix); 9442 char *z; 9443 for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){ 9444 pNext = eqp_next_row(p, iEqpId, pRow); 9445 z = pRow->zText; 9446 utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix, pNext ? "|--" : "`--", z); 9447 if( n<(int)sizeof(p->sGraph.zPrefix)-7 ){ 9448 memcpy(&p->sGraph.zPrefix[n], pNext ? "| " : " ", 4); 9449 eqp_render_level(p, pRow->iEqpId); 9450 p->sGraph.zPrefix[n] = 0; 9451 } 9452 } 9453 } 9454 9455 /* 9456 ** Display and reset the EXPLAIN QUERY PLAN data 9457 */ 9458 static void eqp_render(ShellState *p){ 9459 EQPGraphRow *pRow = p->sGraph.pRow; 9460 if( pRow ){ 9461 if( pRow->zText[0]=='-' ){ 9462 if( pRow->pNext==0 ){ 9463 eqp_reset(p); 9464 return; 9465 } 9466 utf8_printf(p->out, "%s\n", pRow->zText+3); 9467 p->sGraph.pRow = pRow->pNext; 9468 sqlite3_free(pRow); 9469 }else{ 9470 utf8_printf(p->out, "QUERY PLAN\n"); 9471 } 9472 p->sGraph.zPrefix[0] = 0; 9473 eqp_render_level(p, 0); 9474 eqp_reset(p); 9475 } 9476 } 9477 9478 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 9479 /* 9480 ** Progress handler callback. 9481 */ 9482 static int progress_handler(void *pClientData) { 9483 ShellState *p = (ShellState*)pClientData; 9484 p->nProgress++; 9485 if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){ 9486 raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress); 9487 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 9488 if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0; 9489 return 1; 9490 } 9491 if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){ 9492 raw_printf(p->out, "Progress %u\n", p->nProgress); 9493 } 9494 return 0; 9495 } 9496 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 9497 9498 /* 9499 ** This is the callback routine that the shell 9500 ** invokes for each row of a query result. 9501 */ 9502 static int shell_callback( 9503 void *pArg, 9504 int nArg, /* Number of result columns */ 9505 char **azArg, /* Text of each result column */ 9506 char **azCol, /* Column names */ 9507 int *aiType /* Column types */ 9508 ){ 9509 int i; 9510 ShellState *p = (ShellState*)pArg; 9511 9512 if( azArg==0 ) return 0; 9513 switch( p->cMode ){ 9514 case MODE_Line: { 9515 int w = 5; 9516 if( azArg==0 ) break; 9517 for(i=0; i<nArg; i++){ 9518 int len = strlen30(azCol[i] ? azCol[i] : ""); 9519 if( len>w ) w = len; 9520 } 9521 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator); 9522 for(i=0; i<nArg; i++){ 9523 utf8_printf(p->out,"%*s = %s%s", w, azCol[i], 9524 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator); 9525 } 9526 break; 9527 } 9528 case MODE_Explain: 9529 case MODE_Column: { 9530 static const int aExplainWidths[] = {4, 13, 4, 4, 4, 13, 2, 13}; 9531 const int *colWidth; 9532 int showHdr; 9533 char *rowSep; 9534 if( p->cMode==MODE_Column ){ 9535 colWidth = p->colWidth; 9536 showHdr = p->showHeader; 9537 rowSep = p->rowSeparator; 9538 }else{ 9539 colWidth = aExplainWidths; 9540 showHdr = 1; 9541 rowSep = SEP_Row; 9542 } 9543 if( p->cnt++==0 ){ 9544 for(i=0; i<nArg; i++){ 9545 int w, n; 9546 if( i<ArraySize(p->colWidth) ){ 9547 w = colWidth[i]; 9548 }else{ 9549 w = 0; 9550 } 9551 if( w==0 ){ 9552 w = strlenChar(azCol[i] ? azCol[i] : ""); 9553 if( w<10 ) w = 10; 9554 n = strlenChar(azArg && azArg[i] ? azArg[i] : p->nullValue); 9555 if( w<n ) w = n; 9556 } 9557 if( i<ArraySize(p->actualWidth) ){ 9558 p->actualWidth[i] = w; 9559 } 9560 if( showHdr ){ 9561 utf8_width_print(p->out, w, azCol[i]); 9562 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " "); 9563 } 9564 } 9565 if( showHdr ){ 9566 for(i=0; i<nArg; i++){ 9567 int w; 9568 if( i<ArraySize(p->actualWidth) ){ 9569 w = p->actualWidth[i]; 9570 if( w<0 ) w = -w; 9571 }else{ 9572 w = 10; 9573 } 9574 utf8_printf(p->out,"%-*.*s%s",w,w, 9575 "----------------------------------------------------------" 9576 "----------------------------------------------------------", 9577 i==nArg-1 ? rowSep : " "); 9578 } 9579 } 9580 } 9581 if( azArg==0 ) break; 9582 for(i=0; i<nArg; i++){ 9583 int w; 9584 if( i<ArraySize(p->actualWidth) ){ 9585 w = p->actualWidth[i]; 9586 }else{ 9587 w = 10; 9588 } 9589 if( p->cMode==MODE_Explain && azArg[i] && strlenChar(azArg[i])>w ){ 9590 w = strlenChar(azArg[i]); 9591 } 9592 if( i==1 && p->aiIndent && p->pStmt ){ 9593 if( p->iIndent<p->nIndent ){ 9594 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], ""); 9595 } 9596 p->iIndent++; 9597 } 9598 utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue); 9599 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " "); 9600 } 9601 break; 9602 } 9603 case MODE_Semi: { /* .schema and .fullschema output */ 9604 printSchemaLine(p->out, azArg[0], ";\n"); 9605 break; 9606 } 9607 case MODE_Pretty: { /* .schema and .fullschema with --indent */ 9608 char *z; 9609 int j; 9610 int nParen = 0; 9611 char cEnd = 0; 9612 char c; 9613 int nLine = 0; 9614 assert( nArg==1 ); 9615 if( azArg[0]==0 ) break; 9616 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0 9617 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0 9618 ){ 9619 utf8_printf(p->out, "%s;\n", azArg[0]); 9620 break; 9621 } 9622 z = sqlite3_mprintf("%s", azArg[0]); 9623 j = 0; 9624 for(i=0; IsSpace(z[i]); i++){} 9625 for(; (c = z[i])!=0; i++){ 9626 if( IsSpace(c) ){ 9627 if( z[j-1]=='\r' ) z[j-1] = '\n'; 9628 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue; 9629 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){ 9630 j--; 9631 } 9632 z[j++] = c; 9633 } 9634 while( j>0 && IsSpace(z[j-1]) ){ j--; } 9635 z[j] = 0; 9636 if( strlen30(z)>=79 ){ 9637 for(i=j=0; (c = z[i])!=0; i++){ /* Copy changes from z[i] back to z[j] */ 9638 if( c==cEnd ){ 9639 cEnd = 0; 9640 }else if( c=='"' || c=='\'' || c=='`' ){ 9641 cEnd = c; 9642 }else if( c=='[' ){ 9643 cEnd = ']'; 9644 }else if( c=='-' && z[i+1]=='-' ){ 9645 cEnd = '\n'; 9646 }else if( c=='(' ){ 9647 nParen++; 9648 }else if( c==')' ){ 9649 nParen--; 9650 if( nLine>0 && nParen==0 && j>0 ){ 9651 printSchemaLineN(p->out, z, j, "\n"); 9652 j = 0; 9653 } 9654 } 9655 z[j++] = c; 9656 if( nParen==1 && cEnd==0 9657 && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1))) 9658 ){ 9659 if( c=='\n' ) j--; 9660 printSchemaLineN(p->out, z, j, "\n "); 9661 j = 0; 9662 nLine++; 9663 while( IsSpace(z[i+1]) ){ i++; } 9664 } 9665 } 9666 z[j] = 0; 9667 } 9668 printSchemaLine(p->out, z, ";\n"); 9669 sqlite3_free(z); 9670 break; 9671 } 9672 case MODE_List: { 9673 if( p->cnt++==0 && p->showHeader ){ 9674 for(i=0; i<nArg; i++){ 9675 utf8_printf(p->out,"%s%s",azCol[i], 9676 i==nArg-1 ? p->rowSeparator : p->colSeparator); 9677 } 9678 } 9679 if( azArg==0 ) break; 9680 for(i=0; i<nArg; i++){ 9681 char *z = azArg[i]; 9682 if( z==0 ) z = p->nullValue; 9683 utf8_printf(p->out, "%s", z); 9684 if( i<nArg-1 ){ 9685 utf8_printf(p->out, "%s", p->colSeparator); 9686 }else{ 9687 utf8_printf(p->out, "%s", p->rowSeparator); 9688 } 9689 } 9690 break; 9691 } 9692 case MODE_Html: { 9693 if( p->cnt++==0 && p->showHeader ){ 9694 raw_printf(p->out,"<TR>"); 9695 for(i=0; i<nArg; i++){ 9696 raw_printf(p->out,"<TH>"); 9697 output_html_string(p->out, azCol[i]); 9698 raw_printf(p->out,"</TH>\n"); 9699 } 9700 raw_printf(p->out,"</TR>\n"); 9701 } 9702 if( azArg==0 ) break; 9703 raw_printf(p->out,"<TR>"); 9704 for(i=0; i<nArg; i++){ 9705 raw_printf(p->out,"<TD>"); 9706 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 9707 raw_printf(p->out,"</TD>\n"); 9708 } 9709 raw_printf(p->out,"</TR>\n"); 9710 break; 9711 } 9712 case MODE_Tcl: { 9713 if( p->cnt++==0 && p->showHeader ){ 9714 for(i=0; i<nArg; i++){ 9715 output_c_string(p->out,azCol[i] ? azCol[i] : ""); 9716 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 9717 } 9718 utf8_printf(p->out, "%s", p->rowSeparator); 9719 } 9720 if( azArg==0 ) break; 9721 for(i=0; i<nArg; i++){ 9722 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 9723 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 9724 } 9725 utf8_printf(p->out, "%s", p->rowSeparator); 9726 break; 9727 } 9728 case MODE_Csv: { 9729 setBinaryMode(p->out, 1); 9730 if( p->cnt++==0 && p->showHeader ){ 9731 for(i=0; i<nArg; i++){ 9732 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1); 9733 } 9734 utf8_printf(p->out, "%s", p->rowSeparator); 9735 } 9736 if( nArg>0 ){ 9737 for(i=0; i<nArg; i++){ 9738 output_csv(p, azArg[i], i<nArg-1); 9739 } 9740 utf8_printf(p->out, "%s", p->rowSeparator); 9741 } 9742 setTextMode(p->out, 1); 9743 break; 9744 } 9745 case MODE_Insert: { 9746 if( azArg==0 ) break; 9747 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable); 9748 if( p->showHeader ){ 9749 raw_printf(p->out,"("); 9750 for(i=0; i<nArg; i++){ 9751 if( i>0 ) raw_printf(p->out, ","); 9752 if( quoteChar(azCol[i]) ){ 9753 char *z = sqlite3_mprintf("\"%w\"", azCol[i]); 9754 utf8_printf(p->out, "%s", z); 9755 sqlite3_free(z); 9756 }else{ 9757 raw_printf(p->out, "%s", azCol[i]); 9758 } 9759 } 9760 raw_printf(p->out,")"); 9761 } 9762 p->cnt++; 9763 for(i=0; i<nArg; i++){ 9764 raw_printf(p->out, i>0 ? "," : " VALUES("); 9765 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 9766 utf8_printf(p->out,"NULL"); 9767 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 9768 if( ShellHasFlag(p, SHFLG_Newlines) ){ 9769 output_quoted_string(p->out, azArg[i]); 9770 }else{ 9771 output_quoted_escaped_string(p->out, azArg[i]); 9772 } 9773 }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 9774 utf8_printf(p->out,"%s", azArg[i]); 9775 }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 9776 char z[50]; 9777 double r = sqlite3_column_double(p->pStmt, i); 9778 sqlite3_uint64 ur; 9779 memcpy(&ur,&r,sizeof(r)); 9780 if( ur==0x7ff0000000000000LL ){ 9781 raw_printf(p->out, "1e999"); 9782 }else if( ur==0xfff0000000000000LL ){ 9783 raw_printf(p->out, "-1e999"); 9784 }else{ 9785 sqlite3_snprintf(50,z,"%!.20g", r); 9786 raw_printf(p->out, "%s", z); 9787 } 9788 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 9789 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 9790 int nBlob = sqlite3_column_bytes(p->pStmt, i); 9791 output_hex_blob(p->out, pBlob, nBlob); 9792 }else if( isNumber(azArg[i], 0) ){ 9793 utf8_printf(p->out,"%s", azArg[i]); 9794 }else if( ShellHasFlag(p, SHFLG_Newlines) ){ 9795 output_quoted_string(p->out, azArg[i]); 9796 }else{ 9797 output_quoted_escaped_string(p->out, azArg[i]); 9798 } 9799 } 9800 raw_printf(p->out,");\n"); 9801 break; 9802 } 9803 case MODE_Quote: { 9804 if( azArg==0 ) break; 9805 if( p->cnt==0 && p->showHeader ){ 9806 for(i=0; i<nArg; i++){ 9807 if( i>0 ) raw_printf(p->out, ","); 9808 output_quoted_string(p->out, azCol[i]); 9809 } 9810 raw_printf(p->out,"\n"); 9811 } 9812 p->cnt++; 9813 for(i=0; i<nArg; i++){ 9814 if( i>0 ) raw_printf(p->out, ","); 9815 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 9816 utf8_printf(p->out,"NULL"); 9817 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 9818 output_quoted_string(p->out, azArg[i]); 9819 }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 9820 utf8_printf(p->out,"%s", azArg[i]); 9821 }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 9822 char z[50]; 9823 double r = sqlite3_column_double(p->pStmt, i); 9824 sqlite3_snprintf(50,z,"%!.20g", r); 9825 raw_printf(p->out, "%s", z); 9826 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 9827 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 9828 int nBlob = sqlite3_column_bytes(p->pStmt, i); 9829 output_hex_blob(p->out, pBlob, nBlob); 9830 }else if( isNumber(azArg[i], 0) ){ 9831 utf8_printf(p->out,"%s", azArg[i]); 9832 }else{ 9833 output_quoted_string(p->out, azArg[i]); 9834 } 9835 } 9836 raw_printf(p->out,"\n"); 9837 break; 9838 } 9839 case MODE_Ascii: { 9840 if( p->cnt++==0 && p->showHeader ){ 9841 for(i=0; i<nArg; i++){ 9842 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 9843 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : ""); 9844 } 9845 utf8_printf(p->out, "%s", p->rowSeparator); 9846 } 9847 if( azArg==0 ) break; 9848 for(i=0; i<nArg; i++){ 9849 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 9850 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue); 9851 } 9852 utf8_printf(p->out, "%s", p->rowSeparator); 9853 break; 9854 } 9855 case MODE_EQP: { 9856 eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]); 9857 break; 9858 } 9859 } 9860 return 0; 9861 } 9862 9863 /* 9864 ** This is the callback routine that the SQLite library 9865 ** invokes for each row of a query result. 9866 */ 9867 static int callback(void *pArg, int nArg, char **azArg, char **azCol){ 9868 /* since we don't have type info, call the shell_callback with a NULL value */ 9869 return shell_callback(pArg, nArg, azArg, azCol, NULL); 9870 } 9871 9872 /* 9873 ** This is the callback routine from sqlite3_exec() that appends all 9874 ** output onto the end of a ShellText object. 9875 */ 9876 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){ 9877 ShellText *p = (ShellText*)pArg; 9878 int i; 9879 UNUSED_PARAMETER(az); 9880 if( azArg==0 ) return 0; 9881 if( p->n ) appendText(p, "|", 0); 9882 for(i=0; i<nArg; i++){ 9883 if( i ) appendText(p, ",", 0); 9884 if( azArg[i] ) appendText(p, azArg[i], 0); 9885 } 9886 return 0; 9887 } 9888 9889 /* 9890 ** Generate an appropriate SELFTEST table in the main database. 9891 */ 9892 static void createSelftestTable(ShellState *p){ 9893 char *zErrMsg = 0; 9894 sqlite3_exec(p->db, 9895 "SAVEPOINT selftest_init;\n" 9896 "CREATE TABLE IF NOT EXISTS selftest(\n" 9897 " tno INTEGER PRIMARY KEY,\n" /* Test number */ 9898 " op TEXT,\n" /* Operator: memo run */ 9899 " cmd TEXT,\n" /* Command text */ 9900 " ans TEXT\n" /* Desired answer */ 9901 ");" 9902 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n" 9903 "INSERT INTO [_shell$self](rowid,op,cmd)\n" 9904 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n" 9905 " 'memo','Tests generated by --init');\n" 9906 "INSERT INTO [_shell$self]\n" 9907 " SELECT 'run',\n" 9908 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql " 9909 "FROM sqlite_master ORDER BY 2'',224))',\n" 9910 " hex(sha3_query('SELECT type,name,tbl_name,sql " 9911 "FROM sqlite_master ORDER BY 2',224));\n" 9912 "INSERT INTO [_shell$self]\n" 9913 " SELECT 'run'," 9914 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||" 9915 " printf('%w',name) || '\" NOT INDEXED'',224))',\n" 9916 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n" 9917 " FROM (\n" 9918 " SELECT name FROM sqlite_master\n" 9919 " WHERE type='table'\n" 9920 " AND name<>'selftest'\n" 9921 " AND coalesce(rootpage,0)>0\n" 9922 " )\n" 9923 " ORDER BY name;\n" 9924 "INSERT INTO [_shell$self]\n" 9925 " VALUES('run','PRAGMA integrity_check','ok');\n" 9926 "INSERT INTO selftest(tno,op,cmd,ans)" 9927 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n" 9928 "DROP TABLE [_shell$self];" 9929 ,0,0,&zErrMsg); 9930 if( zErrMsg ){ 9931 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg); 9932 sqlite3_free(zErrMsg); 9933 } 9934 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0); 9935 } 9936 9937 9938 /* 9939 ** Set the destination table field of the ShellState structure to 9940 ** the name of the table given. Escape any quote characters in the 9941 ** table name. 9942 */ 9943 static void set_table_name(ShellState *p, const char *zName){ 9944 int i, n; 9945 char cQuote; 9946 char *z; 9947 9948 if( p->zDestTable ){ 9949 free(p->zDestTable); 9950 p->zDestTable = 0; 9951 } 9952 if( zName==0 ) return; 9953 cQuote = quoteChar(zName); 9954 n = strlen30(zName); 9955 if( cQuote ) n += n+2; 9956 z = p->zDestTable = malloc( n+1 ); 9957 if( z==0 ) shell_out_of_memory(); 9958 n = 0; 9959 if( cQuote ) z[n++] = cQuote; 9960 for(i=0; zName[i]; i++){ 9961 z[n++] = zName[i]; 9962 if( zName[i]==cQuote ) z[n++] = cQuote; 9963 } 9964 if( cQuote ) z[n++] = cQuote; 9965 z[n] = 0; 9966 } 9967 9968 9969 /* 9970 ** Execute a query statement that will generate SQL output. Print 9971 ** the result columns, comma-separated, on a line and then add a 9972 ** semicolon terminator to the end of that line. 9973 ** 9974 ** If the number of columns is 1 and that column contains text "--" 9975 ** then write the semicolon on a separate line. That way, if a 9976 ** "--" comment occurs at the end of the statement, the comment 9977 ** won't consume the semicolon terminator. 9978 */ 9979 static int run_table_dump_query( 9980 ShellState *p, /* Query context */ 9981 const char *zSelect, /* SELECT statement to extract content */ 9982 const char *zFirstRow /* Print before first row, if not NULL */ 9983 ){ 9984 sqlite3_stmt *pSelect; 9985 int rc; 9986 int nResult; 9987 int i; 9988 const char *z; 9989 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0); 9990 if( rc!=SQLITE_OK || !pSelect ){ 9991 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 9992 sqlite3_errmsg(p->db)); 9993 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 9994 return rc; 9995 } 9996 rc = sqlite3_step(pSelect); 9997 nResult = sqlite3_column_count(pSelect); 9998 while( rc==SQLITE_ROW ){ 9999 if( zFirstRow ){ 10000 utf8_printf(p->out, "%s", zFirstRow); 10001 zFirstRow = 0; 10002 } 10003 z = (const char*)sqlite3_column_text(pSelect, 0); 10004 utf8_printf(p->out, "%s", z); 10005 for(i=1; i<nResult; i++){ 10006 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i)); 10007 } 10008 if( z==0 ) z = ""; 10009 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++; 10010 if( z[0] ){ 10011 raw_printf(p->out, "\n;\n"); 10012 }else{ 10013 raw_printf(p->out, ";\n"); 10014 } 10015 rc = sqlite3_step(pSelect); 10016 } 10017 rc = sqlite3_finalize(pSelect); 10018 if( rc!=SQLITE_OK ){ 10019 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 10020 sqlite3_errmsg(p->db)); 10021 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 10022 } 10023 return rc; 10024 } 10025 10026 /* 10027 ** Allocate space and save off current error string. 10028 */ 10029 static char *save_err_msg( 10030 sqlite3 *db /* Database to query */ 10031 ){ 10032 int nErrMsg = 1+strlen30(sqlite3_errmsg(db)); 10033 char *zErrMsg = sqlite3_malloc64(nErrMsg); 10034 if( zErrMsg ){ 10035 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg); 10036 } 10037 return zErrMsg; 10038 } 10039 10040 #ifdef __linux__ 10041 /* 10042 ** Attempt to display I/O stats on Linux using /proc/PID/io 10043 */ 10044 static void displayLinuxIoStats(FILE *out){ 10045 FILE *in; 10046 char z[200]; 10047 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid()); 10048 in = fopen(z, "rb"); 10049 if( in==0 ) return; 10050 while( fgets(z, sizeof(z), in)!=0 ){ 10051 static const struct { 10052 const char *zPattern; 10053 const char *zDesc; 10054 } aTrans[] = { 10055 { "rchar: ", "Bytes received by read():" }, 10056 { "wchar: ", "Bytes sent to write():" }, 10057 { "syscr: ", "Read() system calls:" }, 10058 { "syscw: ", "Write() system calls:" }, 10059 { "read_bytes: ", "Bytes read from storage:" }, 10060 { "write_bytes: ", "Bytes written to storage:" }, 10061 { "cancelled_write_bytes: ", "Cancelled write bytes:" }, 10062 }; 10063 int i; 10064 for(i=0; i<ArraySize(aTrans); i++){ 10065 int n = strlen30(aTrans[i].zPattern); 10066 if( strncmp(aTrans[i].zPattern, z, n)==0 ){ 10067 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]); 10068 break; 10069 } 10070 } 10071 } 10072 fclose(in); 10073 } 10074 #endif 10075 10076 /* 10077 ** Display a single line of status using 64-bit values. 10078 */ 10079 static void displayStatLine( 10080 ShellState *p, /* The shell context */ 10081 char *zLabel, /* Label for this one line */ 10082 char *zFormat, /* Format for the result */ 10083 int iStatusCtrl, /* Which status to display */ 10084 int bReset /* True to reset the stats */ 10085 ){ 10086 sqlite3_int64 iCur = -1; 10087 sqlite3_int64 iHiwtr = -1; 10088 int i, nPercent; 10089 char zLine[200]; 10090 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset); 10091 for(i=0, nPercent=0; zFormat[i]; i++){ 10092 if( zFormat[i]=='%' ) nPercent++; 10093 } 10094 if( nPercent>1 ){ 10095 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr); 10096 }else{ 10097 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr); 10098 } 10099 raw_printf(p->out, "%-36s %s\n", zLabel, zLine); 10100 } 10101 10102 /* 10103 ** Display memory stats. 10104 */ 10105 static int display_stats( 10106 sqlite3 *db, /* Database to query */ 10107 ShellState *pArg, /* Pointer to ShellState */ 10108 int bReset /* True to reset the stats */ 10109 ){ 10110 int iCur; 10111 int iHiwtr; 10112 FILE *out; 10113 if( pArg==0 || pArg->out==0 ) return 0; 10114 out = pArg->out; 10115 10116 if( pArg->pStmt && (pArg->statsOn & 2) ){ 10117 int nCol, i, x; 10118 sqlite3_stmt *pStmt = pArg->pStmt; 10119 char z[100]; 10120 nCol = sqlite3_column_count(pStmt); 10121 raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol); 10122 for(i=0; i<nCol; i++){ 10123 sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x); 10124 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i)); 10125 #ifndef SQLITE_OMIT_DECLTYPE 10126 sqlite3_snprintf(30, z+x, "declared type:"); 10127 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i)); 10128 #endif 10129 #ifdef SQLITE_ENABLE_COLUMN_METADATA 10130 sqlite3_snprintf(30, z+x, "database name:"); 10131 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i)); 10132 sqlite3_snprintf(30, z+x, "table name:"); 10133 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i)); 10134 sqlite3_snprintf(30, z+x, "origin name:"); 10135 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i)); 10136 #endif 10137 } 10138 } 10139 10140 displayStatLine(pArg, "Memory Used:", 10141 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset); 10142 displayStatLine(pArg, "Number of Outstanding Allocations:", 10143 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset); 10144 if( pArg->shellFlgs & SHFLG_Pagecache ){ 10145 displayStatLine(pArg, "Number of Pcache Pages Used:", 10146 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset); 10147 } 10148 displayStatLine(pArg, "Number of Pcache Overflow Bytes:", 10149 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset); 10150 displayStatLine(pArg, "Largest Allocation:", 10151 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset); 10152 displayStatLine(pArg, "Largest Pcache Allocation:", 10153 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset); 10154 #ifdef YYTRACKMAXSTACKDEPTH 10155 displayStatLine(pArg, "Deepest Parser Stack:", 10156 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset); 10157 #endif 10158 10159 if( db ){ 10160 if( pArg->shellFlgs & SHFLG_Lookaside ){ 10161 iHiwtr = iCur = -1; 10162 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, 10163 &iCur, &iHiwtr, bReset); 10164 raw_printf(pArg->out, 10165 "Lookaside Slots Used: %d (max %d)\n", 10166 iCur, iHiwtr); 10167 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, 10168 &iCur, &iHiwtr, bReset); 10169 raw_printf(pArg->out, "Successful lookaside attempts: %d\n", 10170 iHiwtr); 10171 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, 10172 &iCur, &iHiwtr, bReset); 10173 raw_printf(pArg->out, "Lookaside failures due to size: %d\n", 10174 iHiwtr); 10175 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, 10176 &iCur, &iHiwtr, bReset); 10177 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n", 10178 iHiwtr); 10179 } 10180 iHiwtr = iCur = -1; 10181 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset); 10182 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n", 10183 iCur); 10184 iHiwtr = iCur = -1; 10185 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1); 10186 raw_printf(pArg->out, "Page cache hits: %d\n", iCur); 10187 iHiwtr = iCur = -1; 10188 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1); 10189 raw_printf(pArg->out, "Page cache misses: %d\n", iCur); 10190 iHiwtr = iCur = -1; 10191 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1); 10192 raw_printf(pArg->out, "Page cache writes: %d\n", iCur); 10193 iHiwtr = iCur = -1; 10194 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1); 10195 raw_printf(pArg->out, "Page cache spills: %d\n", iCur); 10196 iHiwtr = iCur = -1; 10197 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset); 10198 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n", 10199 iCur); 10200 iHiwtr = iCur = -1; 10201 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset); 10202 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", 10203 iCur); 10204 } 10205 10206 if( pArg->pStmt ){ 10207 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, 10208 bReset); 10209 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur); 10210 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset); 10211 raw_printf(pArg->out, "Sort Operations: %d\n", iCur); 10212 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset); 10213 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur); 10214 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset); 10215 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur); 10216 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE, bReset); 10217 raw_printf(pArg->out, "Reprepare operations: %d\n", iCur); 10218 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset); 10219 raw_printf(pArg->out, "Number of times run: %d\n", iCur); 10220 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset); 10221 raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur); 10222 } 10223 10224 #ifdef __linux__ 10225 displayLinuxIoStats(pArg->out); 10226 #endif 10227 10228 /* Do not remove this machine readable comment: extra-stats-output-here */ 10229 10230 return 0; 10231 } 10232 10233 /* 10234 ** Display scan stats. 10235 */ 10236 static void display_scanstats( 10237 sqlite3 *db, /* Database to query */ 10238 ShellState *pArg /* Pointer to ShellState */ 10239 ){ 10240 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS 10241 UNUSED_PARAMETER(db); 10242 UNUSED_PARAMETER(pArg); 10243 #else 10244 int i, k, n, mx; 10245 raw_printf(pArg->out, "-------- scanstats --------\n"); 10246 mx = 0; 10247 for(k=0; k<=mx; k++){ 10248 double rEstLoop = 1.0; 10249 for(i=n=0; 1; i++){ 10250 sqlite3_stmt *p = pArg->pStmt; 10251 sqlite3_int64 nLoop, nVisit; 10252 double rEst; 10253 int iSid; 10254 const char *zExplain; 10255 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){ 10256 break; 10257 } 10258 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid); 10259 if( iSid>mx ) mx = iSid; 10260 if( iSid!=k ) continue; 10261 if( n==0 ){ 10262 rEstLoop = (double)nLoop; 10263 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k); 10264 } 10265 n++; 10266 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit); 10267 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst); 10268 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain); 10269 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain); 10270 rEstLoop *= rEst; 10271 raw_printf(pArg->out, 10272 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n", 10273 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst 10274 ); 10275 } 10276 } 10277 raw_printf(pArg->out, "---------------------------\n"); 10278 #endif 10279 } 10280 10281 /* 10282 ** Parameter azArray points to a zero-terminated array of strings. zStr 10283 ** points to a single nul-terminated string. Return non-zero if zStr 10284 ** is equal, according to strcmp(), to any of the strings in the array. 10285 ** Otherwise, return zero. 10286 */ 10287 static int str_in_array(const char *zStr, const char **azArray){ 10288 int i; 10289 for(i=0; azArray[i]; i++){ 10290 if( 0==strcmp(zStr, azArray[i]) ) return 1; 10291 } 10292 return 0; 10293 } 10294 10295 /* 10296 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate 10297 ** and populate the ShellState.aiIndent[] array with the number of 10298 ** spaces each opcode should be indented before it is output. 10299 ** 10300 ** The indenting rules are: 10301 ** 10302 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent 10303 ** all opcodes that occur between the p2 jump destination and the opcode 10304 ** itself by 2 spaces. 10305 ** 10306 ** * For each "Goto", if the jump destination is earlier in the program 10307 ** and ends on one of: 10308 ** Yield SeekGt SeekLt RowSetRead Rewind 10309 ** or if the P1 parameter is one instead of zero, 10310 ** then indent all opcodes between the earlier instruction 10311 ** and "Goto" by 2 spaces. 10312 */ 10313 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){ 10314 const char *zSql; /* The text of the SQL statement */ 10315 const char *z; /* Used to check if this is an EXPLAIN */ 10316 int *abYield = 0; /* True if op is an OP_Yield */ 10317 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */ 10318 int iOp; /* Index of operation in p->aiIndent[] */ 10319 10320 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 }; 10321 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead", 10322 "Rewind", 0 }; 10323 const char *azGoto[] = { "Goto", 0 }; 10324 10325 /* Try to figure out if this is really an EXPLAIN statement. If this 10326 ** cannot be verified, return early. */ 10327 if( sqlite3_column_count(pSql)!=8 ){ 10328 p->cMode = p->mode; 10329 return; 10330 } 10331 zSql = sqlite3_sql(pSql); 10332 if( zSql==0 ) return; 10333 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++); 10334 if( sqlite3_strnicmp(z, "explain", 7) ){ 10335 p->cMode = p->mode; 10336 return; 10337 } 10338 10339 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){ 10340 int i; 10341 int iAddr = sqlite3_column_int(pSql, 0); 10342 const char *zOp = (const char*)sqlite3_column_text(pSql, 1); 10343 10344 /* Set p2 to the P2 field of the current opcode. Then, assuming that 10345 ** p2 is an instruction address, set variable p2op to the index of that 10346 ** instruction in the aiIndent[] array. p2 and p2op may be different if 10347 ** the current instruction is part of a sub-program generated by an 10348 ** SQL trigger or foreign key. */ 10349 int p2 = sqlite3_column_int(pSql, 3); 10350 int p2op = (p2 + (iOp-iAddr)); 10351 10352 /* Grow the p->aiIndent array as required */ 10353 if( iOp>=nAlloc ){ 10354 if( iOp==0 ){ 10355 /* Do further verfication that this is explain output. Abort if 10356 ** it is not */ 10357 static const char *explainCols[] = { 10358 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" }; 10359 int jj; 10360 for(jj=0; jj<ArraySize(explainCols); jj++){ 10361 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){ 10362 p->cMode = p->mode; 10363 sqlite3_reset(pSql); 10364 return; 10365 } 10366 } 10367 } 10368 nAlloc += 100; 10369 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int)); 10370 if( p->aiIndent==0 ) shell_out_of_memory(); 10371 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int)); 10372 if( abYield==0 ) shell_out_of_memory(); 10373 } 10374 abYield[iOp] = str_in_array(zOp, azYield); 10375 p->aiIndent[iOp] = 0; 10376 p->nIndent = iOp+1; 10377 10378 if( str_in_array(zOp, azNext) ){ 10379 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 10380 } 10381 if( str_in_array(zOp, azGoto) && p2op<p->nIndent 10382 && (abYield[p2op] || sqlite3_column_int(pSql, 2)) 10383 ){ 10384 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 10385 } 10386 } 10387 10388 p->iIndent = 0; 10389 sqlite3_free(abYield); 10390 sqlite3_reset(pSql); 10391 } 10392 10393 /* 10394 ** Free the array allocated by explain_data_prepare(). 10395 */ 10396 static void explain_data_delete(ShellState *p){ 10397 sqlite3_free(p->aiIndent); 10398 p->aiIndent = 0; 10399 p->nIndent = 0; 10400 p->iIndent = 0; 10401 } 10402 10403 /* 10404 ** Disable and restore .wheretrace and .selecttrace settings. 10405 */ 10406 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 10407 extern int sqlite3SelectTrace; 10408 static int savedSelectTrace; 10409 #endif 10410 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 10411 extern int sqlite3WhereTrace; 10412 static int savedWhereTrace; 10413 #endif 10414 static void disable_debug_trace_modes(void){ 10415 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 10416 savedSelectTrace = sqlite3SelectTrace; 10417 sqlite3SelectTrace = 0; 10418 #endif 10419 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 10420 savedWhereTrace = sqlite3WhereTrace; 10421 sqlite3WhereTrace = 0; 10422 #endif 10423 } 10424 static void restore_debug_trace_modes(void){ 10425 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 10426 sqlite3SelectTrace = savedSelectTrace; 10427 #endif 10428 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 10429 sqlite3WhereTrace = savedWhereTrace; 10430 #endif 10431 } 10432 10433 /* 10434 ** Run a prepared statement 10435 */ 10436 static void exec_prepared_stmt( 10437 ShellState *pArg, /* Pointer to ShellState */ 10438 sqlite3_stmt *pStmt /* Statment to run */ 10439 ){ 10440 int rc; 10441 10442 /* perform the first step. this will tell us if we 10443 ** have a result set or not and how wide it is. 10444 */ 10445 rc = sqlite3_step(pStmt); 10446 /* if we have a result set... */ 10447 if( SQLITE_ROW == rc ){ 10448 /* allocate space for col name ptr, value ptr, and type */ 10449 int nCol = sqlite3_column_count(pStmt); 10450 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1); 10451 if( !pData ){ 10452 rc = SQLITE_NOMEM; 10453 }else{ 10454 char **azCols = (char **)pData; /* Names of result columns */ 10455 char **azVals = &azCols[nCol]; /* Results */ 10456 int *aiTypes = (int *)&azVals[nCol]; /* Result types */ 10457 int i, x; 10458 assert(sizeof(int) <= sizeof(char *)); 10459 /* save off ptrs to column names */ 10460 for(i=0; i<nCol; i++){ 10461 azCols[i] = (char *)sqlite3_column_name(pStmt, i); 10462 } 10463 do{ 10464 /* extract the data and data types */ 10465 for(i=0; i<nCol; i++){ 10466 aiTypes[i] = x = sqlite3_column_type(pStmt, i); 10467 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){ 10468 azVals[i] = ""; 10469 }else{ 10470 azVals[i] = (char*)sqlite3_column_text(pStmt, i); 10471 } 10472 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){ 10473 rc = SQLITE_NOMEM; 10474 break; /* from for */ 10475 } 10476 } /* end for */ 10477 10478 /* if data and types extracted successfully... */ 10479 if( SQLITE_ROW == rc ){ 10480 /* call the supplied callback with the result row data */ 10481 if( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){ 10482 rc = SQLITE_ABORT; 10483 }else{ 10484 rc = sqlite3_step(pStmt); 10485 } 10486 } 10487 } while( SQLITE_ROW == rc ); 10488 sqlite3_free(pData); 10489 } 10490 } 10491 } 10492 10493 #ifndef SQLITE_OMIT_VIRTUALTABLE 10494 /* 10495 ** This function is called to process SQL if the previous shell command 10496 ** was ".expert". It passes the SQL in the second argument directly to 10497 ** the sqlite3expert object. 10498 ** 10499 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 10500 ** code. In this case, (*pzErr) may be set to point to a buffer containing 10501 ** an English language error message. It is the responsibility of the 10502 ** caller to eventually free this buffer using sqlite3_free(). 10503 */ 10504 static int expertHandleSQL( 10505 ShellState *pState, 10506 const char *zSql, 10507 char **pzErr 10508 ){ 10509 assert( pState->expert.pExpert ); 10510 assert( pzErr==0 || *pzErr==0 ); 10511 return sqlite3_expert_sql(pState->expert.pExpert, zSql, pzErr); 10512 } 10513 10514 /* 10515 ** This function is called either to silently clean up the object 10516 ** created by the ".expert" command (if bCancel==1), or to generate a 10517 ** report from it and then clean it up (if bCancel==0). 10518 ** 10519 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 10520 ** code. In this case, (*pzErr) may be set to point to a buffer containing 10521 ** an English language error message. It is the responsibility of the 10522 ** caller to eventually free this buffer using sqlite3_free(). 10523 */ 10524 static int expertFinish( 10525 ShellState *pState, 10526 int bCancel, 10527 char **pzErr 10528 ){ 10529 int rc = SQLITE_OK; 10530 sqlite3expert *p = pState->expert.pExpert; 10531 assert( p ); 10532 assert( bCancel || pzErr==0 || *pzErr==0 ); 10533 if( bCancel==0 ){ 10534 FILE *out = pState->out; 10535 int bVerbose = pState->expert.bVerbose; 10536 10537 rc = sqlite3_expert_analyze(p, pzErr); 10538 if( rc==SQLITE_OK ){ 10539 int nQuery = sqlite3_expert_count(p); 10540 int i; 10541 10542 if( bVerbose ){ 10543 const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES); 10544 raw_printf(out, "-- Candidates -----------------------------\n"); 10545 raw_printf(out, "%s\n", zCand); 10546 } 10547 for(i=0; i<nQuery; i++){ 10548 const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL); 10549 const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES); 10550 const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN); 10551 if( zIdx==0 ) zIdx = "(no new indexes)\n"; 10552 if( bVerbose ){ 10553 raw_printf(out, "-- Query %d --------------------------------\n",i+1); 10554 raw_printf(out, "%s\n\n", zSql); 10555 } 10556 raw_printf(out, "%s\n", zIdx); 10557 raw_printf(out, "%s\n", zEQP); 10558 } 10559 } 10560 } 10561 sqlite3_expert_destroy(p); 10562 pState->expert.pExpert = 0; 10563 return rc; 10564 } 10565 10566 /* 10567 ** Implementation of ".expert" dot command. 10568 */ 10569 static int expertDotCommand( 10570 ShellState *pState, /* Current shell tool state */ 10571 char **azArg, /* Array of arguments passed to dot command */ 10572 int nArg /* Number of entries in azArg[] */ 10573 ){ 10574 int rc = SQLITE_OK; 10575 char *zErr = 0; 10576 int i; 10577 int iSample = 0; 10578 10579 assert( pState->expert.pExpert==0 ); 10580 memset(&pState->expert, 0, sizeof(ExpertInfo)); 10581 10582 for(i=1; rc==SQLITE_OK && i<nArg; i++){ 10583 char *z = azArg[i]; 10584 int n; 10585 if( z[0]=='-' && z[1]=='-' ) z++; 10586 n = strlen30(z); 10587 if( n>=2 && 0==strncmp(z, "-verbose", n) ){ 10588 pState->expert.bVerbose = 1; 10589 } 10590 else if( n>=2 && 0==strncmp(z, "-sample", n) ){ 10591 if( i==(nArg-1) ){ 10592 raw_printf(stderr, "option requires an argument: %s\n", z); 10593 rc = SQLITE_ERROR; 10594 }else{ 10595 iSample = (int)integerValue(azArg[++i]); 10596 if( iSample<0 || iSample>100 ){ 10597 raw_printf(stderr, "value out of range: %s\n", azArg[i]); 10598 rc = SQLITE_ERROR; 10599 } 10600 } 10601 } 10602 else{ 10603 raw_printf(stderr, "unknown option: %s\n", z); 10604 rc = SQLITE_ERROR; 10605 } 10606 } 10607 10608 if( rc==SQLITE_OK ){ 10609 pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr); 10610 if( pState->expert.pExpert==0 ){ 10611 raw_printf(stderr, "sqlite3_expert_new: %s\n", zErr); 10612 rc = SQLITE_ERROR; 10613 }else{ 10614 sqlite3_expert_config( 10615 pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample 10616 ); 10617 } 10618 } 10619 10620 return rc; 10621 } 10622 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ 10623 10624 /* 10625 ** Execute a statement or set of statements. Print 10626 ** any result rows/columns depending on the current mode 10627 ** set via the supplied callback. 10628 ** 10629 ** This is very similar to SQLite's built-in sqlite3_exec() 10630 ** function except it takes a slightly different callback 10631 ** and callback data argument. 10632 */ 10633 static int shell_exec( 10634 ShellState *pArg, /* Pointer to ShellState */ 10635 const char *zSql, /* SQL to be evaluated */ 10636 char **pzErrMsg /* Error msg written here */ 10637 ){ 10638 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */ 10639 int rc = SQLITE_OK; /* Return Code */ 10640 int rc2; 10641 const char *zLeftover; /* Tail of unprocessed SQL */ 10642 sqlite3 *db = pArg->db; 10643 10644 if( pzErrMsg ){ 10645 *pzErrMsg = NULL; 10646 } 10647 10648 #ifndef SQLITE_OMIT_VIRTUALTABLE 10649 if( pArg->expert.pExpert ){ 10650 rc = expertHandleSQL(pArg, zSql, pzErrMsg); 10651 return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg); 10652 } 10653 #endif 10654 10655 while( zSql[0] && (SQLITE_OK == rc) ){ 10656 static const char *zStmtSql; 10657 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); 10658 if( SQLITE_OK != rc ){ 10659 if( pzErrMsg ){ 10660 *pzErrMsg = save_err_msg(db); 10661 } 10662 }else{ 10663 if( !pStmt ){ 10664 /* this happens for a comment or white-space */ 10665 zSql = zLeftover; 10666 while( IsSpace(zSql[0]) ) zSql++; 10667 continue; 10668 } 10669 zStmtSql = sqlite3_sql(pStmt); 10670 if( zStmtSql==0 ) zStmtSql = ""; 10671 while( IsSpace(zStmtSql[0]) ) zStmtSql++; 10672 10673 /* save off the prepared statment handle and reset row count */ 10674 if( pArg ){ 10675 pArg->pStmt = pStmt; 10676 pArg->cnt = 0; 10677 } 10678 10679 /* echo the sql statement if echo on */ 10680 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){ 10681 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql); 10682 } 10683 10684 /* Show the EXPLAIN QUERY PLAN if .eqp is on */ 10685 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){ 10686 sqlite3_stmt *pExplain; 10687 char *zEQP; 10688 int triggerEQP = 0; 10689 disable_debug_trace_modes(); 10690 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP); 10691 if( pArg->autoEQP>=AUTOEQP_trigger ){ 10692 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0); 10693 } 10694 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql); 10695 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 10696 if( rc==SQLITE_OK ){ 10697 while( sqlite3_step(pExplain)==SQLITE_ROW ){ 10698 const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3); 10699 int iEqpId = sqlite3_column_int(pExplain, 0); 10700 int iParentId = sqlite3_column_int(pExplain, 1); 10701 if( zEQPLine[0]=='-' ) eqp_render(pArg); 10702 eqp_append(pArg, iEqpId, iParentId, zEQPLine); 10703 } 10704 eqp_render(pArg); 10705 } 10706 sqlite3_finalize(pExplain); 10707 sqlite3_free(zEQP); 10708 if( pArg->autoEQP>=AUTOEQP_full ){ 10709 /* Also do an EXPLAIN for ".eqp full" mode */ 10710 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql); 10711 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 10712 if( rc==SQLITE_OK ){ 10713 pArg->cMode = MODE_Explain; 10714 explain_data_prepare(pArg, pExplain); 10715 exec_prepared_stmt(pArg, pExplain); 10716 explain_data_delete(pArg); 10717 } 10718 sqlite3_finalize(pExplain); 10719 sqlite3_free(zEQP); 10720 } 10721 if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){ 10722 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0); 10723 /* Reprepare pStmt before reactiving trace modes */ 10724 sqlite3_finalize(pStmt); 10725 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 10726 if( pArg ) pArg->pStmt = pStmt; 10727 } 10728 restore_debug_trace_modes(); 10729 } 10730 10731 if( pArg ){ 10732 pArg->cMode = pArg->mode; 10733 if( pArg->autoExplain ){ 10734 if( sqlite3_column_count(pStmt)==8 10735 && sqlite3_strlike("EXPLAIN%", zStmtSql,0)==0 10736 ){ 10737 pArg->cMode = MODE_Explain; 10738 } 10739 if( sqlite3_column_count(pStmt)==4 10740 && sqlite3_strlike("EXPLAIN QUERY PLAN%", zStmtSql,0)==0 ){ 10741 pArg->cMode = MODE_EQP; 10742 } 10743 } 10744 10745 /* If the shell is currently in ".explain" mode, gather the extra 10746 ** data required to add indents to the output.*/ 10747 if( pArg->cMode==MODE_Explain ){ 10748 explain_data_prepare(pArg, pStmt); 10749 } 10750 } 10751 10752 exec_prepared_stmt(pArg, pStmt); 10753 explain_data_delete(pArg); 10754 eqp_render(pArg); 10755 10756 /* print usage stats if stats on */ 10757 if( pArg && pArg->statsOn ){ 10758 display_stats(db, pArg, 0); 10759 } 10760 10761 /* print loop-counters if required */ 10762 if( pArg && pArg->scanstatsOn ){ 10763 display_scanstats(db, pArg); 10764 } 10765 10766 /* Finalize the statement just executed. If this fails, save a 10767 ** copy of the error message. Otherwise, set zSql to point to the 10768 ** next statement to execute. */ 10769 rc2 = sqlite3_finalize(pStmt); 10770 if( rc!=SQLITE_NOMEM ) rc = rc2; 10771 if( rc==SQLITE_OK ){ 10772 zSql = zLeftover; 10773 while( IsSpace(zSql[0]) ) zSql++; 10774 }else if( pzErrMsg ){ 10775 *pzErrMsg = save_err_msg(db); 10776 } 10777 10778 /* clear saved stmt handle */ 10779 if( pArg ){ 10780 pArg->pStmt = NULL; 10781 } 10782 } 10783 } /* end while */ 10784 10785 return rc; 10786 } 10787 10788 /* 10789 ** Release memory previously allocated by tableColumnList(). 10790 */ 10791 static void freeColumnList(char **azCol){ 10792 int i; 10793 for(i=1; azCol[i]; i++){ 10794 sqlite3_free(azCol[i]); 10795 } 10796 /* azCol[0] is a static string */ 10797 sqlite3_free(azCol); 10798 } 10799 10800 /* 10801 ** Return a list of pointers to strings which are the names of all 10802 ** columns in table zTab. The memory to hold the names is dynamically 10803 ** allocated and must be released by the caller using a subsequent call 10804 ** to freeColumnList(). 10805 ** 10806 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid 10807 ** value that needs to be preserved, then azCol[0] is filled in with the 10808 ** name of the rowid column. 10809 ** 10810 ** The first regular column in the table is azCol[1]. The list is terminated 10811 ** by an entry with azCol[i]==0. 10812 */ 10813 static char **tableColumnList(ShellState *p, const char *zTab){ 10814 char **azCol = 0; 10815 sqlite3_stmt *pStmt; 10816 char *zSql; 10817 int nCol = 0; 10818 int nAlloc = 0; 10819 int nPK = 0; /* Number of PRIMARY KEY columns seen */ 10820 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */ 10821 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid); 10822 int rc; 10823 10824 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab); 10825 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 10826 sqlite3_free(zSql); 10827 if( rc ) return 0; 10828 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 10829 if( nCol>=nAlloc-2 ){ 10830 nAlloc = nAlloc*2 + nCol + 10; 10831 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0])); 10832 if( azCol==0 ) shell_out_of_memory(); 10833 } 10834 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1)); 10835 if( sqlite3_column_int(pStmt, 5) ){ 10836 nPK++; 10837 if( nPK==1 10838 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2), 10839 "INTEGER")==0 10840 ){ 10841 isIPK = 1; 10842 }else{ 10843 isIPK = 0; 10844 } 10845 } 10846 } 10847 sqlite3_finalize(pStmt); 10848 if( azCol==0 ) return 0; 10849 azCol[0] = 0; 10850 azCol[nCol+1] = 0; 10851 10852 /* The decision of whether or not a rowid really needs to be preserved 10853 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table 10854 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve 10855 ** rowids on tables where the rowid is inaccessible because there are other 10856 ** columns in the table named "rowid", "_rowid_", and "oid". 10857 */ 10858 if( preserveRowid && isIPK ){ 10859 /* If a single PRIMARY KEY column with type INTEGER was seen, then it 10860 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID 10861 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are 10862 ** ROWID aliases. To distinguish these cases, check to see if 10863 ** there is a "pk" entry in "PRAGMA index_list". There will be 10864 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID. 10865 */ 10866 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)" 10867 " WHERE origin='pk'", zTab); 10868 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 10869 sqlite3_free(zSql); 10870 if( rc ){ 10871 freeColumnList(azCol); 10872 return 0; 10873 } 10874 rc = sqlite3_step(pStmt); 10875 sqlite3_finalize(pStmt); 10876 preserveRowid = rc==SQLITE_ROW; 10877 } 10878 if( preserveRowid ){ 10879 /* Only preserve the rowid if we can find a name to use for the 10880 ** rowid */ 10881 static char *azRowid[] = { "rowid", "_rowid_", "oid" }; 10882 int i, j; 10883 for(j=0; j<3; j++){ 10884 for(i=1; i<=nCol; i++){ 10885 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break; 10886 } 10887 if( i>nCol ){ 10888 /* At this point, we know that azRowid[j] is not the name of any 10889 ** ordinary column in the table. Verify that azRowid[j] is a valid 10890 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID 10891 ** tables will fail this last check */ 10892 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0); 10893 if( rc==SQLITE_OK ) azCol[0] = azRowid[j]; 10894 break; 10895 } 10896 } 10897 } 10898 return azCol; 10899 } 10900 10901 /* 10902 ** Toggle the reverse_unordered_selects setting. 10903 */ 10904 static void toggleSelectOrder(sqlite3 *db){ 10905 sqlite3_stmt *pStmt = 0; 10906 int iSetting = 0; 10907 char zStmt[100]; 10908 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0); 10909 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 10910 iSetting = sqlite3_column_int(pStmt, 0); 10911 } 10912 sqlite3_finalize(pStmt); 10913 sqlite3_snprintf(sizeof(zStmt), zStmt, 10914 "PRAGMA reverse_unordered_selects(%d)", !iSetting); 10915 sqlite3_exec(db, zStmt, 0, 0, 0); 10916 } 10917 10918 /* 10919 ** This is a different callback routine used for dumping the database. 10920 ** Each row received by this callback consists of a table name, 10921 ** the table type ("index" or "table") and SQL to create the table. 10922 ** This routine should print text sufficient to recreate the table. 10923 */ 10924 static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){ 10925 int rc; 10926 const char *zTable; 10927 const char *zType; 10928 const char *zSql; 10929 ShellState *p = (ShellState *)pArg; 10930 10931 UNUSED_PARAMETER(azNotUsed); 10932 if( nArg!=3 || azArg==0 ) return 0; 10933 zTable = azArg[0]; 10934 zType = azArg[1]; 10935 zSql = azArg[2]; 10936 10937 if( strcmp(zTable, "sqlite_sequence")==0 ){ 10938 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n"); 10939 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){ 10940 raw_printf(p->out, "ANALYZE sqlite_master;\n"); 10941 }else if( strncmp(zTable, "sqlite_", 7)==0 ){ 10942 return 0; 10943 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ 10944 char *zIns; 10945 if( !p->writableSchema ){ 10946 raw_printf(p->out, "PRAGMA writable_schema=ON;\n"); 10947 p->writableSchema = 1; 10948 } 10949 zIns = sqlite3_mprintf( 10950 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)" 10951 "VALUES('table','%q','%q',0,'%q');", 10952 zTable, zTable, zSql); 10953 utf8_printf(p->out, "%s\n", zIns); 10954 sqlite3_free(zIns); 10955 return 0; 10956 }else{ 10957 printSchemaLine(p->out, zSql, ";\n"); 10958 } 10959 10960 if( strcmp(zType, "table")==0 ){ 10961 ShellText sSelect; 10962 ShellText sTable; 10963 char **azCol; 10964 int i; 10965 char *savedDestTable; 10966 int savedMode; 10967 10968 azCol = tableColumnList(p, zTable); 10969 if( azCol==0 ){ 10970 p->nErr++; 10971 return 0; 10972 } 10973 10974 /* Always quote the table name, even if it appears to be pure ascii, 10975 ** in case it is a keyword. Ex: INSERT INTO "table" ... */ 10976 initText(&sTable); 10977 appendText(&sTable, zTable, quoteChar(zTable)); 10978 /* If preserving the rowid, add a column list after the table name. 10979 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)" 10980 ** instead of the usual "INSERT INTO tab VALUES(...)". 10981 */ 10982 if( azCol[0] ){ 10983 appendText(&sTable, "(", 0); 10984 appendText(&sTable, azCol[0], 0); 10985 for(i=1; azCol[i]; i++){ 10986 appendText(&sTable, ",", 0); 10987 appendText(&sTable, azCol[i], quoteChar(azCol[i])); 10988 } 10989 appendText(&sTable, ")", 0); 10990 } 10991 10992 /* Build an appropriate SELECT statement */ 10993 initText(&sSelect); 10994 appendText(&sSelect, "SELECT ", 0); 10995 if( azCol[0] ){ 10996 appendText(&sSelect, azCol[0], 0); 10997 appendText(&sSelect, ",", 0); 10998 } 10999 for(i=1; azCol[i]; i++){ 11000 appendText(&sSelect, azCol[i], quoteChar(azCol[i])); 11001 if( azCol[i+1] ){ 11002 appendText(&sSelect, ",", 0); 11003 } 11004 } 11005 freeColumnList(azCol); 11006 appendText(&sSelect, " FROM ", 0); 11007 appendText(&sSelect, zTable, quoteChar(zTable)); 11008 11009 savedDestTable = p->zDestTable; 11010 savedMode = p->mode; 11011 p->zDestTable = sTable.z; 11012 p->mode = p->cMode = MODE_Insert; 11013 rc = shell_exec(p, sSelect.z, 0); 11014 if( (rc&0xff)==SQLITE_CORRUPT ){ 11015 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 11016 toggleSelectOrder(p->db); 11017 shell_exec(p, sSelect.z, 0); 11018 toggleSelectOrder(p->db); 11019 } 11020 p->zDestTable = savedDestTable; 11021 p->mode = savedMode; 11022 freeText(&sTable); 11023 freeText(&sSelect); 11024 if( rc ) p->nErr++; 11025 } 11026 return 0; 11027 } 11028 11029 /* 11030 ** Run zQuery. Use dump_callback() as the callback routine so that 11031 ** the contents of the query are output as SQL statements. 11032 ** 11033 ** If we get a SQLITE_CORRUPT error, rerun the query after appending 11034 ** "ORDER BY rowid DESC" to the end. 11035 */ 11036 static int run_schema_dump_query( 11037 ShellState *p, 11038 const char *zQuery 11039 ){ 11040 int rc; 11041 char *zErr = 0; 11042 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr); 11043 if( rc==SQLITE_CORRUPT ){ 11044 char *zQ2; 11045 int len = strlen30(zQuery); 11046 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 11047 if( zErr ){ 11048 utf8_printf(p->out, "/****** %s ******/\n", zErr); 11049 sqlite3_free(zErr); 11050 zErr = 0; 11051 } 11052 zQ2 = malloc( len+100 ); 11053 if( zQ2==0 ) return rc; 11054 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery); 11055 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr); 11056 if( rc ){ 11057 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr); 11058 }else{ 11059 rc = SQLITE_CORRUPT; 11060 } 11061 sqlite3_free(zErr); 11062 free(zQ2); 11063 } 11064 return rc; 11065 } 11066 11067 /* 11068 ** Text of help messages. 11069 ** 11070 ** The help text for each individual command begins with a line that starts 11071 ** with ".". Subsequent lines are supplimental information. 11072 ** 11073 ** There must be two or more spaces between the end of the command and the 11074 ** start of the description of what that command does. 11075 */ 11076 static const char *(azHelp[]) = { 11077 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 11078 ".archive ... Manage SQL archives", 11079 " Each command must have exactly one of the following options:", 11080 " -c, --create Create a new archive", 11081 " -u, --update Update or add files to an existing archive", 11082 " -t, --list List contents of archive", 11083 " -x, --extract Extract files from archive", 11084 " Optional arguments:", 11085 " -v, --verbose Print each filename as it is processed", 11086 " -f FILE, --file FILE Operate on archive FILE (default is current db)", 11087 " -a FILE, --append FILE Operate on FILE opened using the apndvfs VFS", 11088 " -C DIR, --directory DIR Change to directory DIR to read/extract files", 11089 " -n, --dryrun Show the SQL that would have occurred", 11090 " Examples:", 11091 " .ar -cf archive.sar foo bar # Create archive.sar from files foo and bar", 11092 " .ar -tf archive.sar # List members of archive.sar", 11093 " .ar -xvf archive.sar # Verbosely extract files from archive.sar", 11094 " See also:", 11095 " http://sqlite.org/cli.html#sqlar_archive_support", 11096 #endif 11097 #ifndef SQLITE_OMIT_AUTHORIZATION 11098 ".auth ON|OFF Show authorizer callbacks", 11099 #endif 11100 ".backup ?DB? FILE Backup DB (default \"main\") to FILE", 11101 " --append Use the appendvfs", 11102 " --async Write to FILE without a journal and without fsync()", 11103 ".bail on|off Stop after hitting an error. Default OFF", 11104 ".binary on|off Turn binary output on or off. Default OFF", 11105 ".cd DIRECTORY Change the working directory to DIRECTORY", 11106 ".changes on|off Show number of rows changed by SQL", 11107 ".check GLOB Fail if output since .testcase does not match", 11108 ".clone NEWDB Clone data into NEWDB from the existing database", 11109 ".databases List names and files of attached databases", 11110 ".dbconfig ?op? ?val? List or change sqlite3_db_config() options", 11111 ".dbinfo ?DB? Show status information about the database", 11112 ".dump ?TABLE? ... Render all database content as SQL", 11113 " Options:", 11114 " --preserve-rowids Include ROWID values in the output", 11115 " --newlines Allow unescaped newline characters in output", 11116 " TABLE is LIKE pattern for the tables to dump", 11117 ".echo on|off Turn command echo on or off", 11118 ".eqp on|off|full|... Enable or disable automatic EXPLAIN QUERY PLAN", 11119 " Other Modes:", 11120 #ifdef SQLITE_DEBUG 11121 " test Show raw EXPLAIN QUERY PLAN output", 11122 " trace Like \"full\" but also enable \"PRAGMA vdbe_trace\"", 11123 #endif 11124 " trigger Like \"full\" but also show trigger bytecode", 11125 ".excel Display the output of next command in a spreadsheet", 11126 ".exit ?CODE? Exit this program with return-code CODE", 11127 ".expert EXPERIMENTAL. Suggest indexes for specified queries", 11128 /* Because explain mode comes on automatically now, the ".explain" mode 11129 ** is removed from the help screen. It is still supported for legacy, however */ 11130 /*".explain ?on|off|auto? Turn EXPLAIN output mode on or off or to automatic",*/ 11131 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables", 11132 ".headers on|off Turn display of headers on or off", 11133 ".help ?-all? ?PATTERN? Show help text for PATTERN", 11134 ".import FILE TABLE Import data from FILE into TABLE", 11135 #ifndef SQLITE_OMIT_TEST_CONTROL 11136 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX", 11137 #endif 11138 ".indexes ?TABLE? Show names of indexes", 11139 " If TABLE is specified, only show indexes for", 11140 " tables matching TABLE using the LIKE operator.", 11141 #ifdef SQLITE_ENABLE_IOTRACE 11142 ".iotrace FILE Enable I/O diagnostic logging to FILE", 11143 #endif 11144 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT", 11145 ".lint OPTIONS Report potential schema issues.", 11146 " Options:", 11147 " fkey-indexes Find missing foreign key indexes", 11148 #ifndef SQLITE_OMIT_LOAD_EXTENSION 11149 ".load FILE ?ENTRY? Load an extension library", 11150 #endif 11151 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout", 11152 ".mode MODE ?TABLE? Set output mode", 11153 " MODE is one of:", 11154 " ascii Columns/rows delimited by 0x1F and 0x1E", 11155 " csv Comma-separated values", 11156 " column Left-aligned columns. (See .width)", 11157 " html HTML <table> code", 11158 " insert SQL insert statements for TABLE", 11159 " line One value per line", 11160 " list Values delimited by \"|\"", 11161 " quote Escape answers as for SQL", 11162 " tabs Tab-separated values", 11163 " tcl TCL list elements", 11164 ".nullvalue STRING Use STRING in place of NULL values", 11165 ".once (-e|-x|FILE) Output for the next SQL command only to FILE", 11166 " If FILE begins with '|' then open as a pipe", 11167 " Other options:", 11168 " -e Invoke system text editor", 11169 " -x Open in a spreadsheet", 11170 ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE", 11171 " Options:", 11172 " --append Use appendvfs to append database to the end of FILE", 11173 #ifdef SQLITE_ENABLE_DESERIALIZE 11174 " --deserialize Load into memory useing sqlite3_deserialize()", 11175 " --hexdb Load the output of \"dbtotxt\" as an in-memory database", 11176 " --maxsize N Maximum size for --hexdb or --deserialized database", 11177 #endif 11178 " --new Initialize FILE to an empty database", 11179 " --readonly Open FILE readonly", 11180 " --zip FILE is a ZIP archive", 11181 ".output ?FILE? Send output to FILE or stdout if FILE is omitted", 11182 " If FILE begins with '|' then open it as a pipe.", 11183 ".print STRING... Print literal STRING", 11184 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 11185 ".progress N Invoke progress handler after every N opcodes", 11186 " --limit N Interrupt after N progress callbacks", 11187 " --once Do no more than one progress interrupt", 11188 " --quiet|-q No output except at interrupts", 11189 " --reset Reset the count for each input and interrupt", 11190 #endif 11191 ".prompt MAIN CONTINUE Replace the standard prompts", 11192 ".quit Exit this program", 11193 ".read FILE Read input from FILE", 11194 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE", 11195 ".save FILE Write in-memory database into FILE", 11196 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off", 11197 ".schema ?PATTERN? Show the CREATE statements matching PATTERN", 11198 " Options:", 11199 " --indent Try to pretty-print the schema", 11200 ".selftest ?OPTIONS? Run tests defined in the SELFTEST table", 11201 " Options:", 11202 " --init Create a new SELFTEST table", 11203 " -v Verbose output", 11204 ".separator COL ?ROW? Change the column and row separators", 11205 #if defined(SQLITE_ENABLE_SESSION) 11206 ".session ?NAME? CMD ... Create or control sessions", 11207 " Subcommands:", 11208 " attach TABLE Attach TABLE", 11209 " changeset FILE Write a changeset into FILE", 11210 " close Close one session", 11211 " enable ?BOOLEAN? Set or query the enable bit", 11212 " filter GLOB... Reject tables matching GLOBs", 11213 " indirect ?BOOLEAN? Mark or query the indirect status", 11214 " isempty Query whether the session is empty", 11215 " list List currently open session names", 11216 " open DB NAME Open a new session on DB", 11217 " patchset FILE Write a patchset into FILE", 11218 " If ?NAME? is omitted, the first defined session is used.", 11219 #endif 11220 ".sha3sum ... Compute a SHA3 hash of database content", 11221 " Options:", 11222 " --schema Also hash the sqlite_master table", 11223 " --sha3-224 Use the sha3-224 algorithm", 11224 " --sha3-256 Use the sha3-256 algorithm. This is the default.", 11225 " --sha3-384 Use the sha3-384 algorithm", 11226 " --sha3-512 Use the sha3-512 algorithm", 11227 " Any other argument is a LIKE pattern for tables to hash", 11228 #ifndef SQLITE_NOHAVE_SYSTEM 11229 ".shell CMD ARGS... Run CMD ARGS... in a system shell", 11230 #endif 11231 ".show Show the current values for various settings", 11232 ".stats ?on|off? Show stats or turn stats on or off", 11233 #ifndef SQLITE_NOHAVE_SYSTEM 11234 ".system CMD ARGS... Run CMD ARGS... in a system shell", 11235 #endif 11236 ".tables ?TABLE? List names of tables matching LIKE pattern TABLE", 11237 ".testcase NAME Begin redirecting output to 'testcase-out.txt'", 11238 ".timeout MS Try opening locked tables for MS milliseconds", 11239 ".timer on|off Turn SQL timer on or off", 11240 #ifndef SQLITE_OMIT_TRACE 11241 ".trace ?OPTIONS? Output each SQL statement as it is run", 11242 " FILE Send output to FILE", 11243 " stdout Send output to stdout", 11244 " stderr Send output to stderr", 11245 " off Disable tracing", 11246 " --expanded Expand query parameters", 11247 #ifdef SQLITE_ENABLE_NORMALIZE 11248 " --normalized Normal the SQL statements", 11249 #endif 11250 " --plain Show SQL as it is input", 11251 " --stmt Trace statement execution (SQLITE_TRACE_STMT)", 11252 " --profile Profile statements (SQLITE_TRACE_PROFILE)", 11253 " --row Trace each row (SQLITE_TRACE_ROW)", 11254 " --close Trace connection close (SQLITE_TRACE_CLOSE)", 11255 #endif /* SQLITE_OMIT_TRACE */ 11256 ".vfsinfo ?AUX? Information about the top-level VFS", 11257 ".vfslist List all available VFSes", 11258 ".vfsname ?AUX? Print the name of the VFS stack", 11259 ".width NUM1 NUM2 ... Set column widths for \"column\" mode", 11260 " Negative values right-justify", 11261 }; 11262 11263 /* 11264 ** Output help text. 11265 ** 11266 ** zPattern describes the set of commands for which help text is provided. 11267 ** If zPattern is NULL, then show all commands, but only give a one-line 11268 ** description of each. 11269 ** 11270 ** Return the number of matches. 11271 */ 11272 static int showHelp(FILE *out, const char *zPattern){ 11273 int i = 0; 11274 int j = 0; 11275 int n = 0; 11276 char *zPat; 11277 if( zPattern==0 11278 || zPattern[0]=='0' 11279 || strcmp(zPattern,"-a")==0 11280 || strcmp(zPattern,"-all")==0 11281 ){ 11282 /* Show all commands, but only one line per command */ 11283 if( zPattern==0 ) zPattern = ""; 11284 for(i=0; i<ArraySize(azHelp); i++){ 11285 if( azHelp[i][0]=='.' || zPattern[0] ){ 11286 utf8_printf(out, "%s\n", azHelp[i]); 11287 n++; 11288 } 11289 } 11290 }else{ 11291 /* Look for commands that for which zPattern is an exact prefix */ 11292 zPat = sqlite3_mprintf(".%s*", zPattern); 11293 for(i=0; i<ArraySize(azHelp); i++){ 11294 if( sqlite3_strglob(zPat, azHelp[i])==0 ){ 11295 utf8_printf(out, "%s\n", azHelp[i]); 11296 j = i+1; 11297 n++; 11298 } 11299 } 11300 sqlite3_free(zPat); 11301 if( n ){ 11302 if( n==1 ){ 11303 /* when zPattern is a prefix of exactly one command, then include the 11304 ** details of that command, which should begin at offset j */ 11305 while( j<ArraySize(azHelp)-1 && azHelp[j][0]!='.' ){ 11306 utf8_printf(out, "%s\n", azHelp[j]); 11307 j++; 11308 } 11309 } 11310 return n; 11311 } 11312 /* Look for commands that contain zPattern anywhere. Show the complete 11313 ** text of all commands that match. */ 11314 zPat = sqlite3_mprintf("%%%s%%", zPattern); 11315 for(i=0; i<ArraySize(azHelp); i++){ 11316 if( azHelp[i][0]=='.' ) j = i; 11317 if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){ 11318 utf8_printf(out, "%s\n", azHelp[j]); 11319 while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]!='.' ){ 11320 j++; 11321 utf8_printf(out, "%s\n", azHelp[j]); 11322 } 11323 i = j; 11324 n++; 11325 } 11326 } 11327 sqlite3_free(zPat); 11328 } 11329 return n; 11330 } 11331 11332 /* Forward reference */ 11333 static int process_input(ShellState *p); 11334 11335 /* 11336 ** Read the content of file zName into memory obtained from sqlite3_malloc64() 11337 ** and return a pointer to the buffer. The caller is responsible for freeing 11338 ** the memory. 11339 ** 11340 ** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes 11341 ** read. 11342 ** 11343 ** For convenience, a nul-terminator byte is always appended to the data read 11344 ** from the file before the buffer is returned. This byte is not included in 11345 ** the final value of (*pnByte), if applicable. 11346 ** 11347 ** NULL is returned if any error is encountered. The final value of *pnByte 11348 ** is undefined in this case. 11349 */ 11350 static char *readFile(const char *zName, int *pnByte){ 11351 FILE *in = fopen(zName, "rb"); 11352 long nIn; 11353 size_t nRead; 11354 char *pBuf; 11355 if( in==0 ) return 0; 11356 fseek(in, 0, SEEK_END); 11357 nIn = ftell(in); 11358 rewind(in); 11359 pBuf = sqlite3_malloc64( nIn+1 ); 11360 if( pBuf==0 ){ fclose(in); return 0; } 11361 nRead = fread(pBuf, nIn, 1, in); 11362 fclose(in); 11363 if( nRead!=1 ){ 11364 sqlite3_free(pBuf); 11365 return 0; 11366 } 11367 pBuf[nIn] = 0; 11368 if( pnByte ) *pnByte = nIn; 11369 return pBuf; 11370 } 11371 11372 #if defined(SQLITE_ENABLE_SESSION) 11373 /* 11374 ** Close a single OpenSession object and release all of its associated 11375 ** resources. 11376 */ 11377 static void session_close(OpenSession *pSession){ 11378 int i; 11379 sqlite3session_delete(pSession->p); 11380 sqlite3_free(pSession->zName); 11381 for(i=0; i<pSession->nFilter; i++){ 11382 sqlite3_free(pSession->azFilter[i]); 11383 } 11384 sqlite3_free(pSession->azFilter); 11385 memset(pSession, 0, sizeof(OpenSession)); 11386 } 11387 #endif 11388 11389 /* 11390 ** Close all OpenSession objects and release all associated resources. 11391 */ 11392 #if defined(SQLITE_ENABLE_SESSION) 11393 static void session_close_all(ShellState *p){ 11394 int i; 11395 for(i=0; i<p->nSession; i++){ 11396 session_close(&p->aSession[i]); 11397 } 11398 p->nSession = 0; 11399 } 11400 #else 11401 # define session_close_all(X) 11402 #endif 11403 11404 /* 11405 ** Implementation of the xFilter function for an open session. Omit 11406 ** any tables named by ".session filter" but let all other table through. 11407 */ 11408 #if defined(SQLITE_ENABLE_SESSION) 11409 static int session_filter(void *pCtx, const char *zTab){ 11410 OpenSession *pSession = (OpenSession*)pCtx; 11411 int i; 11412 for(i=0; i<pSession->nFilter; i++){ 11413 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0; 11414 } 11415 return 1; 11416 } 11417 #endif 11418 11419 /* 11420 ** Try to deduce the type of file for zName based on its content. Return 11421 ** one of the SHELL_OPEN_* constants. 11422 ** 11423 ** If the file does not exist or is empty but its name looks like a ZIP 11424 ** archive and the dfltZip flag is true, then assume it is a ZIP archive. 11425 ** Otherwise, assume an ordinary database regardless of the filename if 11426 ** the type cannot be determined from content. 11427 */ 11428 int deduceDatabaseType(const char *zName, int dfltZip){ 11429 FILE *f = fopen(zName, "rb"); 11430 size_t n; 11431 int rc = SHELL_OPEN_UNSPEC; 11432 char zBuf[100]; 11433 if( f==0 ){ 11434 if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 11435 return SHELL_OPEN_ZIPFILE; 11436 }else{ 11437 return SHELL_OPEN_NORMAL; 11438 } 11439 } 11440 n = fread(zBuf, 16, 1, f); 11441 if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){ 11442 fclose(f); 11443 return SHELL_OPEN_NORMAL; 11444 } 11445 fseek(f, -25, SEEK_END); 11446 n = fread(zBuf, 25, 1, f); 11447 if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){ 11448 rc = SHELL_OPEN_APPENDVFS; 11449 }else{ 11450 fseek(f, -22, SEEK_END); 11451 n = fread(zBuf, 22, 1, f); 11452 if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05 11453 && zBuf[3]==0x06 ){ 11454 rc = SHELL_OPEN_ZIPFILE; 11455 }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 11456 rc = SHELL_OPEN_ZIPFILE; 11457 } 11458 } 11459 fclose(f); 11460 return rc; 11461 } 11462 11463 #ifdef SQLITE_ENABLE_DESERIALIZE 11464 /* 11465 ** Reconstruct an in-memory database using the output from the "dbtotxt" 11466 ** program. Read content from the file in p->zDbFilename. If p->zDbFilename 11467 ** is 0, then read from standard input. 11468 */ 11469 static unsigned char *readHexDb(ShellState *p, int *pnData){ 11470 unsigned char *a = 0; 11471 int nLine; 11472 int n = 0; 11473 int pgsz = 0; 11474 int iOffset = 0; 11475 int j, k; 11476 int rc; 11477 FILE *in; 11478 unsigned char x[16]; 11479 char zLine[1000]; 11480 if( p->zDbFilename ){ 11481 in = fopen(p->zDbFilename, "r"); 11482 if( in==0 ){ 11483 utf8_printf(stderr, "cannot open \"%s\" for reading\n", p->zDbFilename); 11484 return 0; 11485 } 11486 nLine = 0; 11487 }else{ 11488 in = p->in; 11489 nLine = p->lineno; 11490 } 11491 *pnData = 0; 11492 nLine++; 11493 if( fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error; 11494 rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz); 11495 if( rc!=2 ) goto readHexDb_error; 11496 if( n<=0 ) goto readHexDb_error; 11497 a = sqlite3_malloc( n ); 11498 if( a==0 ){ 11499 utf8_printf(stderr, "Out of memory!\n"); 11500 goto readHexDb_error; 11501 } 11502 memset(a, 0, n); 11503 if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){ 11504 utf8_printf(stderr, "invalid pagesize\n"); 11505 goto readHexDb_error; 11506 } 11507 for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){ 11508 rc = sscanf(zLine, "| page %d offset %d", &j, &k); 11509 if( rc==2 ){ 11510 iOffset = k; 11511 continue; 11512 } 11513 if( strncmp(zLine, "| end ", 6)==0 ){ 11514 break; 11515 } 11516 rc = sscanf(zLine,"| %d: %hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx" 11517 " %hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx", 11518 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7], 11519 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]); 11520 if( rc==17 ){ 11521 k = iOffset+j; 11522 if( k+16<=n ){ 11523 memcpy(a+k, x, 16); 11524 } 11525 } 11526 } 11527 *pnData = n; 11528 if( in!=p->in ){ 11529 fclose(in); 11530 }else{ 11531 p->lineno = nLine; 11532 } 11533 return a; 11534 11535 readHexDb_error: 11536 if( in!=stdin ){ 11537 fclose(in); 11538 }else{ 11539 while( fgets(zLine, sizeof(zLine), p->in)!=0 ){ 11540 nLine++; 11541 if(strncmp(zLine, "| end ", 6)==0 ) break; 11542 } 11543 p->lineno = nLine; 11544 } 11545 sqlite3_free(a); 11546 utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine); 11547 return 0; 11548 } 11549 #endif /* SQLITE_ENABLE_DESERIALIZE */ 11550 11551 /* Flags for open_db(). 11552 ** 11553 ** The default behavior of open_db() is to exit(1) if the database fails to 11554 ** open. The OPEN_DB_KEEPALIVE flag changes that so that it prints an error 11555 ** but still returns without calling exit. 11556 ** 11557 ** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a 11558 ** ZIP archive if the file does not exist or is empty and its name matches 11559 ** the *.zip pattern. 11560 */ 11561 #define OPEN_DB_KEEPALIVE 0x001 /* Return after error if true */ 11562 #define OPEN_DB_ZIPFILE 0x002 /* Open as ZIP if name matches *.zip */ 11563 11564 /* 11565 ** Make sure the database is open. If it is not, then open it. If 11566 ** the database fails to open, print an error message and exit. 11567 */ 11568 static void open_db(ShellState *p, int openFlags){ 11569 if( p->db==0 ){ 11570 if( p->openMode==SHELL_OPEN_UNSPEC ){ 11571 if( p->zDbFilename==0 || p->zDbFilename[0]==0 ){ 11572 p->openMode = SHELL_OPEN_NORMAL; 11573 }else{ 11574 p->openMode = (u8)deduceDatabaseType(p->zDbFilename, 11575 (openFlags & OPEN_DB_ZIPFILE)!=0); 11576 } 11577 } 11578 switch( p->openMode ){ 11579 case SHELL_OPEN_APPENDVFS: { 11580 sqlite3_open_v2(p->zDbFilename, &p->db, 11581 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, "apndvfs"); 11582 break; 11583 } 11584 case SHELL_OPEN_HEXDB: 11585 case SHELL_OPEN_DESERIALIZE: { 11586 sqlite3_open(0, &p->db); 11587 break; 11588 } 11589 case SHELL_OPEN_ZIPFILE: { 11590 sqlite3_open(":memory:", &p->db); 11591 break; 11592 } 11593 case SHELL_OPEN_READONLY: { 11594 sqlite3_open_v2(p->zDbFilename, &p->db, SQLITE_OPEN_READONLY, 0); 11595 break; 11596 } 11597 case SHELL_OPEN_UNSPEC: 11598 case SHELL_OPEN_NORMAL: { 11599 sqlite3_open(p->zDbFilename, &p->db); 11600 break; 11601 } 11602 } 11603 globalDb = p->db; 11604 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){ 11605 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n", 11606 p->zDbFilename, sqlite3_errmsg(p->db)); 11607 if( openFlags & OPEN_DB_KEEPALIVE ){ 11608 sqlite3_open(":memory:", &p->db); 11609 return; 11610 } 11611 exit(1); 11612 } 11613 #ifndef SQLITE_OMIT_LOAD_EXTENSION 11614 sqlite3_enable_load_extension(p->db, 1); 11615 #endif 11616 sqlite3_fileio_init(p->db, 0, 0); 11617 sqlite3_shathree_init(p->db, 0, 0); 11618 sqlite3_completion_init(p->db, 0, 0); 11619 #ifdef SQLITE_HAVE_ZLIB 11620 sqlite3_zipfile_init(p->db, 0, 0); 11621 sqlite3_sqlar_init(p->db, 0, 0); 11622 #endif 11623 sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0, 11624 shellAddSchemaName, 0, 0); 11625 sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, 0, 11626 shellModuleSchema, 0, 0); 11627 sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p, 11628 shellPutsFunc, 0, 0); 11629 #ifndef SQLITE_NOHAVE_SYSTEM 11630 sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0, 11631 editFunc, 0, 0); 11632 sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0, 11633 editFunc, 0, 0); 11634 #endif 11635 if( p->openMode==SHELL_OPEN_ZIPFILE ){ 11636 char *zSql = sqlite3_mprintf( 11637 "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", p->zDbFilename); 11638 sqlite3_exec(p->db, zSql, 0, 0, 0); 11639 sqlite3_free(zSql); 11640 } 11641 #ifdef SQLITE_ENABLE_DESERIALIZE 11642 else 11643 if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){ 11644 int rc; 11645 int nData = 0; 11646 unsigned char *aData; 11647 if( p->openMode==SHELL_OPEN_DESERIALIZE ){ 11648 aData = (unsigned char*)readFile(p->zDbFilename, &nData); 11649 }else{ 11650 aData = readHexDb(p, &nData); 11651 if( aData==0 ){ 11652 utf8_printf(stderr, "Error in hexdb input\n"); 11653 return; 11654 } 11655 } 11656 rc = sqlite3_deserialize(p->db, "main", aData, nData, nData, 11657 SQLITE_DESERIALIZE_RESIZEABLE | 11658 SQLITE_DESERIALIZE_FREEONCLOSE); 11659 if( rc ){ 11660 utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc); 11661 } 11662 if( p->szMax>0 ){ 11663 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax); 11664 } 11665 } 11666 #endif 11667 } 11668 } 11669 11670 /* 11671 ** Attempt to close the databaes connection. Report errors. 11672 */ 11673 void close_db(sqlite3 *db){ 11674 int rc = sqlite3_close(db); 11675 if( rc ){ 11676 utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n", 11677 rc, sqlite3_errmsg(db)); 11678 } 11679 } 11680 11681 #if HAVE_READLINE || HAVE_EDITLINE 11682 /* 11683 ** Readline completion callbacks 11684 */ 11685 static char *readline_completion_generator(const char *text, int state){ 11686 static sqlite3_stmt *pStmt = 0; 11687 char *zRet; 11688 if( state==0 ){ 11689 char *zSql; 11690 sqlite3_finalize(pStmt); 11691 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 11692 " FROM completion(%Q) ORDER BY 1", text); 11693 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 11694 sqlite3_free(zSql); 11695 } 11696 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 11697 zRet = strdup((const char*)sqlite3_column_text(pStmt, 0)); 11698 }else{ 11699 sqlite3_finalize(pStmt); 11700 pStmt = 0; 11701 zRet = 0; 11702 } 11703 return zRet; 11704 } 11705 static char **readline_completion(const char *zText, int iStart, int iEnd){ 11706 rl_attempted_completion_over = 1; 11707 return rl_completion_matches(zText, readline_completion_generator); 11708 } 11709 11710 #elif HAVE_LINENOISE 11711 /* 11712 ** Linenoise completion callback 11713 */ 11714 static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){ 11715 int nLine = strlen30(zLine); 11716 int i, iStart; 11717 sqlite3_stmt *pStmt = 0; 11718 char *zSql; 11719 char zBuf[1000]; 11720 11721 if( nLine>sizeof(zBuf)-30 ) return; 11722 if( zLine[0]=='.' || zLine[0]=='#') return; 11723 for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){} 11724 if( i==nLine-1 ) return; 11725 iStart = i+1; 11726 memcpy(zBuf, zLine, iStart); 11727 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 11728 " FROM completion(%Q,%Q) ORDER BY 1", 11729 &zLine[iStart], zLine); 11730 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 11731 sqlite3_free(zSql); 11732 sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */ 11733 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 11734 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0); 11735 int nCompletion = sqlite3_column_bytes(pStmt, 0); 11736 if( iStart+nCompletion < sizeof(zBuf)-1 ){ 11737 memcpy(zBuf+iStart, zCompletion, nCompletion+1); 11738 linenoiseAddCompletion(lc, zBuf); 11739 } 11740 } 11741 sqlite3_finalize(pStmt); 11742 } 11743 #endif 11744 11745 /* 11746 ** Do C-language style dequoting. 11747 ** 11748 ** \a -> alarm 11749 ** \b -> backspace 11750 ** \t -> tab 11751 ** \n -> newline 11752 ** \v -> vertical tab 11753 ** \f -> form feed 11754 ** \r -> carriage return 11755 ** \s -> space 11756 ** \" -> " 11757 ** \' -> ' 11758 ** \\ -> backslash 11759 ** \NNN -> ascii character NNN in octal 11760 */ 11761 static void resolve_backslashes(char *z){ 11762 int i, j; 11763 char c; 11764 while( *z && *z!='\\' ) z++; 11765 for(i=j=0; (c = z[i])!=0; i++, j++){ 11766 if( c=='\\' && z[i+1]!=0 ){ 11767 c = z[++i]; 11768 if( c=='a' ){ 11769 c = '\a'; 11770 }else if( c=='b' ){ 11771 c = '\b'; 11772 }else if( c=='t' ){ 11773 c = '\t'; 11774 }else if( c=='n' ){ 11775 c = '\n'; 11776 }else if( c=='v' ){ 11777 c = '\v'; 11778 }else if( c=='f' ){ 11779 c = '\f'; 11780 }else if( c=='r' ){ 11781 c = '\r'; 11782 }else if( c=='"' ){ 11783 c = '"'; 11784 }else if( c=='\'' ){ 11785 c = '\''; 11786 }else if( c=='\\' ){ 11787 c = '\\'; 11788 }else if( c>='0' && c<='7' ){ 11789 c -= '0'; 11790 if( z[i+1]>='0' && z[i+1]<='7' ){ 11791 i++; 11792 c = (c<<3) + z[i] - '0'; 11793 if( z[i+1]>='0' && z[i+1]<='7' ){ 11794 i++; 11795 c = (c<<3) + z[i] - '0'; 11796 } 11797 } 11798 } 11799 } 11800 z[j] = c; 11801 } 11802 if( j<i ) z[j] = 0; 11803 } 11804 11805 /* 11806 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0 11807 ** for TRUE and FALSE. Return the integer value if appropriate. 11808 */ 11809 static int booleanValue(const char *zArg){ 11810 int i; 11811 if( zArg[0]=='0' && zArg[1]=='x' ){ 11812 for(i=2; hexDigitValue(zArg[i])>=0; i++){} 11813 }else{ 11814 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){} 11815 } 11816 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff); 11817 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){ 11818 return 1; 11819 } 11820 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){ 11821 return 0; 11822 } 11823 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", 11824 zArg); 11825 return 0; 11826 } 11827 11828 /* 11829 ** Set or clear a shell flag according to a boolean value. 11830 */ 11831 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){ 11832 if( booleanValue(zArg) ){ 11833 ShellSetFlag(p, mFlag); 11834 }else{ 11835 ShellClearFlag(p, mFlag); 11836 } 11837 } 11838 11839 /* 11840 ** Close an output file, assuming it is not stderr or stdout 11841 */ 11842 static void output_file_close(FILE *f){ 11843 if( f && f!=stdout && f!=stderr ) fclose(f); 11844 } 11845 11846 /* 11847 ** Try to open an output file. The names "stdout" and "stderr" are 11848 ** recognized and do the right thing. NULL is returned if the output 11849 ** filename is "off". 11850 */ 11851 static FILE *output_file_open(const char *zFile, int bTextMode){ 11852 FILE *f; 11853 if( strcmp(zFile,"stdout")==0 ){ 11854 f = stdout; 11855 }else if( strcmp(zFile, "stderr")==0 ){ 11856 f = stderr; 11857 }else if( strcmp(zFile, "off")==0 ){ 11858 f = 0; 11859 }else{ 11860 f = fopen(zFile, bTextMode ? "w" : "wb"); 11861 if( f==0 ){ 11862 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 11863 } 11864 } 11865 return f; 11866 } 11867 11868 #ifndef SQLITE_OMIT_TRACE 11869 /* 11870 ** A routine for handling output from sqlite3_trace(). 11871 */ 11872 static int sql_trace_callback( 11873 unsigned mType, /* The trace type */ 11874 void *pArg, /* The ShellState pointer */ 11875 void *pP, /* Usually a pointer to sqlite_stmt */ 11876 void *pX /* Auxiliary output */ 11877 ){ 11878 ShellState *p = (ShellState*)pArg; 11879 sqlite3_stmt *pStmt; 11880 const char *zSql; 11881 int nSql; 11882 if( p->traceOut==0 ) return 0; 11883 if( mType==SQLITE_TRACE_CLOSE ){ 11884 utf8_printf(p->traceOut, "-- closing database connection\n"); 11885 return 0; 11886 } 11887 if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){ 11888 zSql = (const char*)pX; 11889 }else{ 11890 pStmt = (sqlite3_stmt*)pP; 11891 switch( p->eTraceType ){ 11892 case SHELL_TRACE_EXPANDED: { 11893 zSql = sqlite3_expanded_sql(pStmt); 11894 break; 11895 } 11896 #ifdef SQLITE_ENABLE_NORMALIZE 11897 case SHELL_TRACE_NORMALIZED: { 11898 zSql = sqlite3_normalized_sql(pStmt); 11899 break; 11900 } 11901 #endif 11902 default: { 11903 zSql = sqlite3_sql(pStmt); 11904 break; 11905 } 11906 } 11907 } 11908 if( zSql==0 ) return 0; 11909 nSql = strlen30(zSql); 11910 while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; } 11911 switch( mType ){ 11912 case SQLITE_TRACE_ROW: 11913 case SQLITE_TRACE_STMT: { 11914 utf8_printf(p->traceOut, "%.*s;\n", nSql, zSql); 11915 break; 11916 } 11917 case SQLITE_TRACE_PROFILE: { 11918 sqlite3_int64 nNanosec = *(sqlite3_int64*)pX; 11919 utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", nSql, zSql, nNanosec); 11920 break; 11921 } 11922 } 11923 return 0; 11924 } 11925 #endif 11926 11927 /* 11928 ** A no-op routine that runs with the ".breakpoint" doc-command. This is 11929 ** a useful spot to set a debugger breakpoint. 11930 */ 11931 static void test_breakpoint(void){ 11932 static int nCall = 0; 11933 nCall++; 11934 } 11935 11936 /* 11937 ** An object used to read a CSV and other files for import. 11938 */ 11939 typedef struct ImportCtx ImportCtx; 11940 struct ImportCtx { 11941 const char *zFile; /* Name of the input file */ 11942 FILE *in; /* Read the CSV text from this input stream */ 11943 char *z; /* Accumulated text for a field */ 11944 int n; /* Number of bytes in z */ 11945 int nAlloc; /* Space allocated for z[] */ 11946 int nLine; /* Current line number */ 11947 int bNotFirst; /* True if one or more bytes already read */ 11948 int cTerm; /* Character that terminated the most recent field */ 11949 int cColSep; /* The column separator character. (Usually ",") */ 11950 int cRowSep; /* The row separator character. (Usually "\n") */ 11951 }; 11952 11953 /* Append a single byte to z[] */ 11954 static void import_append_char(ImportCtx *p, int c){ 11955 if( p->n+1>=p->nAlloc ){ 11956 p->nAlloc += p->nAlloc + 100; 11957 p->z = sqlite3_realloc64(p->z, p->nAlloc); 11958 if( p->z==0 ) shell_out_of_memory(); 11959 } 11960 p->z[p->n++] = (char)c; 11961 } 11962 11963 /* Read a single field of CSV text. Compatible with rfc4180 and extended 11964 ** with the option of having a separator other than ",". 11965 ** 11966 ** + Input comes from p->in. 11967 ** + Store results in p->z of length p->n. Space to hold p->z comes 11968 ** from sqlite3_malloc64(). 11969 ** + Use p->cSep as the column separator. The default is ",". 11970 ** + Use p->rSep as the row separator. The default is "\n". 11971 ** + Keep track of the line number in p->nLine. 11972 ** + Store the character that terminates the field in p->cTerm. Store 11973 ** EOF on end-of-file. 11974 ** + Report syntax errors on stderr 11975 */ 11976 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){ 11977 int c; 11978 int cSep = p->cColSep; 11979 int rSep = p->cRowSep; 11980 p->n = 0; 11981 c = fgetc(p->in); 11982 if( c==EOF || seenInterrupt ){ 11983 p->cTerm = EOF; 11984 return 0; 11985 } 11986 if( c=='"' ){ 11987 int pc, ppc; 11988 int startLine = p->nLine; 11989 int cQuote = c; 11990 pc = ppc = 0; 11991 while( 1 ){ 11992 c = fgetc(p->in); 11993 if( c==rSep ) p->nLine++; 11994 if( c==cQuote ){ 11995 if( pc==cQuote ){ 11996 pc = 0; 11997 continue; 11998 } 11999 } 12000 if( (c==cSep && pc==cQuote) 12001 || (c==rSep && pc==cQuote) 12002 || (c==rSep && pc=='\r' && ppc==cQuote) 12003 || (c==EOF && pc==cQuote) 12004 ){ 12005 do{ p->n--; }while( p->z[p->n]!=cQuote ); 12006 p->cTerm = c; 12007 break; 12008 } 12009 if( pc==cQuote && c!='\r' ){ 12010 utf8_printf(stderr, "%s:%d: unescaped %c character\n", 12011 p->zFile, p->nLine, cQuote); 12012 } 12013 if( c==EOF ){ 12014 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n", 12015 p->zFile, startLine, cQuote); 12016 p->cTerm = c; 12017 break; 12018 } 12019 import_append_char(p, c); 12020 ppc = pc; 12021 pc = c; 12022 } 12023 }else{ 12024 /* If this is the first field being parsed and it begins with the 12025 ** UTF-8 BOM (0xEF BB BF) then skip the BOM */ 12026 if( (c&0xff)==0xef && p->bNotFirst==0 ){ 12027 import_append_char(p, c); 12028 c = fgetc(p->in); 12029 if( (c&0xff)==0xbb ){ 12030 import_append_char(p, c); 12031 c = fgetc(p->in); 12032 if( (c&0xff)==0xbf ){ 12033 p->bNotFirst = 1; 12034 p->n = 0; 12035 return csv_read_one_field(p); 12036 } 12037 } 12038 } 12039 while( c!=EOF && c!=cSep && c!=rSep ){ 12040 import_append_char(p, c); 12041 c = fgetc(p->in); 12042 } 12043 if( c==rSep ){ 12044 p->nLine++; 12045 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--; 12046 } 12047 p->cTerm = c; 12048 } 12049 if( p->z ) p->z[p->n] = 0; 12050 p->bNotFirst = 1; 12051 return p->z; 12052 } 12053 12054 /* Read a single field of ASCII delimited text. 12055 ** 12056 ** + Input comes from p->in. 12057 ** + Store results in p->z of length p->n. Space to hold p->z comes 12058 ** from sqlite3_malloc64(). 12059 ** + Use p->cSep as the column separator. The default is "\x1F". 12060 ** + Use p->rSep as the row separator. The default is "\x1E". 12061 ** + Keep track of the row number in p->nLine. 12062 ** + Store the character that terminates the field in p->cTerm. Store 12063 ** EOF on end-of-file. 12064 ** + Report syntax errors on stderr 12065 */ 12066 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){ 12067 int c; 12068 int cSep = p->cColSep; 12069 int rSep = p->cRowSep; 12070 p->n = 0; 12071 c = fgetc(p->in); 12072 if( c==EOF || seenInterrupt ){ 12073 p->cTerm = EOF; 12074 return 0; 12075 } 12076 while( c!=EOF && c!=cSep && c!=rSep ){ 12077 import_append_char(p, c); 12078 c = fgetc(p->in); 12079 } 12080 if( c==rSep ){ 12081 p->nLine++; 12082 } 12083 p->cTerm = c; 12084 if( p->z ) p->z[p->n] = 0; 12085 return p->z; 12086 } 12087 12088 /* 12089 ** Try to transfer data for table zTable. If an error is seen while 12090 ** moving forward, try to go backwards. The backwards movement won't 12091 ** work for WITHOUT ROWID tables. 12092 */ 12093 static void tryToCloneData( 12094 ShellState *p, 12095 sqlite3 *newDb, 12096 const char *zTable 12097 ){ 12098 sqlite3_stmt *pQuery = 0; 12099 sqlite3_stmt *pInsert = 0; 12100 char *zQuery = 0; 12101 char *zInsert = 0; 12102 int rc; 12103 int i, j, n; 12104 int nTable = strlen30(zTable); 12105 int k = 0; 12106 int cnt = 0; 12107 const int spinRate = 10000; 12108 12109 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); 12110 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 12111 if( rc ){ 12112 utf8_printf(stderr, "Error %d: %s on [%s]\n", 12113 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 12114 zQuery); 12115 goto end_data_xfer; 12116 } 12117 n = sqlite3_column_count(pQuery); 12118 zInsert = sqlite3_malloc64(200 + nTable + n*3); 12119 if( zInsert==0 ) shell_out_of_memory(); 12120 sqlite3_snprintf(200+nTable,zInsert, 12121 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable); 12122 i = strlen30(zInsert); 12123 for(j=1; j<n; j++){ 12124 memcpy(zInsert+i, ",?", 2); 12125 i += 2; 12126 } 12127 memcpy(zInsert+i, ");", 3); 12128 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0); 12129 if( rc ){ 12130 utf8_printf(stderr, "Error %d: %s on [%s]\n", 12131 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), 12132 zQuery); 12133 goto end_data_xfer; 12134 } 12135 for(k=0; k<2; k++){ 12136 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 12137 for(i=0; i<n; i++){ 12138 switch( sqlite3_column_type(pQuery, i) ){ 12139 case SQLITE_NULL: { 12140 sqlite3_bind_null(pInsert, i+1); 12141 break; 12142 } 12143 case SQLITE_INTEGER: { 12144 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i)); 12145 break; 12146 } 12147 case SQLITE_FLOAT: { 12148 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i)); 12149 break; 12150 } 12151 case SQLITE_TEXT: { 12152 sqlite3_bind_text(pInsert, i+1, 12153 (const char*)sqlite3_column_text(pQuery,i), 12154 -1, SQLITE_STATIC); 12155 break; 12156 } 12157 case SQLITE_BLOB: { 12158 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i), 12159 sqlite3_column_bytes(pQuery,i), 12160 SQLITE_STATIC); 12161 break; 12162 } 12163 } 12164 } /* End for */ 12165 rc = sqlite3_step(pInsert); 12166 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){ 12167 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb), 12168 sqlite3_errmsg(newDb)); 12169 } 12170 sqlite3_reset(pInsert); 12171 cnt++; 12172 if( (cnt%spinRate)==0 ){ 12173 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]); 12174 fflush(stdout); 12175 } 12176 } /* End while */ 12177 if( rc==SQLITE_DONE ) break; 12178 sqlite3_finalize(pQuery); 12179 sqlite3_free(zQuery); 12180 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;", 12181 zTable); 12182 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 12183 if( rc ){ 12184 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable); 12185 break; 12186 } 12187 } /* End for(k=0...) */ 12188 12189 end_data_xfer: 12190 sqlite3_finalize(pQuery); 12191 sqlite3_finalize(pInsert); 12192 sqlite3_free(zQuery); 12193 sqlite3_free(zInsert); 12194 } 12195 12196 12197 /* 12198 ** Try to transfer all rows of the schema that match zWhere. For 12199 ** each row, invoke xForEach() on the object defined by that row. 12200 ** If an error is encountered while moving forward through the 12201 ** sqlite_master table, try again moving backwards. 12202 */ 12203 static void tryToCloneSchema( 12204 ShellState *p, 12205 sqlite3 *newDb, 12206 const char *zWhere, 12207 void (*xForEach)(ShellState*,sqlite3*,const char*) 12208 ){ 12209 sqlite3_stmt *pQuery = 0; 12210 char *zQuery = 0; 12211 int rc; 12212 const unsigned char *zName; 12213 const unsigned char *zSql; 12214 char *zErrMsg = 0; 12215 12216 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" 12217 " WHERE %s", zWhere); 12218 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 12219 if( rc ){ 12220 utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 12221 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 12222 zQuery); 12223 goto end_schema_xfer; 12224 } 12225 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 12226 zName = sqlite3_column_text(pQuery, 0); 12227 zSql = sqlite3_column_text(pQuery, 1); 12228 printf("%s... ", zName); fflush(stdout); 12229 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 12230 if( zErrMsg ){ 12231 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 12232 sqlite3_free(zErrMsg); 12233 zErrMsg = 0; 12234 } 12235 if( xForEach ){ 12236 xForEach(p, newDb, (const char*)zName); 12237 } 12238 printf("done\n"); 12239 } 12240 if( rc!=SQLITE_DONE ){ 12241 sqlite3_finalize(pQuery); 12242 sqlite3_free(zQuery); 12243 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" 12244 " WHERE %s ORDER BY rowid DESC", zWhere); 12245 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 12246 if( rc ){ 12247 utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 12248 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 12249 zQuery); 12250 goto end_schema_xfer; 12251 } 12252 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 12253 zName = sqlite3_column_text(pQuery, 0); 12254 zSql = sqlite3_column_text(pQuery, 1); 12255 printf("%s... ", zName); fflush(stdout); 12256 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 12257 if( zErrMsg ){ 12258 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 12259 sqlite3_free(zErrMsg); 12260 zErrMsg = 0; 12261 } 12262 if( xForEach ){ 12263 xForEach(p, newDb, (const char*)zName); 12264 } 12265 printf("done\n"); 12266 } 12267 } 12268 end_schema_xfer: 12269 sqlite3_finalize(pQuery); 12270 sqlite3_free(zQuery); 12271 } 12272 12273 /* 12274 ** Open a new database file named "zNewDb". Try to recover as much information 12275 ** as possible out of the main database (which might be corrupt) and write it 12276 ** into zNewDb. 12277 */ 12278 static void tryToClone(ShellState *p, const char *zNewDb){ 12279 int rc; 12280 sqlite3 *newDb = 0; 12281 if( access(zNewDb,0)==0 ){ 12282 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb); 12283 return; 12284 } 12285 rc = sqlite3_open(zNewDb, &newDb); 12286 if( rc ){ 12287 utf8_printf(stderr, "Cannot create output database: %s\n", 12288 sqlite3_errmsg(newDb)); 12289 }else{ 12290 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0); 12291 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0); 12292 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData); 12293 tryToCloneSchema(p, newDb, "type!='table'", 0); 12294 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0); 12295 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 12296 } 12297 close_db(newDb); 12298 } 12299 12300 /* 12301 ** Change the output file back to stdout. 12302 ** 12303 ** If the p->doXdgOpen flag is set, that means the output was being 12304 ** redirected to a temporary file named by p->zTempFile. In that case, 12305 ** launch start/open/xdg-open on that temporary file. 12306 */ 12307 static void output_reset(ShellState *p){ 12308 if( p->outfile[0]=='|' ){ 12309 #ifndef SQLITE_OMIT_POPEN 12310 pclose(p->out); 12311 #endif 12312 }else{ 12313 output_file_close(p->out); 12314 #ifndef SQLITE_NOHAVE_SYSTEM 12315 if( p->doXdgOpen ){ 12316 const char *zXdgOpenCmd = 12317 #if defined(_WIN32) 12318 "start"; 12319 #elif defined(__APPLE__) 12320 "open"; 12321 #else 12322 "xdg-open"; 12323 #endif 12324 char *zCmd; 12325 zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile); 12326 if( system(zCmd) ){ 12327 utf8_printf(stderr, "Failed: [%s]\n", zCmd); 12328 } 12329 sqlite3_free(zCmd); 12330 outputModePop(p); 12331 p->doXdgOpen = 0; 12332 } 12333 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 12334 } 12335 p->outfile[0] = 0; 12336 p->out = stdout; 12337 } 12338 12339 /* 12340 ** Run an SQL command and return the single integer result. 12341 */ 12342 static int db_int(ShellState *p, const char *zSql){ 12343 sqlite3_stmt *pStmt; 12344 int res = 0; 12345 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 12346 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ 12347 res = sqlite3_column_int(pStmt,0); 12348 } 12349 sqlite3_finalize(pStmt); 12350 return res; 12351 } 12352 12353 /* 12354 ** Convert a 2-byte or 4-byte big-endian integer into a native integer 12355 */ 12356 static unsigned int get2byteInt(unsigned char *a){ 12357 return (a[0]<<8) + a[1]; 12358 } 12359 static unsigned int get4byteInt(unsigned char *a){ 12360 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3]; 12361 } 12362 12363 /* 12364 ** Implementation of the ".info" command. 12365 ** 12366 ** Return 1 on error, 2 to exit, and 0 otherwise. 12367 */ 12368 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){ 12369 static const struct { const char *zName; int ofst; } aField[] = { 12370 { "file change counter:", 24 }, 12371 { "database page count:", 28 }, 12372 { "freelist page count:", 36 }, 12373 { "schema cookie:", 40 }, 12374 { "schema format:", 44 }, 12375 { "default cache size:", 48 }, 12376 { "autovacuum top root:", 52 }, 12377 { "incremental vacuum:", 64 }, 12378 { "text encoding:", 56 }, 12379 { "user version:", 60 }, 12380 { "application id:", 68 }, 12381 { "software version:", 96 }, 12382 }; 12383 static const struct { const char *zName; const char *zSql; } aQuery[] = { 12384 { "number of tables:", 12385 "SELECT count(*) FROM %s WHERE type='table'" }, 12386 { "number of indexes:", 12387 "SELECT count(*) FROM %s WHERE type='index'" }, 12388 { "number of triggers:", 12389 "SELECT count(*) FROM %s WHERE type='trigger'" }, 12390 { "number of views:", 12391 "SELECT count(*) FROM %s WHERE type='view'" }, 12392 { "schema size:", 12393 "SELECT total(length(sql)) FROM %s" }, 12394 }; 12395 int i; 12396 unsigned iDataVersion; 12397 char *zSchemaTab; 12398 char *zDb = nArg>=2 ? azArg[1] : "main"; 12399 sqlite3_stmt *pStmt = 0; 12400 unsigned char aHdr[100]; 12401 open_db(p, 0); 12402 if( p->db==0 ) return 1; 12403 sqlite3_prepare_v2(p->db,"SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1", 12404 -1, &pStmt, 0); 12405 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC); 12406 if( sqlite3_step(pStmt)==SQLITE_ROW 12407 && sqlite3_column_bytes(pStmt,0)>100 12408 ){ 12409 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100); 12410 sqlite3_finalize(pStmt); 12411 }else{ 12412 raw_printf(stderr, "unable to read database header\n"); 12413 sqlite3_finalize(pStmt); 12414 return 1; 12415 } 12416 i = get2byteInt(aHdr+16); 12417 if( i==1 ) i = 65536; 12418 utf8_printf(p->out, "%-20s %d\n", "database page size:", i); 12419 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]); 12420 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]); 12421 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]); 12422 for(i=0; i<ArraySize(aField); i++){ 12423 int ofst = aField[i].ofst; 12424 unsigned int val = get4byteInt(aHdr + ofst); 12425 utf8_printf(p->out, "%-20s %u", aField[i].zName, val); 12426 switch( ofst ){ 12427 case 56: { 12428 if( val==1 ) raw_printf(p->out, " (utf8)"); 12429 if( val==2 ) raw_printf(p->out, " (utf16le)"); 12430 if( val==3 ) raw_printf(p->out, " (utf16be)"); 12431 } 12432 } 12433 raw_printf(p->out, "\n"); 12434 } 12435 if( zDb==0 ){ 12436 zSchemaTab = sqlite3_mprintf("main.sqlite_master"); 12437 }else if( strcmp(zDb,"temp")==0 ){ 12438 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master"); 12439 }else{ 12440 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb); 12441 } 12442 for(i=0; i<ArraySize(aQuery); i++){ 12443 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab); 12444 int val = db_int(p, zSql); 12445 sqlite3_free(zSql); 12446 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val); 12447 } 12448 sqlite3_free(zSchemaTab); 12449 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion); 12450 utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion); 12451 return 0; 12452 } 12453 12454 /* 12455 ** Print the current sqlite3_errmsg() value to stderr and return 1. 12456 */ 12457 static int shellDatabaseError(sqlite3 *db){ 12458 const char *zErr = sqlite3_errmsg(db); 12459 utf8_printf(stderr, "Error: %s\n", zErr); 12460 return 1; 12461 } 12462 12463 /* 12464 ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE 12465 ** if they match and FALSE (0) if they do not match. 12466 ** 12467 ** Globbing rules: 12468 ** 12469 ** '*' Matches any sequence of zero or more characters. 12470 ** 12471 ** '?' Matches exactly one character. 12472 ** 12473 ** [...] Matches one character from the enclosed list of 12474 ** characters. 12475 ** 12476 ** [^...] Matches one character not in the enclosed list. 12477 ** 12478 ** '#' Matches any sequence of one or more digits with an 12479 ** optional + or - sign in front 12480 ** 12481 ** ' ' Any span of whitespace matches any other span of 12482 ** whitespace. 12483 ** 12484 ** Extra whitespace at the end of z[] is ignored. 12485 */ 12486 static int testcase_glob(const char *zGlob, const char *z){ 12487 int c, c2; 12488 int invert; 12489 int seen; 12490 12491 while( (c = (*(zGlob++)))!=0 ){ 12492 if( IsSpace(c) ){ 12493 if( !IsSpace(*z) ) return 0; 12494 while( IsSpace(*zGlob) ) zGlob++; 12495 while( IsSpace(*z) ) z++; 12496 }else if( c=='*' ){ 12497 while( (c=(*(zGlob++))) == '*' || c=='?' ){ 12498 if( c=='?' && (*(z++))==0 ) return 0; 12499 } 12500 if( c==0 ){ 12501 return 1; 12502 }else if( c=='[' ){ 12503 while( *z && testcase_glob(zGlob-1,z)==0 ){ 12504 z++; 12505 } 12506 return (*z)!=0; 12507 } 12508 while( (c2 = (*(z++)))!=0 ){ 12509 while( c2!=c ){ 12510 c2 = *(z++); 12511 if( c2==0 ) return 0; 12512 } 12513 if( testcase_glob(zGlob,z) ) return 1; 12514 } 12515 return 0; 12516 }else if( c=='?' ){ 12517 if( (*(z++))==0 ) return 0; 12518 }else if( c=='[' ){ 12519 int prior_c = 0; 12520 seen = 0; 12521 invert = 0; 12522 c = *(z++); 12523 if( c==0 ) return 0; 12524 c2 = *(zGlob++); 12525 if( c2=='^' ){ 12526 invert = 1; 12527 c2 = *(zGlob++); 12528 } 12529 if( c2==']' ){ 12530 if( c==']' ) seen = 1; 12531 c2 = *(zGlob++); 12532 } 12533 while( c2 && c2!=']' ){ 12534 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){ 12535 c2 = *(zGlob++); 12536 if( c>=prior_c && c<=c2 ) seen = 1; 12537 prior_c = 0; 12538 }else{ 12539 if( c==c2 ){ 12540 seen = 1; 12541 } 12542 prior_c = c2; 12543 } 12544 c2 = *(zGlob++); 12545 } 12546 if( c2==0 || (seen ^ invert)==0 ) return 0; 12547 }else if( c=='#' ){ 12548 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++; 12549 if( !IsDigit(z[0]) ) return 0; 12550 z++; 12551 while( IsDigit(z[0]) ){ z++; } 12552 }else{ 12553 if( c!=(*(z++)) ) return 0; 12554 } 12555 } 12556 while( IsSpace(*z) ){ z++; } 12557 return *z==0; 12558 } 12559 12560 12561 /* 12562 ** Compare the string as a command-line option with either one or two 12563 ** initial "-" characters. 12564 */ 12565 static int optionMatch(const char *zStr, const char *zOpt){ 12566 if( zStr[0]!='-' ) return 0; 12567 zStr++; 12568 if( zStr[0]=='-' ) zStr++; 12569 return strcmp(zStr, zOpt)==0; 12570 } 12571 12572 /* 12573 ** Delete a file. 12574 */ 12575 int shellDeleteFile(const char *zFilename){ 12576 int rc; 12577 #ifdef _WIN32 12578 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename); 12579 rc = _wunlink(z); 12580 sqlite3_free(z); 12581 #else 12582 rc = unlink(zFilename); 12583 #endif 12584 return rc; 12585 } 12586 12587 /* 12588 ** Try to delete the temporary file (if there is one) and free the 12589 ** memory used to hold the name of the temp file. 12590 */ 12591 static void clearTempFile(ShellState *p){ 12592 if( p->zTempFile==0 ) return; 12593 if( p->doXdgOpen ) return; 12594 if( shellDeleteFile(p->zTempFile) ) return; 12595 sqlite3_free(p->zTempFile); 12596 p->zTempFile = 0; 12597 } 12598 12599 /* 12600 ** Create a new temp file name with the given suffix. 12601 */ 12602 static void newTempFile(ShellState *p, const char *zSuffix){ 12603 clearTempFile(p); 12604 sqlite3_free(p->zTempFile); 12605 p->zTempFile = 0; 12606 if( p->db ){ 12607 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile); 12608 } 12609 if( p->zTempFile==0 ){ 12610 sqlite3_uint64 r; 12611 sqlite3_randomness(sizeof(r), &r); 12612 p->zTempFile = sqlite3_mprintf("temp%llx.%s", r, zSuffix); 12613 }else{ 12614 p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix); 12615 } 12616 if( p->zTempFile==0 ){ 12617 raw_printf(stderr, "out of memory\n"); 12618 exit(1); 12619 } 12620 } 12621 12622 12623 /* 12624 ** The implementation of SQL scalar function fkey_collate_clause(), used 12625 ** by the ".lint fkey-indexes" command. This scalar function is always 12626 ** called with four arguments - the parent table name, the parent column name, 12627 ** the child table name and the child column name. 12628 ** 12629 ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col') 12630 ** 12631 ** If either of the named tables or columns do not exist, this function 12632 ** returns an empty string. An empty string is also returned if both tables 12633 ** and columns exist but have the same default collation sequence. Or, 12634 ** if both exist but the default collation sequences are different, this 12635 ** function returns the string " COLLATE <parent-collation>", where 12636 ** <parent-collation> is the default collation sequence of the parent column. 12637 */ 12638 static void shellFkeyCollateClause( 12639 sqlite3_context *pCtx, 12640 int nVal, 12641 sqlite3_value **apVal 12642 ){ 12643 sqlite3 *db = sqlite3_context_db_handle(pCtx); 12644 const char *zParent; 12645 const char *zParentCol; 12646 const char *zParentSeq; 12647 const char *zChild; 12648 const char *zChildCol; 12649 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */ 12650 int rc; 12651 12652 assert( nVal==4 ); 12653 zParent = (const char*)sqlite3_value_text(apVal[0]); 12654 zParentCol = (const char*)sqlite3_value_text(apVal[1]); 12655 zChild = (const char*)sqlite3_value_text(apVal[2]); 12656 zChildCol = (const char*)sqlite3_value_text(apVal[3]); 12657 12658 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC); 12659 rc = sqlite3_table_column_metadata( 12660 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0 12661 ); 12662 if( rc==SQLITE_OK ){ 12663 rc = sqlite3_table_column_metadata( 12664 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0 12665 ); 12666 } 12667 12668 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){ 12669 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq); 12670 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT); 12671 sqlite3_free(z); 12672 } 12673 } 12674 12675 12676 /* 12677 ** The implementation of dot-command ".lint fkey-indexes". 12678 */ 12679 static int lintFkeyIndexes( 12680 ShellState *pState, /* Current shell tool state */ 12681 char **azArg, /* Array of arguments passed to dot command */ 12682 int nArg /* Number of entries in azArg[] */ 12683 ){ 12684 sqlite3 *db = pState->db; /* Database handle to query "main" db of */ 12685 FILE *out = pState->out; /* Stream to write non-error output to */ 12686 int bVerbose = 0; /* If -verbose is present */ 12687 int bGroupByParent = 0; /* If -groupbyparent is present */ 12688 int i; /* To iterate through azArg[] */ 12689 const char *zIndent = ""; /* How much to indent CREATE INDEX by */ 12690 int rc; /* Return code */ 12691 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */ 12692 12693 /* 12694 ** This SELECT statement returns one row for each foreign key constraint 12695 ** in the schema of the main database. The column values are: 12696 ** 12697 ** 0. The text of an SQL statement similar to: 12698 ** 12699 ** "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?" 12700 ** 12701 ** This SELECT is similar to the one that the foreign keys implementation 12702 ** needs to run internally on child tables. If there is an index that can 12703 ** be used to optimize this query, then it can also be used by the FK 12704 ** implementation to optimize DELETE or UPDATE statements on the parent 12705 ** table. 12706 ** 12707 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by 12708 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema 12709 ** contains an index that can be used to optimize the query. 12710 ** 12711 ** 2. Human readable text that describes the child table and columns. e.g. 12712 ** 12713 ** "child_table(child_key1, child_key2)" 12714 ** 12715 ** 3. Human readable text that describes the parent table and columns. e.g. 12716 ** 12717 ** "parent_table(parent_key1, parent_key2)" 12718 ** 12719 ** 4. A full CREATE INDEX statement for an index that could be used to 12720 ** optimize DELETE or UPDATE statements on the parent table. e.g. 12721 ** 12722 ** "CREATE INDEX child_table_child_key ON child_table(child_key)" 12723 ** 12724 ** 5. The name of the parent table. 12725 ** 12726 ** These six values are used by the C logic below to generate the report. 12727 */ 12728 const char *zSql = 12729 "SELECT " 12730 " 'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '" 12731 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' " 12732 " || fkey_collate_clause(" 12733 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')" 12734 ", " 12735 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('" 12736 " || group_concat('*=?', ' AND ') || ')'" 12737 ", " 12738 " s.name || '(' || group_concat(f.[from], ', ') || ')'" 12739 ", " 12740 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'" 12741 ", " 12742 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))" 12743 " || ' ON ' || quote(s.name) || '('" 12744 " || group_concat(quote(f.[from]) ||" 12745 " fkey_collate_clause(" 12746 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')" 12747 " || ');'" 12748 ", " 12749 " f.[table] " 12750 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f " 12751 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) " 12752 "GROUP BY s.name, f.id " 12753 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)" 12754 ; 12755 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)"; 12756 12757 for(i=2; i<nArg; i++){ 12758 int n = strlen30(azArg[i]); 12759 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){ 12760 bVerbose = 1; 12761 } 12762 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){ 12763 bGroupByParent = 1; 12764 zIndent = " "; 12765 } 12766 else{ 12767 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n", 12768 azArg[0], azArg[1] 12769 ); 12770 return SQLITE_ERROR; 12771 } 12772 } 12773 12774 /* Register the fkey_collate_clause() SQL function */ 12775 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8, 12776 0, shellFkeyCollateClause, 0, 0 12777 ); 12778 12779 12780 if( rc==SQLITE_OK ){ 12781 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0); 12782 } 12783 if( rc==SQLITE_OK ){ 12784 sqlite3_bind_int(pSql, 1, bGroupByParent); 12785 } 12786 12787 if( rc==SQLITE_OK ){ 12788 int rc2; 12789 char *zPrev = 0; 12790 while( SQLITE_ROW==sqlite3_step(pSql) ){ 12791 int res = -1; 12792 sqlite3_stmt *pExplain = 0; 12793 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0); 12794 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1); 12795 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2); 12796 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3); 12797 const char *zCI = (const char*)sqlite3_column_text(pSql, 4); 12798 const char *zParent = (const char*)sqlite3_column_text(pSql, 5); 12799 12800 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 12801 if( rc!=SQLITE_OK ) break; 12802 if( SQLITE_ROW==sqlite3_step(pExplain) ){ 12803 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3); 12804 res = ( 12805 0==sqlite3_strglob(zGlob, zPlan) 12806 || 0==sqlite3_strglob(zGlobIPK, zPlan) 12807 ); 12808 } 12809 rc = sqlite3_finalize(pExplain); 12810 if( rc!=SQLITE_OK ) break; 12811 12812 if( res<0 ){ 12813 raw_printf(stderr, "Error: internal error"); 12814 break; 12815 }else{ 12816 if( bGroupByParent 12817 && (bVerbose || res==0) 12818 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev)) 12819 ){ 12820 raw_printf(out, "-- Parent table %s\n", zParent); 12821 sqlite3_free(zPrev); 12822 zPrev = sqlite3_mprintf("%s", zParent); 12823 } 12824 12825 if( res==0 ){ 12826 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget); 12827 }else if( bVerbose ){ 12828 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n", 12829 zIndent, zFrom, zTarget 12830 ); 12831 } 12832 } 12833 } 12834 sqlite3_free(zPrev); 12835 12836 if( rc!=SQLITE_OK ){ 12837 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 12838 } 12839 12840 rc2 = sqlite3_finalize(pSql); 12841 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){ 12842 rc = rc2; 12843 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 12844 } 12845 }else{ 12846 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 12847 } 12848 12849 return rc; 12850 } 12851 12852 /* 12853 ** Implementation of ".lint" dot command. 12854 */ 12855 static int lintDotCommand( 12856 ShellState *pState, /* Current shell tool state */ 12857 char **azArg, /* Array of arguments passed to dot command */ 12858 int nArg /* Number of entries in azArg[] */ 12859 ){ 12860 int n; 12861 n = (nArg>=2 ? strlen30(azArg[1]) : 0); 12862 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage; 12863 return lintFkeyIndexes(pState, azArg, nArg); 12864 12865 usage: 12866 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]); 12867 raw_printf(stderr, "Where sub-commands are:\n"); 12868 raw_printf(stderr, " fkey-indexes\n"); 12869 return SQLITE_ERROR; 12870 } 12871 12872 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 12873 /********************************************************************************* 12874 ** The ".archive" or ".ar" command. 12875 */ 12876 static void shellPrepare( 12877 sqlite3 *db, 12878 int *pRc, 12879 const char *zSql, 12880 sqlite3_stmt **ppStmt 12881 ){ 12882 *ppStmt = 0; 12883 if( *pRc==SQLITE_OK ){ 12884 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); 12885 if( rc!=SQLITE_OK ){ 12886 raw_printf(stderr, "sql error: %s (%d)\n", 12887 sqlite3_errmsg(db), sqlite3_errcode(db) 12888 ); 12889 *pRc = rc; 12890 } 12891 } 12892 } 12893 12894 static void shellPreparePrintf( 12895 sqlite3 *db, 12896 int *pRc, 12897 sqlite3_stmt **ppStmt, 12898 const char *zFmt, 12899 ... 12900 ){ 12901 *ppStmt = 0; 12902 if( *pRc==SQLITE_OK ){ 12903 va_list ap; 12904 char *z; 12905 va_start(ap, zFmt); 12906 z = sqlite3_vmprintf(zFmt, ap); 12907 va_end(ap); 12908 if( z==0 ){ 12909 *pRc = SQLITE_NOMEM; 12910 }else{ 12911 shellPrepare(db, pRc, z, ppStmt); 12912 sqlite3_free(z); 12913 } 12914 } 12915 } 12916 12917 static void shellFinalize( 12918 int *pRc, 12919 sqlite3_stmt *pStmt 12920 ){ 12921 if( pStmt ){ 12922 sqlite3 *db = sqlite3_db_handle(pStmt); 12923 int rc = sqlite3_finalize(pStmt); 12924 if( *pRc==SQLITE_OK ){ 12925 if( rc!=SQLITE_OK ){ 12926 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 12927 } 12928 *pRc = rc; 12929 } 12930 } 12931 } 12932 12933 static void shellReset( 12934 int *pRc, 12935 sqlite3_stmt *pStmt 12936 ){ 12937 int rc = sqlite3_reset(pStmt); 12938 if( *pRc==SQLITE_OK ){ 12939 if( rc!=SQLITE_OK ){ 12940 sqlite3 *db = sqlite3_db_handle(pStmt); 12941 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 12942 } 12943 *pRc = rc; 12944 } 12945 } 12946 /* 12947 ** Structure representing a single ".ar" command. 12948 */ 12949 typedef struct ArCommand ArCommand; 12950 struct ArCommand { 12951 u8 eCmd; /* An AR_CMD_* value */ 12952 u8 bVerbose; /* True if --verbose */ 12953 u8 bZip; /* True if the archive is a ZIP */ 12954 u8 bDryRun; /* True if --dry-run */ 12955 u8 bAppend; /* True if --append */ 12956 u8 fromCmdLine; /* Run from -A instead of .archive */ 12957 int nArg; /* Number of command arguments */ 12958 char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */ 12959 const char *zFile; /* --file argument, or NULL */ 12960 const char *zDir; /* --directory argument, or NULL */ 12961 char **azArg; /* Array of command arguments */ 12962 ShellState *p; /* Shell state */ 12963 sqlite3 *db; /* Database containing the archive */ 12964 }; 12965 12966 /* 12967 ** Print a usage message for the .ar command to stderr and return SQLITE_ERROR. 12968 */ 12969 static int arUsage(FILE *f){ 12970 showHelp(f,"archive"); 12971 return SQLITE_ERROR; 12972 } 12973 12974 /* 12975 ** Print an error message for the .ar command to stderr and return 12976 ** SQLITE_ERROR. 12977 */ 12978 static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){ 12979 va_list ap; 12980 char *z; 12981 va_start(ap, zFmt); 12982 z = sqlite3_vmprintf(zFmt, ap); 12983 va_end(ap); 12984 utf8_printf(stderr, "Error: %s\n", z); 12985 if( pAr->fromCmdLine ){ 12986 utf8_printf(stderr, "Use \"-A\" for more help\n"); 12987 }else{ 12988 utf8_printf(stderr, "Use \".archive --help\" for more help\n"); 12989 } 12990 sqlite3_free(z); 12991 return SQLITE_ERROR; 12992 } 12993 12994 /* 12995 ** Values for ArCommand.eCmd. 12996 */ 12997 #define AR_CMD_CREATE 1 12998 #define AR_CMD_EXTRACT 2 12999 #define AR_CMD_LIST 3 13000 #define AR_CMD_UPDATE 4 13001 #define AR_CMD_HELP 5 13002 13003 /* 13004 ** Other (non-command) switches. 13005 */ 13006 #define AR_SWITCH_VERBOSE 6 13007 #define AR_SWITCH_FILE 7 13008 #define AR_SWITCH_DIRECTORY 8 13009 #define AR_SWITCH_APPEND 9 13010 #define AR_SWITCH_DRYRUN 10 13011 13012 static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){ 13013 switch( eSwitch ){ 13014 case AR_CMD_CREATE: 13015 case AR_CMD_EXTRACT: 13016 case AR_CMD_LIST: 13017 case AR_CMD_UPDATE: 13018 case AR_CMD_HELP: 13019 if( pAr->eCmd ){ 13020 return arErrorMsg(pAr, "multiple command options"); 13021 } 13022 pAr->eCmd = eSwitch; 13023 break; 13024 13025 case AR_SWITCH_DRYRUN: 13026 pAr->bDryRun = 1; 13027 break; 13028 case AR_SWITCH_VERBOSE: 13029 pAr->bVerbose = 1; 13030 break; 13031 case AR_SWITCH_APPEND: 13032 pAr->bAppend = 1; 13033 /* Fall thru into --file */ 13034 case AR_SWITCH_FILE: 13035 pAr->zFile = zArg; 13036 break; 13037 case AR_SWITCH_DIRECTORY: 13038 pAr->zDir = zArg; 13039 break; 13040 } 13041 13042 return SQLITE_OK; 13043 } 13044 13045 /* 13046 ** Parse the command line for an ".ar" command. The results are written into 13047 ** structure (*pAr). SQLITE_OK is returned if the command line is parsed 13048 ** successfully, otherwise an error message is written to stderr and 13049 ** SQLITE_ERROR returned. 13050 */ 13051 static int arParseCommand( 13052 char **azArg, /* Array of arguments passed to dot command */ 13053 int nArg, /* Number of entries in azArg[] */ 13054 ArCommand *pAr /* Populate this object */ 13055 ){ 13056 struct ArSwitch { 13057 const char *zLong; 13058 char cShort; 13059 u8 eSwitch; 13060 u8 bArg; 13061 } aSwitch[] = { 13062 { "create", 'c', AR_CMD_CREATE, 0 }, 13063 { "extract", 'x', AR_CMD_EXTRACT, 0 }, 13064 { "list", 't', AR_CMD_LIST, 0 }, 13065 { "update", 'u', AR_CMD_UPDATE, 0 }, 13066 { "help", 'h', AR_CMD_HELP, 0 }, 13067 { "verbose", 'v', AR_SWITCH_VERBOSE, 0 }, 13068 { "file", 'f', AR_SWITCH_FILE, 1 }, 13069 { "append", 'a', AR_SWITCH_APPEND, 1 }, 13070 { "directory", 'C', AR_SWITCH_DIRECTORY, 1 }, 13071 { "dryrun", 'n', AR_SWITCH_DRYRUN, 0 }, 13072 }; 13073 int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch); 13074 struct ArSwitch *pEnd = &aSwitch[nSwitch]; 13075 13076 if( nArg<=1 ){ 13077 utf8_printf(stderr, "Wrong number of arguments. Usage:\n"); 13078 return arUsage(stderr); 13079 }else{ 13080 char *z = azArg[1]; 13081 if( z[0]!='-' ){ 13082 /* Traditional style [tar] invocation */ 13083 int i; 13084 int iArg = 2; 13085 for(i=0; z[i]; i++){ 13086 const char *zArg = 0; 13087 struct ArSwitch *pOpt; 13088 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 13089 if( z[i]==pOpt->cShort ) break; 13090 } 13091 if( pOpt==pEnd ){ 13092 return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 13093 } 13094 if( pOpt->bArg ){ 13095 if( iArg>=nArg ){ 13096 return arErrorMsg(pAr, "option requires an argument: %c",z[i]); 13097 } 13098 zArg = azArg[iArg++]; 13099 } 13100 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 13101 } 13102 pAr->nArg = nArg-iArg; 13103 if( pAr->nArg>0 ){ 13104 pAr->azArg = &azArg[iArg]; 13105 } 13106 }else{ 13107 /* Non-traditional invocation */ 13108 int iArg; 13109 for(iArg=1; iArg<nArg; iArg++){ 13110 int n; 13111 z = azArg[iArg]; 13112 if( z[0]!='-' ){ 13113 /* All remaining command line words are command arguments. */ 13114 pAr->azArg = &azArg[iArg]; 13115 pAr->nArg = nArg-iArg; 13116 break; 13117 } 13118 n = strlen30(z); 13119 13120 if( z[1]!='-' ){ 13121 int i; 13122 /* One or more short options */ 13123 for(i=1; i<n; i++){ 13124 const char *zArg = 0; 13125 struct ArSwitch *pOpt; 13126 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 13127 if( z[i]==pOpt->cShort ) break; 13128 } 13129 if( pOpt==pEnd ){ 13130 return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 13131 } 13132 if( pOpt->bArg ){ 13133 if( i<(n-1) ){ 13134 zArg = &z[i+1]; 13135 i = n; 13136 }else{ 13137 if( iArg>=(nArg-1) ){ 13138 return arErrorMsg(pAr, "option requires an argument: %c",z[i]); 13139 } 13140 zArg = azArg[++iArg]; 13141 } 13142 } 13143 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 13144 } 13145 }else if( z[2]=='\0' ){ 13146 /* A -- option, indicating that all remaining command line words 13147 ** are command arguments. */ 13148 pAr->azArg = &azArg[iArg+1]; 13149 pAr->nArg = nArg-iArg-1; 13150 break; 13151 }else{ 13152 /* A long option */ 13153 const char *zArg = 0; /* Argument for option, if any */ 13154 struct ArSwitch *pMatch = 0; /* Matching option */ 13155 struct ArSwitch *pOpt; /* Iterator */ 13156 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 13157 const char *zLong = pOpt->zLong; 13158 if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){ 13159 if( pMatch ){ 13160 return arErrorMsg(pAr, "ambiguous option: %s",z); 13161 }else{ 13162 pMatch = pOpt; 13163 } 13164 } 13165 } 13166 13167 if( pMatch==0 ){ 13168 return arErrorMsg(pAr, "unrecognized option: %s", z); 13169 } 13170 if( pMatch->bArg ){ 13171 if( iArg>=(nArg-1) ){ 13172 return arErrorMsg(pAr, "option requires an argument: %s", z); 13173 } 13174 zArg = azArg[++iArg]; 13175 } 13176 if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR; 13177 } 13178 } 13179 } 13180 } 13181 13182 return SQLITE_OK; 13183 } 13184 13185 /* 13186 ** This function assumes that all arguments within the ArCommand.azArg[] 13187 ** array refer to archive members, as for the --extract or --list commands. 13188 ** It checks that each of them are present. If any specified file is not 13189 ** present in the archive, an error is printed to stderr and an error 13190 ** code returned. Otherwise, if all specified arguments are present in 13191 ** the archive, SQLITE_OK is returned. 13192 ** 13193 ** This function strips any trailing '/' characters from each argument. 13194 ** This is consistent with the way the [tar] command seems to work on 13195 ** Linux. 13196 */ 13197 static int arCheckEntries(ArCommand *pAr){ 13198 int rc = SQLITE_OK; 13199 if( pAr->nArg ){ 13200 int i, j; 13201 sqlite3_stmt *pTest = 0; 13202 13203 shellPreparePrintf(pAr->db, &rc, &pTest, 13204 "SELECT name FROM %s WHERE name=$name", 13205 pAr->zSrcTable 13206 ); 13207 j = sqlite3_bind_parameter_index(pTest, "$name"); 13208 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 13209 char *z = pAr->azArg[i]; 13210 int n = strlen30(z); 13211 int bOk = 0; 13212 while( n>0 && z[n-1]=='/' ) n--; 13213 z[n] = '\0'; 13214 sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC); 13215 if( SQLITE_ROW==sqlite3_step(pTest) ){ 13216 bOk = 1; 13217 } 13218 shellReset(&rc, pTest); 13219 if( rc==SQLITE_OK && bOk==0 ){ 13220 utf8_printf(stderr, "not found in archive: %s\n", z); 13221 rc = SQLITE_ERROR; 13222 } 13223 } 13224 shellFinalize(&rc, pTest); 13225 } 13226 return rc; 13227 } 13228 13229 /* 13230 ** Format a WHERE clause that can be used against the "sqlar" table to 13231 ** identify all archive members that match the command arguments held 13232 ** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning. 13233 ** The caller is responsible for eventually calling sqlite3_free() on 13234 ** any non-NULL (*pzWhere) value. 13235 */ 13236 static void arWhereClause( 13237 int *pRc, 13238 ArCommand *pAr, 13239 char **pzWhere /* OUT: New WHERE clause */ 13240 ){ 13241 char *zWhere = 0; 13242 if( *pRc==SQLITE_OK ){ 13243 if( pAr->nArg==0 ){ 13244 zWhere = sqlite3_mprintf("1"); 13245 }else{ 13246 int i; 13247 const char *zSep = ""; 13248 for(i=0; i<pAr->nArg; i++){ 13249 const char *z = pAr->azArg[i]; 13250 zWhere = sqlite3_mprintf( 13251 "%z%s name = '%q' OR substr(name,1,%d) = '%q/'", 13252 zWhere, zSep, z, strlen30(z)+1, z 13253 ); 13254 if( zWhere==0 ){ 13255 *pRc = SQLITE_NOMEM; 13256 break; 13257 } 13258 zSep = " OR "; 13259 } 13260 } 13261 } 13262 *pzWhere = zWhere; 13263 } 13264 13265 /* 13266 ** Implementation of .ar "lisT" command. 13267 */ 13268 static int arListCommand(ArCommand *pAr){ 13269 const char *zSql = "SELECT %s FROM %s WHERE %s"; 13270 const char *azCols[] = { 13271 "name", 13272 "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name" 13273 }; 13274 13275 char *zWhere = 0; 13276 sqlite3_stmt *pSql = 0; 13277 int rc; 13278 13279 rc = arCheckEntries(pAr); 13280 arWhereClause(&rc, pAr, &zWhere); 13281 13282 shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose], 13283 pAr->zSrcTable, zWhere); 13284 if( pAr->bDryRun ){ 13285 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 13286 }else{ 13287 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 13288 if( pAr->bVerbose ){ 13289 utf8_printf(pAr->p->out, "%s % 10d %s %s\n", 13290 sqlite3_column_text(pSql, 0), 13291 sqlite3_column_int(pSql, 1), 13292 sqlite3_column_text(pSql, 2), 13293 sqlite3_column_text(pSql, 3) 13294 ); 13295 }else{ 13296 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 13297 } 13298 } 13299 } 13300 shellFinalize(&rc, pSql); 13301 sqlite3_free(zWhere); 13302 return rc; 13303 } 13304 13305 13306 /* 13307 ** Implementation of .ar "eXtract" command. 13308 */ 13309 static int arExtractCommand(ArCommand *pAr){ 13310 const char *zSql1 = 13311 "SELECT " 13312 " ($dir || name)," 13313 " writefile(($dir || name), %s, mode, mtime) " 13314 "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)" 13315 " AND name NOT GLOB '*..[/\\]*'"; 13316 13317 const char *azExtraArg[] = { 13318 "sqlar_uncompress(data, sz)", 13319 "data" 13320 }; 13321 13322 sqlite3_stmt *pSql = 0; 13323 int rc = SQLITE_OK; 13324 char *zDir = 0; 13325 char *zWhere = 0; 13326 int i, j; 13327 13328 /* If arguments are specified, check that they actually exist within 13329 ** the archive before proceeding. And formulate a WHERE clause to 13330 ** match them. */ 13331 rc = arCheckEntries(pAr); 13332 arWhereClause(&rc, pAr, &zWhere); 13333 13334 if( rc==SQLITE_OK ){ 13335 if( pAr->zDir ){ 13336 zDir = sqlite3_mprintf("%s/", pAr->zDir); 13337 }else{ 13338 zDir = sqlite3_mprintf(""); 13339 } 13340 if( zDir==0 ) rc = SQLITE_NOMEM; 13341 } 13342 13343 shellPreparePrintf(pAr->db, &rc, &pSql, zSql1, 13344 azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere 13345 ); 13346 13347 if( rc==SQLITE_OK ){ 13348 j = sqlite3_bind_parameter_index(pSql, "$dir"); 13349 sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC); 13350 13351 /* Run the SELECT statement twice. The first time, writefile() is called 13352 ** for all archive members that should be extracted. The second time, 13353 ** only for the directories. This is because the timestamps for 13354 ** extracted directories must be reset after they are populated (as 13355 ** populating them changes the timestamp). */ 13356 for(i=0; i<2; i++){ 13357 j = sqlite3_bind_parameter_index(pSql, "$dirOnly"); 13358 sqlite3_bind_int(pSql, j, i); 13359 if( pAr->bDryRun ){ 13360 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 13361 }else{ 13362 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 13363 if( i==0 && pAr->bVerbose ){ 13364 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 13365 } 13366 } 13367 } 13368 shellReset(&rc, pSql); 13369 } 13370 shellFinalize(&rc, pSql); 13371 } 13372 13373 sqlite3_free(zDir); 13374 sqlite3_free(zWhere); 13375 return rc; 13376 } 13377 13378 /* 13379 ** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out. 13380 */ 13381 static int arExecSql(ArCommand *pAr, const char *zSql){ 13382 int rc; 13383 if( pAr->bDryRun ){ 13384 utf8_printf(pAr->p->out, "%s\n", zSql); 13385 rc = SQLITE_OK; 13386 }else{ 13387 char *zErr = 0; 13388 rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr); 13389 if( zErr ){ 13390 utf8_printf(stdout, "ERROR: %s\n", zErr); 13391 sqlite3_free(zErr); 13392 } 13393 } 13394 return rc; 13395 } 13396 13397 13398 /* 13399 ** Implementation of .ar "create" and "update" commands. 13400 ** 13401 ** Create the "sqlar" table in the database if it does not already exist. 13402 ** Then add each file in the azFile[] array to the archive. Directories 13403 ** are added recursively. If argument bVerbose is non-zero, a message is 13404 ** printed on stdout for each file archived. 13405 ** 13406 ** The create command is the same as update, except that it drops 13407 ** any existing "sqlar" table before beginning. 13408 */ 13409 static int arCreateOrUpdateCommand( 13410 ArCommand *pAr, /* Command arguments and options */ 13411 int bUpdate /* true for a --create. false for --update */ 13412 ){ 13413 const char *zCreate = 13414 "CREATE TABLE IF NOT EXISTS sqlar(\n" 13415 " name TEXT PRIMARY KEY, -- name of the file\n" 13416 " mode INT, -- access permissions\n" 13417 " mtime INT, -- last modification time\n" 13418 " sz INT, -- original file size\n" 13419 " data BLOB -- compressed content\n" 13420 ")"; 13421 const char *zDrop = "DROP TABLE IF EXISTS sqlar"; 13422 const char *zInsertFmt[2] = { 13423 "REPLACE INTO %s(name,mode,mtime,sz,data)\n" 13424 " SELECT\n" 13425 " %s,\n" 13426 " mode,\n" 13427 " mtime,\n" 13428 " CASE substr(lsmode(mode),1,1)\n" 13429 " WHEN '-' THEN length(data)\n" 13430 " WHEN 'd' THEN 0\n" 13431 " ELSE -1 END,\n" 13432 " sqlar_compress(data)\n" 13433 " FROM fsdir(%Q,%Q)\n" 13434 " WHERE lsmode(mode) NOT LIKE '?%%';", 13435 "REPLACE INTO %s(name,mode,mtime,data)\n" 13436 " SELECT\n" 13437 " %s,\n" 13438 " mode,\n" 13439 " mtime,\n" 13440 " data\n" 13441 " FROM fsdir(%Q,%Q)\n" 13442 " WHERE lsmode(mode) NOT LIKE '?%%';" 13443 }; 13444 int i; /* For iterating through azFile[] */ 13445 int rc; /* Return code */ 13446 const char *zTab = 0; /* SQL table into which to insert */ 13447 char *zSql; 13448 char zTemp[50]; 13449 13450 arExecSql(pAr, "PRAGMA page_size=512"); 13451 rc = arExecSql(pAr, "SAVEPOINT ar;"); 13452 if( rc!=SQLITE_OK ) return rc; 13453 zTemp[0] = 0; 13454 if( pAr->bZip ){ 13455 /* Initialize the zipfile virtual table, if necessary */ 13456 if( pAr->zFile ){ 13457 sqlite3_uint64 r; 13458 sqlite3_randomness(sizeof(r),&r); 13459 sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r); 13460 zTab = zTemp; 13461 zSql = sqlite3_mprintf( 13462 "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)", 13463 zTab, pAr->zFile 13464 ); 13465 rc = arExecSql(pAr, zSql); 13466 sqlite3_free(zSql); 13467 }else{ 13468 zTab = "zip"; 13469 } 13470 }else{ 13471 /* Initialize the table for an SQLAR */ 13472 zTab = "sqlar"; 13473 if( bUpdate==0 ){ 13474 rc = arExecSql(pAr, zDrop); 13475 if( rc!=SQLITE_OK ) goto end_ar_transaction; 13476 } 13477 rc = arExecSql(pAr, zCreate); 13478 } 13479 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 13480 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab, 13481 pAr->bVerbose ? "shell_putsnl(name)" : "name", 13482 pAr->azArg[i], pAr->zDir); 13483 rc = arExecSql(pAr, zSql2); 13484 sqlite3_free(zSql2); 13485 } 13486 end_ar_transaction: 13487 if( rc!=SQLITE_OK ){ 13488 sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0); 13489 }else{ 13490 rc = arExecSql(pAr, "RELEASE ar;"); 13491 if( pAr->bZip && pAr->zFile ){ 13492 zSql = sqlite3_mprintf("DROP TABLE %s", zTemp); 13493 arExecSql(pAr, zSql); 13494 sqlite3_free(zSql); 13495 } 13496 } 13497 return rc; 13498 } 13499 13500 /* 13501 ** Implementation of ".ar" dot command. 13502 */ 13503 static int arDotCommand( 13504 ShellState *pState, /* Current shell tool state */ 13505 int fromCmdLine, /* True if -A command-line option, not .ar cmd */ 13506 char **azArg, /* Array of arguments passed to dot command */ 13507 int nArg /* Number of entries in azArg[] */ 13508 ){ 13509 ArCommand cmd; 13510 int rc; 13511 memset(&cmd, 0, sizeof(cmd)); 13512 cmd.fromCmdLine = fromCmdLine; 13513 rc = arParseCommand(azArg, nArg, &cmd); 13514 if( rc==SQLITE_OK ){ 13515 int eDbType = SHELL_OPEN_UNSPEC; 13516 cmd.p = pState; 13517 cmd.db = pState->db; 13518 if( cmd.zFile ){ 13519 eDbType = deduceDatabaseType(cmd.zFile, 1); 13520 }else{ 13521 eDbType = pState->openMode; 13522 } 13523 if( eDbType==SHELL_OPEN_ZIPFILE ){ 13524 if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){ 13525 if( cmd.zFile==0 ){ 13526 cmd.zSrcTable = sqlite3_mprintf("zip"); 13527 }else{ 13528 cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile); 13529 } 13530 } 13531 cmd.bZip = 1; 13532 }else if( cmd.zFile ){ 13533 int flags; 13534 if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS; 13535 if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_UPDATE ){ 13536 flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE; 13537 }else{ 13538 flags = SQLITE_OPEN_READONLY; 13539 } 13540 cmd.db = 0; 13541 if( cmd.bDryRun ){ 13542 utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile, 13543 eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : ""); 13544 } 13545 rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags, 13546 eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0); 13547 if( rc!=SQLITE_OK ){ 13548 utf8_printf(stderr, "cannot open file: %s (%s)\n", 13549 cmd.zFile, sqlite3_errmsg(cmd.db) 13550 ); 13551 goto end_ar_command; 13552 } 13553 sqlite3_fileio_init(cmd.db, 0, 0); 13554 sqlite3_sqlar_init(cmd.db, 0, 0); 13555 sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p, 13556 shellPutsFunc, 0, 0); 13557 13558 } 13559 if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){ 13560 if( cmd.eCmd!=AR_CMD_CREATE 13561 && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0) 13562 ){ 13563 utf8_printf(stderr, "database does not contain an 'sqlar' table\n"); 13564 rc = SQLITE_ERROR; 13565 goto end_ar_command; 13566 } 13567 cmd.zSrcTable = sqlite3_mprintf("sqlar"); 13568 } 13569 13570 switch( cmd.eCmd ){ 13571 case AR_CMD_CREATE: 13572 rc = arCreateOrUpdateCommand(&cmd, 0); 13573 break; 13574 13575 case AR_CMD_EXTRACT: 13576 rc = arExtractCommand(&cmd); 13577 break; 13578 13579 case AR_CMD_LIST: 13580 rc = arListCommand(&cmd); 13581 break; 13582 13583 case AR_CMD_HELP: 13584 arUsage(pState->out); 13585 break; 13586 13587 default: 13588 assert( cmd.eCmd==AR_CMD_UPDATE ); 13589 rc = arCreateOrUpdateCommand(&cmd, 1); 13590 break; 13591 } 13592 } 13593 end_ar_command: 13594 if( cmd.db!=pState->db ){ 13595 close_db(cmd.db); 13596 } 13597 sqlite3_free(cmd.zSrcTable); 13598 13599 return rc; 13600 } 13601 /* End of the ".archive" or ".ar" command logic 13602 **********************************************************************************/ 13603 #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */ 13604 13605 13606 /* 13607 ** If an input line begins with "." then invoke this routine to 13608 ** process that line. 13609 ** 13610 ** Return 1 on error, 2 to exit, and 0 otherwise. 13611 */ 13612 static int do_meta_command(char *zLine, ShellState *p){ 13613 int h = 1; 13614 int nArg = 0; 13615 int n, c; 13616 int rc = 0; 13617 char *azArg[50]; 13618 13619 #ifndef SQLITE_OMIT_VIRTUALTABLE 13620 if( p->expert.pExpert ){ 13621 expertFinish(p, 1, 0); 13622 } 13623 #endif 13624 13625 /* Parse the input line into tokens. 13626 */ 13627 while( zLine[h] && nArg<ArraySize(azArg) ){ 13628 while( IsSpace(zLine[h]) ){ h++; } 13629 if( zLine[h]==0 ) break; 13630 if( zLine[h]=='\'' || zLine[h]=='"' ){ 13631 int delim = zLine[h++]; 13632 azArg[nArg++] = &zLine[h]; 13633 while( zLine[h] && zLine[h]!=delim ){ 13634 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++; 13635 h++; 13636 } 13637 if( zLine[h]==delim ){ 13638 zLine[h++] = 0; 13639 } 13640 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]); 13641 }else{ 13642 azArg[nArg++] = &zLine[h]; 13643 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; } 13644 if( zLine[h] ) zLine[h++] = 0; 13645 resolve_backslashes(azArg[nArg-1]); 13646 } 13647 } 13648 13649 /* Process the input line. 13650 */ 13651 if( nArg==0 ) return 0; /* no tokens, no error */ 13652 n = strlen30(azArg[0]); 13653 c = azArg[0][0]; 13654 clearTempFile(p); 13655 13656 #ifndef SQLITE_OMIT_AUTHORIZATION 13657 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){ 13658 if( nArg!=2 ){ 13659 raw_printf(stderr, "Usage: .auth ON|OFF\n"); 13660 rc = 1; 13661 goto meta_command_exit; 13662 } 13663 open_db(p, 0); 13664 if( booleanValue(azArg[1]) ){ 13665 sqlite3_set_authorizer(p->db, shellAuth, p); 13666 }else{ 13667 sqlite3_set_authorizer(p->db, 0, 0); 13668 } 13669 }else 13670 #endif 13671 13672 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 13673 if( c=='a' && strncmp(azArg[0], "archive", n)==0 ){ 13674 open_db(p, 0); 13675 rc = arDotCommand(p, 0, azArg, nArg); 13676 }else 13677 #endif 13678 13679 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0) 13680 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0) 13681 ){ 13682 const char *zDestFile = 0; 13683 const char *zDb = 0; 13684 sqlite3 *pDest; 13685 sqlite3_backup *pBackup; 13686 int j; 13687 int bAsync = 0; 13688 const char *zVfs = 0; 13689 for(j=1; j<nArg; j++){ 13690 const char *z = azArg[j]; 13691 if( z[0]=='-' ){ 13692 if( z[1]=='-' ) z++; 13693 if( strcmp(z, "-append")==0 ){ 13694 zVfs = "apndvfs"; 13695 }else 13696 if( strcmp(z, "-async")==0 ){ 13697 bAsync = 1; 13698 }else 13699 { 13700 utf8_printf(stderr, "unknown option: %s\n", azArg[j]); 13701 return 1; 13702 } 13703 }else if( zDestFile==0 ){ 13704 zDestFile = azArg[j]; 13705 }else if( zDb==0 ){ 13706 zDb = zDestFile; 13707 zDestFile = azArg[j]; 13708 }else{ 13709 raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n"); 13710 return 1; 13711 } 13712 } 13713 if( zDestFile==0 ){ 13714 raw_printf(stderr, "missing FILENAME argument on .backup\n"); 13715 return 1; 13716 } 13717 if( zDb==0 ) zDb = "main"; 13718 rc = sqlite3_open_v2(zDestFile, &pDest, 13719 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs); 13720 if( rc!=SQLITE_OK ){ 13721 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile); 13722 close_db(pDest); 13723 return 1; 13724 } 13725 if( bAsync ){ 13726 sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;", 13727 0, 0, 0); 13728 } 13729 open_db(p, 0); 13730 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb); 13731 if( pBackup==0 ){ 13732 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 13733 close_db(pDest); 13734 return 1; 13735 } 13736 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} 13737 sqlite3_backup_finish(pBackup); 13738 if( rc==SQLITE_DONE ){ 13739 rc = 0; 13740 }else{ 13741 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 13742 rc = 1; 13743 } 13744 close_db(pDest); 13745 }else 13746 13747 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){ 13748 if( nArg==2 ){ 13749 bail_on_error = booleanValue(azArg[1]); 13750 }else{ 13751 raw_printf(stderr, "Usage: .bail on|off\n"); 13752 rc = 1; 13753 } 13754 }else 13755 13756 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){ 13757 if( nArg==2 ){ 13758 if( booleanValue(azArg[1]) ){ 13759 setBinaryMode(p->out, 1); 13760 }else{ 13761 setTextMode(p->out, 1); 13762 } 13763 }else{ 13764 raw_printf(stderr, "Usage: .binary on|off\n"); 13765 rc = 1; 13766 } 13767 }else 13768 13769 if( c=='c' && strcmp(azArg[0],"cd")==0 ){ 13770 if( nArg==2 ){ 13771 #if defined(_WIN32) || defined(WIN32) 13772 wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]); 13773 rc = !SetCurrentDirectoryW(z); 13774 sqlite3_free(z); 13775 #else 13776 rc = chdir(azArg[1]); 13777 #endif 13778 if( rc ){ 13779 utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]); 13780 rc = 1; 13781 } 13782 }else{ 13783 raw_printf(stderr, "Usage: .cd DIRECTORY\n"); 13784 rc = 1; 13785 } 13786 }else 13787 13788 /* The undocumented ".breakpoint" command causes a call to the no-op 13789 ** routine named test_breakpoint(). 13790 */ 13791 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){ 13792 test_breakpoint(); 13793 }else 13794 13795 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){ 13796 if( nArg==2 ){ 13797 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]); 13798 }else{ 13799 raw_printf(stderr, "Usage: .changes on|off\n"); 13800 rc = 1; 13801 } 13802 }else 13803 13804 /* Cancel output redirection, if it is currently set (by .testcase) 13805 ** Then read the content of the testcase-out.txt file and compare against 13806 ** azArg[1]. If there are differences, report an error and exit. 13807 */ 13808 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){ 13809 char *zRes = 0; 13810 output_reset(p); 13811 if( nArg!=2 ){ 13812 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n"); 13813 rc = 2; 13814 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){ 13815 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n"); 13816 rc = 2; 13817 }else if( testcase_glob(azArg[1],zRes)==0 ){ 13818 utf8_printf(stderr, 13819 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n", 13820 p->zTestcase, azArg[1], zRes); 13821 rc = 1; 13822 }else{ 13823 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase); 13824 p->nCheck++; 13825 } 13826 sqlite3_free(zRes); 13827 }else 13828 13829 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){ 13830 if( nArg==2 ){ 13831 tryToClone(p, azArg[1]); 13832 }else{ 13833 raw_printf(stderr, "Usage: .clone FILENAME\n"); 13834 rc = 1; 13835 } 13836 }else 13837 13838 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){ 13839 ShellState data; 13840 char *zErrMsg = 0; 13841 open_db(p, 0); 13842 memcpy(&data, p, sizeof(data)); 13843 data.showHeader = 0; 13844 data.cMode = data.mode = MODE_List; 13845 sqlite3_snprintf(sizeof(data.colSeparator),data.colSeparator,": "); 13846 data.cnt = 0; 13847 sqlite3_exec(p->db, "SELECT name, file FROM pragma_database_list", 13848 callback, &data, &zErrMsg); 13849 if( zErrMsg ){ 13850 utf8_printf(stderr,"Error: %s\n", zErrMsg); 13851 sqlite3_free(zErrMsg); 13852 rc = 1; 13853 } 13854 }else 13855 13856 if( c=='d' && n>=3 && strncmp(azArg[0], "dbconfig", n)==0 ){ 13857 static const struct DbConfigChoices { 13858 const char *zName; 13859 int op; 13860 } aDbConfig[] = { 13861 { "enable_fkey", SQLITE_DBCONFIG_ENABLE_FKEY }, 13862 { "enable_trigger", SQLITE_DBCONFIG_ENABLE_TRIGGER }, 13863 { "fts3_tokenizer", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER }, 13864 { "load_extension", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION }, 13865 { "no_ckpt_on_close", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE }, 13866 { "enable_qpsg", SQLITE_DBCONFIG_ENABLE_QPSG }, 13867 { "trigger_eqp", SQLITE_DBCONFIG_TRIGGER_EQP }, 13868 { "reset_database", SQLITE_DBCONFIG_RESET_DATABASE }, 13869 { "defensive", SQLITE_DBCONFIG_DEFENSIVE }, 13870 }; 13871 int ii, v; 13872 open_db(p, 0); 13873 for(ii=0; ii<ArraySize(aDbConfig); ii++){ 13874 if( nArg>1 && strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue; 13875 if( nArg>=3 ){ 13876 sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0); 13877 } 13878 sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v); 13879 utf8_printf(p->out, "%18s %s\n", aDbConfig[ii].zName, v ? "on" : "off"); 13880 if( nArg>1 ) break; 13881 } 13882 if( nArg>1 && ii==ArraySize(aDbConfig) ){ 13883 utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]); 13884 utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n"); 13885 } 13886 }else 13887 13888 if( c=='d' && n>=3 && strncmp(azArg[0], "dbinfo", n)==0 ){ 13889 rc = shell_dbinfo_command(p, nArg, azArg); 13890 }else 13891 13892 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ 13893 const char *zLike = 0; 13894 int i; 13895 int savedShowHeader = p->showHeader; 13896 int savedShellFlags = p->shellFlgs; 13897 ShellClearFlag(p, SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo); 13898 for(i=1; i<nArg; i++){ 13899 if( azArg[i][0]=='-' ){ 13900 const char *z = azArg[i]+1; 13901 if( z[0]=='-' ) z++; 13902 if( strcmp(z,"preserve-rowids")==0 ){ 13903 #ifdef SQLITE_OMIT_VIRTUALTABLE 13904 raw_printf(stderr, "The --preserve-rowids option is not compatible" 13905 " with SQLITE_OMIT_VIRTUALTABLE\n"); 13906 rc = 1; 13907 goto meta_command_exit; 13908 #else 13909 ShellSetFlag(p, SHFLG_PreserveRowid); 13910 #endif 13911 }else 13912 if( strcmp(z,"newlines")==0 ){ 13913 ShellSetFlag(p, SHFLG_Newlines); 13914 }else 13915 { 13916 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]); 13917 rc = 1; 13918 goto meta_command_exit; 13919 } 13920 }else if( zLike ){ 13921 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? " 13922 "?--newlines? ?LIKE-PATTERN?\n"); 13923 rc = 1; 13924 goto meta_command_exit; 13925 }else{ 13926 zLike = azArg[i]; 13927 } 13928 } 13929 open_db(p, 0); 13930 /* When playing back a "dump", the content might appear in an order 13931 ** which causes immediate foreign key constraints to be violated. 13932 ** So disable foreign-key constraint enforcement to prevent problems. */ 13933 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n"); 13934 raw_printf(p->out, "BEGIN TRANSACTION;\n"); 13935 p->writableSchema = 0; 13936 p->showHeader = 0; 13937 /* Set writable_schema=ON since doing so forces SQLite to initialize 13938 ** as much of the schema as it can even if the sqlite_master table is 13939 ** corrupt. */ 13940 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0); 13941 p->nErr = 0; 13942 if( zLike==0 ){ 13943 run_schema_dump_query(p, 13944 "SELECT name, type, sql FROM sqlite_master " 13945 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'" 13946 ); 13947 run_schema_dump_query(p, 13948 "SELECT name, type, sql FROM sqlite_master " 13949 "WHERE name=='sqlite_sequence'" 13950 ); 13951 run_table_dump_query(p, 13952 "SELECT sql FROM sqlite_master " 13953 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0 13954 ); 13955 }else{ 13956 char *zSql; 13957 zSql = sqlite3_mprintf( 13958 "SELECT name, type, sql FROM sqlite_master " 13959 "WHERE tbl_name LIKE %Q AND type=='table'" 13960 " AND sql NOT NULL", zLike); 13961 run_schema_dump_query(p,zSql); 13962 sqlite3_free(zSql); 13963 zSql = sqlite3_mprintf( 13964 "SELECT sql FROM sqlite_master " 13965 "WHERE sql NOT NULL" 13966 " AND type IN ('index','trigger','view')" 13967 " AND tbl_name LIKE %Q", zLike); 13968 run_table_dump_query(p, zSql, 0); 13969 sqlite3_free(zSql); 13970 } 13971 if( p->writableSchema ){ 13972 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n"); 13973 p->writableSchema = 0; 13974 } 13975 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 13976 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0); 13977 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n"); 13978 p->showHeader = savedShowHeader; 13979 p->shellFlgs = savedShellFlags; 13980 }else 13981 13982 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){ 13983 if( nArg==2 ){ 13984 setOrClearFlag(p, SHFLG_Echo, azArg[1]); 13985 }else{ 13986 raw_printf(stderr, "Usage: .echo on|off\n"); 13987 rc = 1; 13988 } 13989 }else 13990 13991 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){ 13992 if( nArg==2 ){ 13993 p->autoEQPtest = 0; 13994 if( p->autoEQPtrace ){ 13995 if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0); 13996 p->autoEQPtrace = 0; 13997 } 13998 if( strcmp(azArg[1],"full")==0 ){ 13999 p->autoEQP = AUTOEQP_full; 14000 }else if( strcmp(azArg[1],"trigger")==0 ){ 14001 p->autoEQP = AUTOEQP_trigger; 14002 #ifdef SQLITE_DEBUG 14003 }else if( strcmp(azArg[1],"test")==0 ){ 14004 p->autoEQP = AUTOEQP_on; 14005 p->autoEQPtest = 1; 14006 }else if( strcmp(azArg[1],"trace")==0 ){ 14007 p->autoEQP = AUTOEQP_full; 14008 p->autoEQPtrace = 1; 14009 open_db(p, 0); 14010 sqlite3_exec(p->db, "SELECT name FROM sqlite_master LIMIT 1", 0, 0, 0); 14011 sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0); 14012 #endif 14013 }else{ 14014 p->autoEQP = (u8)booleanValue(azArg[1]); 14015 } 14016 }else{ 14017 raw_printf(stderr, "Usage: .eqp off|on|trace|trigger|full\n"); 14018 rc = 1; 14019 } 14020 }else 14021 14022 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){ 14023 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc); 14024 rc = 2; 14025 }else 14026 14027 /* The ".explain" command is automatic now. It is largely pointless. It 14028 ** retained purely for backwards compatibility */ 14029 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ 14030 int val = 1; 14031 if( nArg>=2 ){ 14032 if( strcmp(azArg[1],"auto")==0 ){ 14033 val = 99; 14034 }else{ 14035 val = booleanValue(azArg[1]); 14036 } 14037 } 14038 if( val==1 && p->mode!=MODE_Explain ){ 14039 p->normalMode = p->mode; 14040 p->mode = MODE_Explain; 14041 p->autoExplain = 0; 14042 }else if( val==0 ){ 14043 if( p->mode==MODE_Explain ) p->mode = p->normalMode; 14044 p->autoExplain = 0; 14045 }else if( val==99 ){ 14046 if( p->mode==MODE_Explain ) p->mode = p->normalMode; 14047 p->autoExplain = 1; 14048 } 14049 }else 14050 14051 #ifndef SQLITE_OMIT_VIRTUALTABLE 14052 if( c=='e' && strncmp(azArg[0], "expert", n)==0 ){ 14053 open_db(p, 0); 14054 expertDotCommand(p, azArg, nArg); 14055 }else 14056 #endif 14057 14058 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){ 14059 ShellState data; 14060 char *zErrMsg = 0; 14061 int doStats = 0; 14062 memcpy(&data, p, sizeof(data)); 14063 data.showHeader = 0; 14064 data.cMode = data.mode = MODE_Semi; 14065 if( nArg==2 && optionMatch(azArg[1], "indent") ){ 14066 data.cMode = data.mode = MODE_Pretty; 14067 nArg = 1; 14068 } 14069 if( nArg!=1 ){ 14070 raw_printf(stderr, "Usage: .fullschema ?--indent?\n"); 14071 rc = 1; 14072 goto meta_command_exit; 14073 } 14074 open_db(p, 0); 14075 rc = sqlite3_exec(p->db, 14076 "SELECT sql FROM" 14077 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" 14078 " FROM sqlite_master UNION ALL" 14079 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " 14080 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " 14081 "ORDER BY rowid", 14082 callback, &data, &zErrMsg 14083 ); 14084 if( rc==SQLITE_OK ){ 14085 sqlite3_stmt *pStmt; 14086 rc = sqlite3_prepare_v2(p->db, 14087 "SELECT rowid FROM sqlite_master" 14088 " WHERE name GLOB 'sqlite_stat[134]'", 14089 -1, &pStmt, 0); 14090 doStats = sqlite3_step(pStmt)==SQLITE_ROW; 14091 sqlite3_finalize(pStmt); 14092 } 14093 if( doStats==0 ){ 14094 raw_printf(p->out, "/* No STAT tables available */\n"); 14095 }else{ 14096 raw_printf(p->out, "ANALYZE sqlite_master;\n"); 14097 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'", 14098 callback, &data, &zErrMsg); 14099 data.cMode = data.mode = MODE_Insert; 14100 data.zDestTable = "sqlite_stat1"; 14101 shell_exec(&data, "SELECT * FROM sqlite_stat1", &zErrMsg); 14102 data.zDestTable = "sqlite_stat3"; 14103 shell_exec(&data, "SELECT * FROM sqlite_stat3", &zErrMsg); 14104 data.zDestTable = "sqlite_stat4"; 14105 shell_exec(&data, "SELECT * FROM sqlite_stat4", &zErrMsg); 14106 raw_printf(p->out, "ANALYZE sqlite_master;\n"); 14107 } 14108 }else 14109 14110 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){ 14111 if( nArg==2 ){ 14112 p->showHeader = booleanValue(azArg[1]); 14113 }else{ 14114 raw_printf(stderr, "Usage: .headers on|off\n"); 14115 rc = 1; 14116 } 14117 }else 14118 14119 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ 14120 if( nArg>=2 ){ 14121 n = showHelp(p->out, azArg[1]); 14122 if( n==0 ){ 14123 utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]); 14124 } 14125 }else{ 14126 showHelp(p->out, 0); 14127 } 14128 }else 14129 14130 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){ 14131 char *zTable; /* Insert data into this table */ 14132 char *zFile; /* Name of file to extra content from */ 14133 sqlite3_stmt *pStmt = NULL; /* A statement */ 14134 int nCol; /* Number of columns in the table */ 14135 int nByte; /* Number of bytes in an SQL string */ 14136 int i, j; /* Loop counters */ 14137 int needCommit; /* True to COMMIT or ROLLBACK at end */ 14138 int nSep; /* Number of bytes in p->colSeparator[] */ 14139 char *zSql; /* An SQL statement */ 14140 ImportCtx sCtx; /* Reader context */ 14141 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */ 14142 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */ 14143 14144 if( nArg!=3 ){ 14145 raw_printf(stderr, "Usage: .import FILE TABLE\n"); 14146 goto meta_command_exit; 14147 } 14148 zFile = azArg[1]; 14149 zTable = azArg[2]; 14150 seenInterrupt = 0; 14151 memset(&sCtx, 0, sizeof(sCtx)); 14152 open_db(p, 0); 14153 nSep = strlen30(p->colSeparator); 14154 if( nSep==0 ){ 14155 raw_printf(stderr, 14156 "Error: non-null column separator required for import\n"); 14157 return 1; 14158 } 14159 if( nSep>1 ){ 14160 raw_printf(stderr, "Error: multi-character column separators not allowed" 14161 " for import\n"); 14162 return 1; 14163 } 14164 nSep = strlen30(p->rowSeparator); 14165 if( nSep==0 ){ 14166 raw_printf(stderr, "Error: non-null row separator required for import\n"); 14167 return 1; 14168 } 14169 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){ 14170 /* When importing CSV (only), if the row separator is set to the 14171 ** default output row separator, change it to the default input 14172 ** row separator. This avoids having to maintain different input 14173 ** and output row separators. */ 14174 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 14175 nSep = strlen30(p->rowSeparator); 14176 } 14177 if( nSep>1 ){ 14178 raw_printf(stderr, "Error: multi-character row separators not allowed" 14179 " for import\n"); 14180 return 1; 14181 } 14182 sCtx.zFile = zFile; 14183 sCtx.nLine = 1; 14184 if( sCtx.zFile[0]=='|' ){ 14185 #ifdef SQLITE_OMIT_POPEN 14186 raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 14187 return 1; 14188 #else 14189 sCtx.in = popen(sCtx.zFile+1, "r"); 14190 sCtx.zFile = "<pipe>"; 14191 xCloser = pclose; 14192 #endif 14193 }else{ 14194 sCtx.in = fopen(sCtx.zFile, "rb"); 14195 xCloser = fclose; 14196 } 14197 if( p->mode==MODE_Ascii ){ 14198 xRead = ascii_read_one_field; 14199 }else{ 14200 xRead = csv_read_one_field; 14201 } 14202 if( sCtx.in==0 ){ 14203 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 14204 return 1; 14205 } 14206 sCtx.cColSep = p->colSeparator[0]; 14207 sCtx.cRowSep = p->rowSeparator[0]; 14208 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable); 14209 if( zSql==0 ){ 14210 xCloser(sCtx.in); 14211 shell_out_of_memory(); 14212 } 14213 nByte = strlen30(zSql); 14214 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 14215 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */ 14216 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){ 14217 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable); 14218 char cSep = '('; 14219 while( xRead(&sCtx) ){ 14220 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z); 14221 cSep = ','; 14222 if( sCtx.cTerm!=sCtx.cColSep ) break; 14223 } 14224 if( cSep=='(' ){ 14225 sqlite3_free(zCreate); 14226 sqlite3_free(sCtx.z); 14227 xCloser(sCtx.in); 14228 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile); 14229 return 1; 14230 } 14231 zCreate = sqlite3_mprintf("%z\n)", zCreate); 14232 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0); 14233 sqlite3_free(zCreate); 14234 if( rc ){ 14235 utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable, 14236 sqlite3_errmsg(p->db)); 14237 sqlite3_free(sCtx.z); 14238 xCloser(sCtx.in); 14239 return 1; 14240 } 14241 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 14242 } 14243 sqlite3_free(zSql); 14244 if( rc ){ 14245 if (pStmt) sqlite3_finalize(pStmt); 14246 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db)); 14247 xCloser(sCtx.in); 14248 return 1; 14249 } 14250 nCol = sqlite3_column_count(pStmt); 14251 sqlite3_finalize(pStmt); 14252 pStmt = 0; 14253 if( nCol==0 ) return 0; /* no columns, no error */ 14254 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 ); 14255 if( zSql==0 ){ 14256 xCloser(sCtx.in); 14257 shell_out_of_memory(); 14258 } 14259 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable); 14260 j = strlen30(zSql); 14261 for(i=1; i<nCol; i++){ 14262 zSql[j++] = ','; 14263 zSql[j++] = '?'; 14264 } 14265 zSql[j++] = ')'; 14266 zSql[j] = 0; 14267 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 14268 sqlite3_free(zSql); 14269 if( rc ){ 14270 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 14271 if (pStmt) sqlite3_finalize(pStmt); 14272 xCloser(sCtx.in); 14273 return 1; 14274 } 14275 needCommit = sqlite3_get_autocommit(p->db); 14276 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0); 14277 do{ 14278 int startLine = sCtx.nLine; 14279 for(i=0; i<nCol; i++){ 14280 char *z = xRead(&sCtx); 14281 /* 14282 ** Did we reach end-of-file before finding any columns? 14283 ** If so, stop instead of NULL filling the remaining columns. 14284 */ 14285 if( z==0 && i==0 ) break; 14286 /* 14287 ** Did we reach end-of-file OR end-of-line before finding any 14288 ** columns in ASCII mode? If so, stop instead of NULL filling 14289 ** the remaining columns. 14290 */ 14291 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break; 14292 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT); 14293 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){ 14294 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 14295 "filling the rest with NULL\n", 14296 sCtx.zFile, startLine, nCol, i+1); 14297 i += 2; 14298 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; } 14299 } 14300 } 14301 if( sCtx.cTerm==sCtx.cColSep ){ 14302 do{ 14303 xRead(&sCtx); 14304 i++; 14305 }while( sCtx.cTerm==sCtx.cColSep ); 14306 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 14307 "extras ignored\n", 14308 sCtx.zFile, startLine, nCol, i); 14309 } 14310 if( i>=nCol ){ 14311 sqlite3_step(pStmt); 14312 rc = sqlite3_reset(pStmt); 14313 if( rc!=SQLITE_OK ){ 14314 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, 14315 startLine, sqlite3_errmsg(p->db)); 14316 } 14317 } 14318 }while( sCtx.cTerm!=EOF ); 14319 14320 xCloser(sCtx.in); 14321 sqlite3_free(sCtx.z); 14322 sqlite3_finalize(pStmt); 14323 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0); 14324 }else 14325 14326 #ifndef SQLITE_UNTESTABLE 14327 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){ 14328 char *zSql; 14329 char *zCollist = 0; 14330 sqlite3_stmt *pStmt; 14331 int tnum = 0; 14332 int i; 14333 if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){ 14334 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n" 14335 " .imposter off\n"); 14336 rc = 1; 14337 goto meta_command_exit; 14338 } 14339 open_db(p, 0); 14340 if( nArg==2 ){ 14341 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1); 14342 goto meta_command_exit; 14343 } 14344 zSql = sqlite3_mprintf("SELECT rootpage FROM sqlite_master" 14345 " WHERE name='%q' AND type='index'", azArg[1]); 14346 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 14347 sqlite3_free(zSql); 14348 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 14349 tnum = sqlite3_column_int(pStmt, 0); 14350 } 14351 sqlite3_finalize(pStmt); 14352 if( tnum==0 ){ 14353 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]); 14354 rc = 1; 14355 goto meta_command_exit; 14356 } 14357 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]); 14358 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 14359 sqlite3_free(zSql); 14360 i = 0; 14361 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 14362 char zLabel[20]; 14363 const char *zCol = (const char*)sqlite3_column_text(pStmt,2); 14364 i++; 14365 if( zCol==0 ){ 14366 if( sqlite3_column_int(pStmt,1)==-1 ){ 14367 zCol = "_ROWID_"; 14368 }else{ 14369 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i); 14370 zCol = zLabel; 14371 } 14372 } 14373 if( zCollist==0 ){ 14374 zCollist = sqlite3_mprintf("\"%w\"", zCol); 14375 }else{ 14376 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol); 14377 } 14378 } 14379 sqlite3_finalize(pStmt); 14380 zSql = sqlite3_mprintf( 14381 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%s))WITHOUT ROWID", 14382 azArg[2], zCollist, zCollist); 14383 sqlite3_free(zCollist); 14384 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum); 14385 if( rc==SQLITE_OK ){ 14386 rc = sqlite3_exec(p->db, zSql, 0, 0, 0); 14387 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0); 14388 if( rc ){ 14389 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db)); 14390 }else{ 14391 utf8_printf(stdout, "%s;\n", zSql); 14392 raw_printf(stdout, 14393 "WARNING: writing to an imposter table will corrupt the index!\n" 14394 ); 14395 } 14396 }else{ 14397 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc); 14398 rc = 1; 14399 } 14400 sqlite3_free(zSql); 14401 }else 14402 #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */ 14403 14404 #ifdef SQLITE_ENABLE_IOTRACE 14405 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ 14406 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...); 14407 if( iotrace && iotrace!=stdout ) fclose(iotrace); 14408 iotrace = 0; 14409 if( nArg<2 ){ 14410 sqlite3IoTrace = 0; 14411 }else if( strcmp(azArg[1], "-")==0 ){ 14412 sqlite3IoTrace = iotracePrintf; 14413 iotrace = stdout; 14414 }else{ 14415 iotrace = fopen(azArg[1], "w"); 14416 if( iotrace==0 ){ 14417 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); 14418 sqlite3IoTrace = 0; 14419 rc = 1; 14420 }else{ 14421 sqlite3IoTrace = iotracePrintf; 14422 } 14423 } 14424 }else 14425 #endif 14426 14427 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){ 14428 static const struct { 14429 const char *zLimitName; /* Name of a limit */ 14430 int limitCode; /* Integer code for that limit */ 14431 } aLimit[] = { 14432 { "length", SQLITE_LIMIT_LENGTH }, 14433 { "sql_length", SQLITE_LIMIT_SQL_LENGTH }, 14434 { "column", SQLITE_LIMIT_COLUMN }, 14435 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH }, 14436 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT }, 14437 { "vdbe_op", SQLITE_LIMIT_VDBE_OP }, 14438 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG }, 14439 { "attached", SQLITE_LIMIT_ATTACHED }, 14440 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH }, 14441 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER }, 14442 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH }, 14443 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS }, 14444 }; 14445 int i, n2; 14446 open_db(p, 0); 14447 if( nArg==1 ){ 14448 for(i=0; i<ArraySize(aLimit); i++){ 14449 printf("%20s %d\n", aLimit[i].zLimitName, 14450 sqlite3_limit(p->db, aLimit[i].limitCode, -1)); 14451 } 14452 }else if( nArg>3 ){ 14453 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n"); 14454 rc = 1; 14455 goto meta_command_exit; 14456 }else{ 14457 int iLimit = -1; 14458 n2 = strlen30(azArg[1]); 14459 for(i=0; i<ArraySize(aLimit); i++){ 14460 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){ 14461 if( iLimit<0 ){ 14462 iLimit = i; 14463 }else{ 14464 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]); 14465 rc = 1; 14466 goto meta_command_exit; 14467 } 14468 } 14469 } 14470 if( iLimit<0 ){ 14471 utf8_printf(stderr, "unknown limit: \"%s\"\n" 14472 "enter \".limits\" with no arguments for a list.\n", 14473 azArg[1]); 14474 rc = 1; 14475 goto meta_command_exit; 14476 } 14477 if( nArg==3 ){ 14478 sqlite3_limit(p->db, aLimit[iLimit].limitCode, 14479 (int)integerValue(azArg[2])); 14480 } 14481 printf("%20s %d\n", aLimit[iLimit].zLimitName, 14482 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1)); 14483 } 14484 }else 14485 14486 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){ 14487 open_db(p, 0); 14488 lintDotCommand(p, azArg, nArg); 14489 }else 14490 14491 #ifndef SQLITE_OMIT_LOAD_EXTENSION 14492 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){ 14493 const char *zFile, *zProc; 14494 char *zErrMsg = 0; 14495 if( nArg<2 ){ 14496 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n"); 14497 rc = 1; 14498 goto meta_command_exit; 14499 } 14500 zFile = azArg[1]; 14501 zProc = nArg>=3 ? azArg[2] : 0; 14502 open_db(p, 0); 14503 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); 14504 if( rc!=SQLITE_OK ){ 14505 utf8_printf(stderr, "Error: %s\n", zErrMsg); 14506 sqlite3_free(zErrMsg); 14507 rc = 1; 14508 } 14509 }else 14510 #endif 14511 14512 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){ 14513 if( nArg!=2 ){ 14514 raw_printf(stderr, "Usage: .log FILENAME\n"); 14515 rc = 1; 14516 }else{ 14517 const char *zFile = azArg[1]; 14518 output_file_close(p->pLog); 14519 p->pLog = output_file_open(zFile, 0); 14520 } 14521 }else 14522 14523 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){ 14524 const char *zMode = nArg>=2 ? azArg[1] : ""; 14525 int n2 = strlen30(zMode); 14526 int c2 = zMode[0]; 14527 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){ 14528 p->mode = MODE_Line; 14529 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 14530 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){ 14531 p->mode = MODE_Column; 14532 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 14533 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){ 14534 p->mode = MODE_List; 14535 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column); 14536 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 14537 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){ 14538 p->mode = MODE_Html; 14539 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){ 14540 p->mode = MODE_Tcl; 14541 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space); 14542 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 14543 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){ 14544 p->mode = MODE_Csv; 14545 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 14546 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 14547 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){ 14548 p->mode = MODE_List; 14549 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab); 14550 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){ 14551 p->mode = MODE_Insert; 14552 set_table_name(p, nArg>=3 ? azArg[2] : "table"); 14553 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){ 14554 p->mode = MODE_Quote; 14555 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){ 14556 p->mode = MODE_Ascii; 14557 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit); 14558 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record); 14559 }else if( nArg==1 ){ 14560 raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]); 14561 }else{ 14562 raw_printf(stderr, "Error: mode should be one of: " 14563 "ascii column csv html insert line list quote tabs tcl\n"); 14564 rc = 1; 14565 } 14566 p->cMode = p->mode; 14567 }else 14568 14569 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){ 14570 if( nArg==2 ){ 14571 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue, 14572 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]); 14573 }else{ 14574 raw_printf(stderr, "Usage: .nullvalue STRING\n"); 14575 rc = 1; 14576 } 14577 }else 14578 14579 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){ 14580 char *zNewFilename; /* Name of the database file to open */ 14581 int iName = 1; /* Index in azArg[] of the filename */ 14582 int newFlag = 0; /* True to delete file before opening */ 14583 /* Close the existing database */ 14584 session_close_all(p); 14585 close_db(p->db); 14586 p->db = 0; 14587 p->zDbFilename = 0; 14588 sqlite3_free(p->zFreeOnClose); 14589 p->zFreeOnClose = 0; 14590 p->openMode = SHELL_OPEN_UNSPEC; 14591 p->szMax = 0; 14592 /* Check for command-line arguments */ 14593 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){ 14594 const char *z = azArg[iName]; 14595 if( optionMatch(z,"new") ){ 14596 newFlag = 1; 14597 #ifdef SQLITE_HAVE_ZLIB 14598 }else if( optionMatch(z, "zip") ){ 14599 p->openMode = SHELL_OPEN_ZIPFILE; 14600 #endif 14601 }else if( optionMatch(z, "append") ){ 14602 p->openMode = SHELL_OPEN_APPENDVFS; 14603 }else if( optionMatch(z, "readonly") ){ 14604 p->openMode = SHELL_OPEN_READONLY; 14605 #ifdef SQLITE_ENABLE_DESERIALIZE 14606 }else if( optionMatch(z, "deserialize") ){ 14607 p->openMode = SHELL_OPEN_DESERIALIZE; 14608 }else if( optionMatch(z, "hexdb") ){ 14609 p->openMode = SHELL_OPEN_HEXDB; 14610 }else if( optionMatch(z, "maxsize") && iName+1<nArg ){ 14611 p->szMax = integerValue(azArg[++iName]); 14612 #endif /* SQLITE_ENABLE_DESERIALIZE */ 14613 }else if( z[0]=='-' ){ 14614 utf8_printf(stderr, "unknown option: %s\n", z); 14615 rc = 1; 14616 goto meta_command_exit; 14617 } 14618 } 14619 /* If a filename is specified, try to open it first */ 14620 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0; 14621 if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){ 14622 if( newFlag ) shellDeleteFile(zNewFilename); 14623 p->zDbFilename = zNewFilename; 14624 open_db(p, OPEN_DB_KEEPALIVE); 14625 if( p->db==0 ){ 14626 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename); 14627 sqlite3_free(zNewFilename); 14628 }else{ 14629 p->zFreeOnClose = zNewFilename; 14630 } 14631 } 14632 if( p->db==0 ){ 14633 /* As a fall-back open a TEMP database */ 14634 p->zDbFilename = 0; 14635 open_db(p, 0); 14636 } 14637 }else 14638 14639 if( (c=='o' 14640 && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0)) 14641 || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0) 14642 ){ 14643 const char *zFile = nArg>=2 ? azArg[1] : "stdout"; 14644 int bTxtMode = 0; 14645 if( azArg[0][0]=='e' ){ 14646 /* Transform the ".excel" command into ".once -x" */ 14647 nArg = 2; 14648 azArg[0] = "once"; 14649 zFile = azArg[1] = "-x"; 14650 n = 4; 14651 } 14652 if( nArg>2 ){ 14653 utf8_printf(stderr, "Usage: .%s [-e|-x|FILE]\n", azArg[0]); 14654 rc = 1; 14655 goto meta_command_exit; 14656 } 14657 if( n>1 && strncmp(azArg[0], "once", n)==0 ){ 14658 if( nArg<2 ){ 14659 raw_printf(stderr, "Usage: .once (-e|-x|FILE)\n"); 14660 rc = 1; 14661 goto meta_command_exit; 14662 } 14663 p->outCount = 2; 14664 }else{ 14665 p->outCount = 0; 14666 } 14667 output_reset(p); 14668 if( zFile[0]=='-' && zFile[1]=='-' ) zFile++; 14669 #ifndef SQLITE_NOHAVE_SYSTEM 14670 if( strcmp(zFile, "-e")==0 || strcmp(zFile, "-x")==0 ){ 14671 p->doXdgOpen = 1; 14672 outputModePush(p); 14673 if( zFile[1]=='x' ){ 14674 newTempFile(p, "csv"); 14675 p->mode = MODE_Csv; 14676 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 14677 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 14678 }else{ 14679 newTempFile(p, "txt"); 14680 bTxtMode = 1; 14681 } 14682 zFile = p->zTempFile; 14683 } 14684 #endif /* SQLITE_NOHAVE_SYSTEM */ 14685 if( zFile[0]=='|' ){ 14686 #ifdef SQLITE_OMIT_POPEN 14687 raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 14688 rc = 1; 14689 p->out = stdout; 14690 #else 14691 p->out = popen(zFile + 1, "w"); 14692 if( p->out==0 ){ 14693 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1); 14694 p->out = stdout; 14695 rc = 1; 14696 }else{ 14697 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 14698 } 14699 #endif 14700 }else{ 14701 p->out = output_file_open(zFile, bTxtMode); 14702 if( p->out==0 ){ 14703 if( strcmp(zFile,"off")!=0 ){ 14704 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile); 14705 } 14706 p->out = stdout; 14707 rc = 1; 14708 } else { 14709 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 14710 } 14711 } 14712 }else 14713 14714 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){ 14715 int i; 14716 for(i=1; i<nArg; i++){ 14717 if( i>1 ) raw_printf(p->out, " "); 14718 utf8_printf(p->out, "%s", azArg[i]); 14719 } 14720 raw_printf(p->out, "\n"); 14721 }else 14722 14723 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 14724 if( c=='p' && n>=3 && strncmp(azArg[0], "progress", n)==0 ){ 14725 int i; 14726 int nn = 0; 14727 p->flgProgress = 0; 14728 p->mxProgress = 0; 14729 p->nProgress = 0; 14730 for(i=1; i<nArg; i++){ 14731 const char *z = azArg[i]; 14732 if( z[0]=='-' ){ 14733 z++; 14734 if( z[0]=='-' ) z++; 14735 if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){ 14736 p->flgProgress |= SHELL_PROGRESS_QUIET; 14737 continue; 14738 } 14739 if( strcmp(z,"reset")==0 ){ 14740 p->flgProgress |= SHELL_PROGRESS_RESET; 14741 continue; 14742 } 14743 if( strcmp(z,"once")==0 ){ 14744 p->flgProgress |= SHELL_PROGRESS_ONCE; 14745 continue; 14746 } 14747 if( strcmp(z,"limit")==0 ){ 14748 if( i+1>=nArg ){ 14749 utf8_printf(stderr, "Error: missing argument on --limit\n"); 14750 rc = 1; 14751 goto meta_command_exit; 14752 }else{ 14753 p->mxProgress = (int)integerValue(azArg[++i]); 14754 } 14755 continue; 14756 } 14757 utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]); 14758 rc = 1; 14759 goto meta_command_exit; 14760 }else{ 14761 nn = (int)integerValue(z); 14762 } 14763 } 14764 open_db(p, 0); 14765 sqlite3_progress_handler(p->db, nn, progress_handler, p); 14766 }else 14767 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 14768 14769 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){ 14770 if( nArg >= 2) { 14771 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); 14772 } 14773 if( nArg >= 3) { 14774 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); 14775 } 14776 }else 14777 14778 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){ 14779 rc = 2; 14780 }else 14781 14782 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){ 14783 FILE *inSaved = p->in; 14784 int savedLineno = p->lineno; 14785 if( nArg!=2 ){ 14786 raw_printf(stderr, "Usage: .read FILE\n"); 14787 rc = 1; 14788 goto meta_command_exit; 14789 } 14790 p->in = fopen(azArg[1], "rb"); 14791 if( p->in==0 ){ 14792 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); 14793 rc = 1; 14794 }else{ 14795 rc = process_input(p); 14796 fclose(p->in); 14797 } 14798 p->in = inSaved; 14799 p->lineno = savedLineno; 14800 }else 14801 14802 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){ 14803 const char *zSrcFile; 14804 const char *zDb; 14805 sqlite3 *pSrc; 14806 sqlite3_backup *pBackup; 14807 int nTimeout = 0; 14808 14809 if( nArg==2 ){ 14810 zSrcFile = azArg[1]; 14811 zDb = "main"; 14812 }else if( nArg==3 ){ 14813 zSrcFile = azArg[2]; 14814 zDb = azArg[1]; 14815 }else{ 14816 raw_printf(stderr, "Usage: .restore ?DB? FILE\n"); 14817 rc = 1; 14818 goto meta_command_exit; 14819 } 14820 rc = sqlite3_open(zSrcFile, &pSrc); 14821 if( rc!=SQLITE_OK ){ 14822 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); 14823 close_db(pSrc); 14824 return 1; 14825 } 14826 open_db(p, 0); 14827 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); 14828 if( pBackup==0 ){ 14829 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 14830 close_db(pSrc); 14831 return 1; 14832 } 14833 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK 14834 || rc==SQLITE_BUSY ){ 14835 if( rc==SQLITE_BUSY ){ 14836 if( nTimeout++ >= 3 ) break; 14837 sqlite3_sleep(100); 14838 } 14839 } 14840 sqlite3_backup_finish(pBackup); 14841 if( rc==SQLITE_DONE ){ 14842 rc = 0; 14843 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ 14844 raw_printf(stderr, "Error: source database is busy\n"); 14845 rc = 1; 14846 }else{ 14847 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 14848 rc = 1; 14849 } 14850 close_db(pSrc); 14851 }else 14852 14853 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){ 14854 if( nArg==2 ){ 14855 p->scanstatsOn = (u8)booleanValue(azArg[1]); 14856 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS 14857 raw_printf(stderr, "Warning: .scanstats not available in this build.\n"); 14858 #endif 14859 }else{ 14860 raw_printf(stderr, "Usage: .scanstats on|off\n"); 14861 rc = 1; 14862 } 14863 }else 14864 14865 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){ 14866 ShellText sSelect; 14867 ShellState data; 14868 char *zErrMsg = 0; 14869 const char *zDiv = "("; 14870 const char *zName = 0; 14871 int iSchema = 0; 14872 int bDebug = 0; 14873 int ii; 14874 14875 open_db(p, 0); 14876 memcpy(&data, p, sizeof(data)); 14877 data.showHeader = 0; 14878 data.cMode = data.mode = MODE_Semi; 14879 initText(&sSelect); 14880 for(ii=1; ii<nArg; ii++){ 14881 if( optionMatch(azArg[ii],"indent") ){ 14882 data.cMode = data.mode = MODE_Pretty; 14883 }else if( optionMatch(azArg[ii],"debug") ){ 14884 bDebug = 1; 14885 }else if( zName==0 ){ 14886 zName = azArg[ii]; 14887 }else{ 14888 raw_printf(stderr, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n"); 14889 rc = 1; 14890 goto meta_command_exit; 14891 } 14892 } 14893 if( zName!=0 ){ 14894 int isMaster = sqlite3_strlike(zName, "sqlite_master", '\\')==0; 14895 if( isMaster || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0 ){ 14896 char *new_argv[2], *new_colv[2]; 14897 new_argv[0] = sqlite3_mprintf( 14898 "CREATE TABLE %s (\n" 14899 " type text,\n" 14900 " name text,\n" 14901 " tbl_name text,\n" 14902 " rootpage integer,\n" 14903 " sql text\n" 14904 ")", isMaster ? "sqlite_master" : "sqlite_temp_master"); 14905 new_argv[1] = 0; 14906 new_colv[0] = "sql"; 14907 new_colv[1] = 0; 14908 callback(&data, 1, new_argv, new_colv); 14909 sqlite3_free(new_argv[0]); 14910 } 14911 } 14912 if( zDiv ){ 14913 sqlite3_stmt *pStmt = 0; 14914 rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list", 14915 -1, &pStmt, 0); 14916 if( rc ){ 14917 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 14918 sqlite3_finalize(pStmt); 14919 rc = 1; 14920 goto meta_command_exit; 14921 } 14922 appendText(&sSelect, "SELECT sql FROM", 0); 14923 iSchema = 0; 14924 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 14925 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0); 14926 char zScNum[30]; 14927 sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema); 14928 appendText(&sSelect, zDiv, 0); 14929 zDiv = " UNION ALL "; 14930 appendText(&sSelect, "SELECT shell_add_schema(sql,", 0); 14931 if( sqlite3_stricmp(zDb, "main")!=0 ){ 14932 appendText(&sSelect, zDb, '"'); 14933 }else{ 14934 appendText(&sSelect, "NULL", 0); 14935 } 14936 appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0); 14937 appendText(&sSelect, zScNum, 0); 14938 appendText(&sSelect, " AS snum, ", 0); 14939 appendText(&sSelect, zDb, '\''); 14940 appendText(&sSelect, " AS sname FROM ", 0); 14941 appendText(&sSelect, zDb, '"'); 14942 appendText(&sSelect, ".sqlite_master", 0); 14943 } 14944 sqlite3_finalize(pStmt); 14945 #ifdef SQLITE_INTROSPECTION_PRAGMAS 14946 if( zName ){ 14947 appendText(&sSelect, 14948 " UNION ALL SELECT shell_module_schema(name)," 14949 " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list", 0); 14950 } 14951 #endif 14952 appendText(&sSelect, ") WHERE ", 0); 14953 if( zName ){ 14954 char *zQarg = sqlite3_mprintf("%Q", zName); 14955 int bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 || 14956 strchr(zName, '[') != 0; 14957 if( strchr(zName, '.') ){ 14958 appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0); 14959 }else{ 14960 appendText(&sSelect, "lower(tbl_name)", 0); 14961 } 14962 appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0); 14963 appendText(&sSelect, zQarg, 0); 14964 if( !bGlob ){ 14965 appendText(&sSelect, " ESCAPE '\\' ", 0); 14966 } 14967 appendText(&sSelect, " AND ", 0); 14968 sqlite3_free(zQarg); 14969 } 14970 appendText(&sSelect, "type!='meta' AND sql IS NOT NULL" 14971 " ORDER BY snum, rowid", 0); 14972 if( bDebug ){ 14973 utf8_printf(p->out, "SQL: %s;\n", sSelect.z); 14974 }else{ 14975 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg); 14976 } 14977 freeText(&sSelect); 14978 } 14979 if( zErrMsg ){ 14980 utf8_printf(stderr,"Error: %s\n", zErrMsg); 14981 sqlite3_free(zErrMsg); 14982 rc = 1; 14983 }else if( rc != SQLITE_OK ){ 14984 raw_printf(stderr,"Error: querying schema information\n"); 14985 rc = 1; 14986 }else{ 14987 rc = 0; 14988 } 14989 }else 14990 14991 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 14992 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){ 14993 sqlite3SelectTrace = (int)integerValue(azArg[1]); 14994 }else 14995 #endif 14996 14997 #if defined(SQLITE_ENABLE_SESSION) 14998 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){ 14999 OpenSession *pSession = &p->aSession[0]; 15000 char **azCmd = &azArg[1]; 15001 int iSes = 0; 15002 int nCmd = nArg - 1; 15003 int i; 15004 if( nArg<=1 ) goto session_syntax_error; 15005 open_db(p, 0); 15006 if( nArg>=3 ){ 15007 for(iSes=0; iSes<p->nSession; iSes++){ 15008 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break; 15009 } 15010 if( iSes<p->nSession ){ 15011 pSession = &p->aSession[iSes]; 15012 azCmd++; 15013 nCmd--; 15014 }else{ 15015 pSession = &p->aSession[0]; 15016 iSes = 0; 15017 } 15018 } 15019 15020 /* .session attach TABLE 15021 ** Invoke the sqlite3session_attach() interface to attach a particular 15022 ** table so that it is never filtered. 15023 */ 15024 if( strcmp(azCmd[0],"attach")==0 ){ 15025 if( nCmd!=2 ) goto session_syntax_error; 15026 if( pSession->p==0 ){ 15027 session_not_open: 15028 raw_printf(stderr, "ERROR: No sessions are open\n"); 15029 }else{ 15030 rc = sqlite3session_attach(pSession->p, azCmd[1]); 15031 if( rc ){ 15032 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc); 15033 rc = 0; 15034 } 15035 } 15036 }else 15037 15038 /* .session changeset FILE 15039 ** .session patchset FILE 15040 ** Write a changeset or patchset into a file. The file is overwritten. 15041 */ 15042 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){ 15043 FILE *out = 0; 15044 if( nCmd!=2 ) goto session_syntax_error; 15045 if( pSession->p==0 ) goto session_not_open; 15046 out = fopen(azCmd[1], "wb"); 15047 if( out==0 ){ 15048 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n", azCmd[1]); 15049 }else{ 15050 int szChng; 15051 void *pChng; 15052 if( azCmd[0][0]=='c' ){ 15053 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng); 15054 }else{ 15055 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng); 15056 } 15057 if( rc ){ 15058 printf("Error: error code %d\n", rc); 15059 rc = 0; 15060 } 15061 if( pChng 15062 && fwrite(pChng, szChng, 1, out)!=1 ){ 15063 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n", 15064 szChng); 15065 } 15066 sqlite3_free(pChng); 15067 fclose(out); 15068 } 15069 }else 15070 15071 /* .session close 15072 ** Close the identified session 15073 */ 15074 if( strcmp(azCmd[0], "close")==0 ){ 15075 if( nCmd!=1 ) goto session_syntax_error; 15076 if( p->nSession ){ 15077 session_close(pSession); 15078 p->aSession[iSes] = p->aSession[--p->nSession]; 15079 } 15080 }else 15081 15082 /* .session enable ?BOOLEAN? 15083 ** Query or set the enable flag 15084 */ 15085 if( strcmp(azCmd[0], "enable")==0 ){ 15086 int ii; 15087 if( nCmd>2 ) goto session_syntax_error; 15088 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 15089 if( p->nSession ){ 15090 ii = sqlite3session_enable(pSession->p, ii); 15091 utf8_printf(p->out, "session %s enable flag = %d\n", 15092 pSession->zName, ii); 15093 } 15094 }else 15095 15096 /* .session filter GLOB .... 15097 ** Set a list of GLOB patterns of table names to be excluded. 15098 */ 15099 if( strcmp(azCmd[0], "filter")==0 ){ 15100 int ii, nByte; 15101 if( nCmd<2 ) goto session_syntax_error; 15102 if( p->nSession ){ 15103 for(ii=0; ii<pSession->nFilter; ii++){ 15104 sqlite3_free(pSession->azFilter[ii]); 15105 } 15106 sqlite3_free(pSession->azFilter); 15107 nByte = sizeof(pSession->azFilter[0])*(nCmd-1); 15108 pSession->azFilter = sqlite3_malloc( nByte ); 15109 if( pSession->azFilter==0 ){ 15110 raw_printf(stderr, "Error: out or memory\n"); 15111 exit(1); 15112 } 15113 for(ii=1; ii<nCmd; ii++){ 15114 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]); 15115 } 15116 pSession->nFilter = ii-1; 15117 } 15118 }else 15119 15120 /* .session indirect ?BOOLEAN? 15121 ** Query or set the indirect flag 15122 */ 15123 if( strcmp(azCmd[0], "indirect")==0 ){ 15124 int ii; 15125 if( nCmd>2 ) goto session_syntax_error; 15126 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 15127 if( p->nSession ){ 15128 ii = sqlite3session_indirect(pSession->p, ii); 15129 utf8_printf(p->out, "session %s indirect flag = %d\n", 15130 pSession->zName, ii); 15131 } 15132 }else 15133 15134 /* .session isempty 15135 ** Determine if the session is empty 15136 */ 15137 if( strcmp(azCmd[0], "isempty")==0 ){ 15138 int ii; 15139 if( nCmd!=1 ) goto session_syntax_error; 15140 if( p->nSession ){ 15141 ii = sqlite3session_isempty(pSession->p); 15142 utf8_printf(p->out, "session %s isempty flag = %d\n", 15143 pSession->zName, ii); 15144 } 15145 }else 15146 15147 /* .session list 15148 ** List all currently open sessions 15149 */ 15150 if( strcmp(azCmd[0],"list")==0 ){ 15151 for(i=0; i<p->nSession; i++){ 15152 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName); 15153 } 15154 }else 15155 15156 /* .session open DB NAME 15157 ** Open a new session called NAME on the attached database DB. 15158 ** DB is normally "main". 15159 */ 15160 if( strcmp(azCmd[0],"open")==0 ){ 15161 char *zName; 15162 if( nCmd!=3 ) goto session_syntax_error; 15163 zName = azCmd[2]; 15164 if( zName[0]==0 ) goto session_syntax_error; 15165 for(i=0; i<p->nSession; i++){ 15166 if( strcmp(p->aSession[i].zName,zName)==0 ){ 15167 utf8_printf(stderr, "Session \"%s\" already exists\n", zName); 15168 goto meta_command_exit; 15169 } 15170 } 15171 if( p->nSession>=ArraySize(p->aSession) ){ 15172 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession)); 15173 goto meta_command_exit; 15174 } 15175 pSession = &p->aSession[p->nSession]; 15176 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p); 15177 if( rc ){ 15178 raw_printf(stderr, "Cannot open session: error code=%d\n", rc); 15179 rc = 0; 15180 goto meta_command_exit; 15181 } 15182 pSession->nFilter = 0; 15183 sqlite3session_table_filter(pSession->p, session_filter, pSession); 15184 p->nSession++; 15185 pSession->zName = sqlite3_mprintf("%s", zName); 15186 }else 15187 /* If no command name matches, show a syntax error */ 15188 session_syntax_error: 15189 showHelp(p->out, "session"); 15190 }else 15191 #endif 15192 15193 #ifdef SQLITE_DEBUG 15194 /* Undocumented commands for internal testing. Subject to change 15195 ** without notice. */ 15196 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){ 15197 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){ 15198 int i, v; 15199 for(i=1; i<nArg; i++){ 15200 v = booleanValue(azArg[i]); 15201 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v); 15202 } 15203 } 15204 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){ 15205 int i; sqlite3_int64 v; 15206 for(i=1; i<nArg; i++){ 15207 char zBuf[200]; 15208 v = integerValue(azArg[i]); 15209 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v); 15210 utf8_printf(p->out, "%s", zBuf); 15211 } 15212 } 15213 }else 15214 #endif 15215 15216 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){ 15217 int bIsInit = 0; /* True to initialize the SELFTEST table */ 15218 int bVerbose = 0; /* Verbose output */ 15219 int bSelftestExists; /* True if SELFTEST already exists */ 15220 int i, k; /* Loop counters */ 15221 int nTest = 0; /* Number of tests runs */ 15222 int nErr = 0; /* Number of errors seen */ 15223 ShellText str; /* Answer for a query */ 15224 sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */ 15225 15226 open_db(p,0); 15227 for(i=1; i<nArg; i++){ 15228 const char *z = azArg[i]; 15229 if( z[0]=='-' && z[1]=='-' ) z++; 15230 if( strcmp(z,"-init")==0 ){ 15231 bIsInit = 1; 15232 }else 15233 if( strcmp(z,"-v")==0 ){ 15234 bVerbose++; 15235 }else 15236 { 15237 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 15238 azArg[i], azArg[0]); 15239 raw_printf(stderr, "Should be one of: --init -v\n"); 15240 rc = 1; 15241 goto meta_command_exit; 15242 } 15243 } 15244 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0) 15245 != SQLITE_OK ){ 15246 bSelftestExists = 0; 15247 }else{ 15248 bSelftestExists = 1; 15249 } 15250 if( bIsInit ){ 15251 createSelftestTable(p); 15252 bSelftestExists = 1; 15253 } 15254 initText(&str); 15255 appendText(&str, "x", 0); 15256 for(k=bSelftestExists; k>=0; k--){ 15257 if( k==1 ){ 15258 rc = sqlite3_prepare_v2(p->db, 15259 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno", 15260 -1, &pStmt, 0); 15261 }else{ 15262 rc = sqlite3_prepare_v2(p->db, 15263 "VALUES(0,'memo','Missing SELFTEST table - default checks only','')," 15264 " (1,'run','PRAGMA integrity_check','ok')", 15265 -1, &pStmt, 0); 15266 } 15267 if( rc ){ 15268 raw_printf(stderr, "Error querying the selftest table\n"); 15269 rc = 1; 15270 sqlite3_finalize(pStmt); 15271 goto meta_command_exit; 15272 } 15273 for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){ 15274 int tno = sqlite3_column_int(pStmt, 0); 15275 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1); 15276 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2); 15277 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3); 15278 15279 k = 0; 15280 if( bVerbose>0 ){ 15281 char *zQuote = sqlite3_mprintf("%q", zSql); 15282 printf("%d: %s %s\n", tno, zOp, zSql); 15283 sqlite3_free(zQuote); 15284 } 15285 if( strcmp(zOp,"memo")==0 ){ 15286 utf8_printf(p->out, "%s\n", zSql); 15287 }else 15288 if( strcmp(zOp,"run")==0 ){ 15289 char *zErrMsg = 0; 15290 str.n = 0; 15291 str.z[0] = 0; 15292 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg); 15293 nTest++; 15294 if( bVerbose ){ 15295 utf8_printf(p->out, "Result: %s\n", str.z); 15296 } 15297 if( rc || zErrMsg ){ 15298 nErr++; 15299 rc = 1; 15300 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg); 15301 sqlite3_free(zErrMsg); 15302 }else if( strcmp(zAns,str.z)!=0 ){ 15303 nErr++; 15304 rc = 1; 15305 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns); 15306 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z); 15307 } 15308 }else 15309 { 15310 utf8_printf(stderr, 15311 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno); 15312 rc = 1; 15313 break; 15314 } 15315 } /* End loop over rows of content from SELFTEST */ 15316 sqlite3_finalize(pStmt); 15317 } /* End loop over k */ 15318 freeText(&str); 15319 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest); 15320 }else 15321 15322 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){ 15323 if( nArg<2 || nArg>3 ){ 15324 raw_printf(stderr, "Usage: .separator COL ?ROW?\n"); 15325 rc = 1; 15326 } 15327 if( nArg>=2 ){ 15328 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, 15329 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]); 15330 } 15331 if( nArg>=3 ){ 15332 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, 15333 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]); 15334 } 15335 }else 15336 15337 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){ 15338 const char *zLike = 0; /* Which table to checksum. 0 means everything */ 15339 int i; /* Loop counter */ 15340 int bSchema = 0; /* Also hash the schema */ 15341 int bSeparate = 0; /* Hash each table separately */ 15342 int iSize = 224; /* Hash algorithm to use */ 15343 int bDebug = 0; /* Only show the query that would have run */ 15344 sqlite3_stmt *pStmt; /* For querying tables names */ 15345 char *zSql; /* SQL to be run */ 15346 char *zSep; /* Separator */ 15347 ShellText sSql; /* Complete SQL for the query to run the hash */ 15348 ShellText sQuery; /* Set of queries used to read all content */ 15349 open_db(p, 0); 15350 for(i=1; i<nArg; i++){ 15351 const char *z = azArg[i]; 15352 if( z[0]=='-' ){ 15353 z++; 15354 if( z[0]=='-' ) z++; 15355 if( strcmp(z,"schema")==0 ){ 15356 bSchema = 1; 15357 }else 15358 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0 15359 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0 15360 ){ 15361 iSize = atoi(&z[5]); 15362 }else 15363 if( strcmp(z,"debug")==0 ){ 15364 bDebug = 1; 15365 }else 15366 { 15367 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 15368 azArg[i], azArg[0]); 15369 raw_printf(stderr, "Should be one of: --schema" 15370 " --sha3-224 --sha3-256 --sha3-384 --sha3-512\n"); 15371 rc = 1; 15372 goto meta_command_exit; 15373 } 15374 }else if( zLike ){ 15375 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n"); 15376 rc = 1; 15377 goto meta_command_exit; 15378 }else{ 15379 zLike = z; 15380 bSeparate = 1; 15381 if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1; 15382 } 15383 } 15384 if( bSchema ){ 15385 zSql = "SELECT lower(name) FROM sqlite_master" 15386 " WHERE type='table' AND coalesce(rootpage,0)>1" 15387 " UNION ALL SELECT 'sqlite_master'" 15388 " ORDER BY 1 collate nocase"; 15389 }else{ 15390 zSql = "SELECT lower(name) FROM sqlite_master" 15391 " WHERE type='table' AND coalesce(rootpage,0)>1" 15392 " AND name NOT LIKE 'sqlite_%'" 15393 " ORDER BY 1 collate nocase"; 15394 } 15395 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 15396 initText(&sQuery); 15397 initText(&sSql); 15398 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0); 15399 zSep = "VALUES("; 15400 while( SQLITE_ROW==sqlite3_step(pStmt) ){ 15401 const char *zTab = (const char*)sqlite3_column_text(pStmt,0); 15402 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue; 15403 if( strncmp(zTab, "sqlite_",7)!=0 ){ 15404 appendText(&sQuery,"SELECT * FROM ", 0); 15405 appendText(&sQuery,zTab,'"'); 15406 appendText(&sQuery," NOT INDEXED;", 0); 15407 }else if( strcmp(zTab, "sqlite_master")==0 ){ 15408 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master" 15409 " ORDER BY name;", 0); 15410 }else if( strcmp(zTab, "sqlite_sequence")==0 ){ 15411 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence" 15412 " ORDER BY name;", 0); 15413 }else if( strcmp(zTab, "sqlite_stat1")==0 ){ 15414 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1" 15415 " ORDER BY tbl,idx;", 0); 15416 }else if( strcmp(zTab, "sqlite_stat3")==0 15417 || strcmp(zTab, "sqlite_stat4")==0 ){ 15418 appendText(&sQuery, "SELECT * FROM ", 0); 15419 appendText(&sQuery, zTab, 0); 15420 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0); 15421 } 15422 appendText(&sSql, zSep, 0); 15423 appendText(&sSql, sQuery.z, '\''); 15424 sQuery.n = 0; 15425 appendText(&sSql, ",", 0); 15426 appendText(&sSql, zTab, '\''); 15427 zSep = "),("; 15428 } 15429 sqlite3_finalize(pStmt); 15430 if( bSeparate ){ 15431 zSql = sqlite3_mprintf( 15432 "%s))" 15433 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label" 15434 " FROM [sha3sum$query]", 15435 sSql.z, iSize); 15436 }else{ 15437 zSql = sqlite3_mprintf( 15438 "%s))" 15439 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash" 15440 " FROM [sha3sum$query]", 15441 sSql.z, iSize); 15442 } 15443 freeText(&sQuery); 15444 freeText(&sSql); 15445 if( bDebug ){ 15446 utf8_printf(p->out, "%s\n", zSql); 15447 }else{ 15448 shell_exec(p, zSql, 0); 15449 } 15450 sqlite3_free(zSql); 15451 }else 15452 15453 #ifndef SQLITE_NOHAVE_SYSTEM 15454 if( c=='s' 15455 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0) 15456 ){ 15457 char *zCmd; 15458 int i, x; 15459 if( nArg<2 ){ 15460 raw_printf(stderr, "Usage: .system COMMAND\n"); 15461 rc = 1; 15462 goto meta_command_exit; 15463 } 15464 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]); 15465 for(i=2; i<nArg; i++){ 15466 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"", 15467 zCmd, azArg[i]); 15468 } 15469 x = system(zCmd); 15470 sqlite3_free(zCmd); 15471 if( x ) raw_printf(stderr, "System command returns %d\n", x); 15472 }else 15473 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 15474 15475 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){ 15476 static const char *azBool[] = { "off", "on", "trigger", "full"}; 15477 int i; 15478 if( nArg!=1 ){ 15479 raw_printf(stderr, "Usage: .show\n"); 15480 rc = 1; 15481 goto meta_command_exit; 15482 } 15483 utf8_printf(p->out, "%12.12s: %s\n","echo", 15484 azBool[ShellHasFlag(p, SHFLG_Echo)]); 15485 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]); 15486 utf8_printf(p->out, "%12.12s: %s\n","explain", 15487 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off"); 15488 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]); 15489 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]); 15490 utf8_printf(p->out, "%12.12s: ", "nullvalue"); 15491 output_c_string(p->out, p->nullValue); 15492 raw_printf(p->out, "\n"); 15493 utf8_printf(p->out,"%12.12s: %s\n","output", 15494 strlen30(p->outfile) ? p->outfile : "stdout"); 15495 utf8_printf(p->out,"%12.12s: ", "colseparator"); 15496 output_c_string(p->out, p->colSeparator); 15497 raw_printf(p->out, "\n"); 15498 utf8_printf(p->out,"%12.12s: ", "rowseparator"); 15499 output_c_string(p->out, p->rowSeparator); 15500 raw_printf(p->out, "\n"); 15501 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]); 15502 utf8_printf(p->out, "%12.12s: ", "width"); 15503 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) { 15504 raw_printf(p->out, "%d ", p->colWidth[i]); 15505 } 15506 raw_printf(p->out, "\n"); 15507 utf8_printf(p->out, "%12.12s: %s\n", "filename", 15508 p->zDbFilename ? p->zDbFilename : ""); 15509 }else 15510 15511 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){ 15512 if( nArg==2 ){ 15513 p->statsOn = (u8)booleanValue(azArg[1]); 15514 }else if( nArg==1 ){ 15515 display_stats(p->db, p, 0); 15516 }else{ 15517 raw_printf(stderr, "Usage: .stats ?on|off?\n"); 15518 rc = 1; 15519 } 15520 }else 15521 15522 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0) 15523 || (c=='i' && (strncmp(azArg[0], "indices", n)==0 15524 || strncmp(azArg[0], "indexes", n)==0) ) 15525 ){ 15526 sqlite3_stmt *pStmt; 15527 char **azResult; 15528 int nRow, nAlloc; 15529 int ii; 15530 ShellText s; 15531 initText(&s); 15532 open_db(p, 0); 15533 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); 15534 if( rc ){ 15535 sqlite3_finalize(pStmt); 15536 return shellDatabaseError(p->db); 15537 } 15538 15539 if( nArg>2 && c=='i' ){ 15540 /* It is an historical accident that the .indexes command shows an error 15541 ** when called with the wrong number of arguments whereas the .tables 15542 ** command does not. */ 15543 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n"); 15544 rc = 1; 15545 sqlite3_finalize(pStmt); 15546 goto meta_command_exit; 15547 } 15548 for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){ 15549 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1); 15550 if( zDbName==0 ) continue; 15551 if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0); 15552 if( sqlite3_stricmp(zDbName, "main")==0 ){ 15553 appendText(&s, "SELECT name FROM ", 0); 15554 }else{ 15555 appendText(&s, "SELECT ", 0); 15556 appendText(&s, zDbName, '\''); 15557 appendText(&s, "||'.'||name FROM ", 0); 15558 } 15559 appendText(&s, zDbName, '"'); 15560 appendText(&s, ".sqlite_master ", 0); 15561 if( c=='t' ){ 15562 appendText(&s," WHERE type IN ('table','view')" 15563 " AND name NOT LIKE 'sqlite_%'" 15564 " AND name LIKE ?1", 0); 15565 }else{ 15566 appendText(&s," WHERE type='index'" 15567 " AND tbl_name LIKE ?1", 0); 15568 } 15569 } 15570 rc = sqlite3_finalize(pStmt); 15571 appendText(&s, " ORDER BY 1", 0); 15572 rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0); 15573 freeText(&s); 15574 if( rc ) return shellDatabaseError(p->db); 15575 15576 /* Run the SQL statement prepared by the above block. Store the results 15577 ** as an array of nul-terminated strings in azResult[]. */ 15578 nRow = nAlloc = 0; 15579 azResult = 0; 15580 if( nArg>1 ){ 15581 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT); 15582 }else{ 15583 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC); 15584 } 15585 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 15586 if( nRow>=nAlloc ){ 15587 char **azNew; 15588 int n2 = nAlloc*2 + 10; 15589 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2); 15590 if( azNew==0 ) shell_out_of_memory(); 15591 nAlloc = n2; 15592 azResult = azNew; 15593 } 15594 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0)); 15595 if( 0==azResult[nRow] ) shell_out_of_memory(); 15596 nRow++; 15597 } 15598 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){ 15599 rc = shellDatabaseError(p->db); 15600 } 15601 15602 /* Pretty-print the contents of array azResult[] to the output */ 15603 if( rc==0 && nRow>0 ){ 15604 int len, maxlen = 0; 15605 int i, j; 15606 int nPrintCol, nPrintRow; 15607 for(i=0; i<nRow; i++){ 15608 len = strlen30(azResult[i]); 15609 if( len>maxlen ) maxlen = len; 15610 } 15611 nPrintCol = 80/(maxlen+2); 15612 if( nPrintCol<1 ) nPrintCol = 1; 15613 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; 15614 for(i=0; i<nPrintRow; i++){ 15615 for(j=i; j<nRow; j+=nPrintRow){ 15616 char *zSp = j<nPrintRow ? "" : " "; 15617 utf8_printf(p->out, "%s%-*s", zSp, maxlen, 15618 azResult[j] ? azResult[j]:""); 15619 } 15620 raw_printf(p->out, "\n"); 15621 } 15622 } 15623 15624 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]); 15625 sqlite3_free(azResult); 15626 }else 15627 15628 /* Begin redirecting output to the file "testcase-out.txt" */ 15629 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){ 15630 output_reset(p); 15631 p->out = output_file_open("testcase-out.txt", 0); 15632 if( p->out==0 ){ 15633 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n"); 15634 } 15635 if( nArg>=2 ){ 15636 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]); 15637 }else{ 15638 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?"); 15639 } 15640 }else 15641 15642 #ifndef SQLITE_UNTESTABLE 15643 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 ){ 15644 static const struct { 15645 const char *zCtrlName; /* Name of a test-control option */ 15646 int ctrlCode; /* Integer code for that option */ 15647 const char *zUsage; /* Usage notes */ 15648 } aCtrl[] = { 15649 { "always", SQLITE_TESTCTRL_ALWAYS, "BOOLEAN" }, 15650 { "assert", SQLITE_TESTCTRL_ASSERT, "BOOLEAN" }, 15651 /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, "" },*/ 15652 /*{ "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST, "" },*/ 15653 { "byteorder", SQLITE_TESTCTRL_BYTEORDER, "" }, 15654 /*{ "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL, "" }, */ 15655 { "imposter", SQLITE_TESTCTRL_IMPOSTER, "SCHEMA ON/OFF ROOTPAGE"}, 15656 { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "BOOLEAN" }, 15657 { "localtime_fault", SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN" }, 15658 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN" }, 15659 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK" }, 15660 #ifdef YYCOVERAGE 15661 { "parser_coverage", SQLITE_TESTCTRL_PARSER_COVERAGE, "" }, 15662 #endif 15663 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE, "OFFSET " }, 15664 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET, "" }, 15665 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE, "" }, 15666 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE, "" }, 15667 { "reserve", SQLITE_TESTCTRL_RESERVE, "BYTES-OF-RESERVE" }, 15668 }; 15669 int testctrl = -1; 15670 int iCtrl = -1; 15671 int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */ 15672 int isOk = 0; 15673 int i, n2; 15674 const char *zCmd = 0; 15675 15676 open_db(p, 0); 15677 zCmd = nArg>=2 ? azArg[1] : "help"; 15678 15679 /* The argument can optionally begin with "-" or "--" */ 15680 if( zCmd[0]=='-' && zCmd[1] ){ 15681 zCmd++; 15682 if( zCmd[0]=='-' && zCmd[1] ) zCmd++; 15683 } 15684 15685 /* --help lists all test-controls */ 15686 if( strcmp(zCmd,"help")==0 ){ 15687 utf8_printf(p->out, "Available test-controls:\n"); 15688 for(i=0; i<ArraySize(aCtrl); i++){ 15689 utf8_printf(p->out, " .testctrl %s %s\n", 15690 aCtrl[i].zCtrlName, aCtrl[i].zUsage); 15691 } 15692 rc = 1; 15693 goto meta_command_exit; 15694 } 15695 15696 /* convert testctrl text option to value. allow any unique prefix 15697 ** of the option name, or a numerical value. */ 15698 n2 = strlen30(zCmd); 15699 for(i=0; i<ArraySize(aCtrl); i++){ 15700 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){ 15701 if( testctrl<0 ){ 15702 testctrl = aCtrl[i].ctrlCode; 15703 iCtrl = i; 15704 }else{ 15705 utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n" 15706 "Use \".testctrl --help\" for help\n", zCmd); 15707 rc = 1; 15708 goto meta_command_exit; 15709 } 15710 } 15711 } 15712 if( testctrl<0 ){ 15713 utf8_printf(stderr,"Error: unknown test-control: %s\n" 15714 "Use \".testctrl --help\" for help\n", zCmd); 15715 }else{ 15716 switch(testctrl){ 15717 15718 /* sqlite3_test_control(int, db, int) */ 15719 case SQLITE_TESTCTRL_OPTIMIZATIONS: 15720 case SQLITE_TESTCTRL_RESERVE: 15721 if( nArg==3 ){ 15722 int opt = (int)strtol(azArg[2], 0, 0); 15723 rc2 = sqlite3_test_control(testctrl, p->db, opt); 15724 isOk = 3; 15725 } 15726 break; 15727 15728 /* sqlite3_test_control(int) */ 15729 case SQLITE_TESTCTRL_PRNG_SAVE: 15730 case SQLITE_TESTCTRL_PRNG_RESTORE: 15731 case SQLITE_TESTCTRL_PRNG_RESET: 15732 case SQLITE_TESTCTRL_BYTEORDER: 15733 if( nArg==2 ){ 15734 rc2 = sqlite3_test_control(testctrl); 15735 isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3; 15736 } 15737 break; 15738 15739 /* sqlite3_test_control(int, uint) */ 15740 case SQLITE_TESTCTRL_PENDING_BYTE: 15741 if( nArg==3 ){ 15742 unsigned int opt = (unsigned int)integerValue(azArg[2]); 15743 rc2 = sqlite3_test_control(testctrl, opt); 15744 isOk = 3; 15745 } 15746 break; 15747 15748 /* sqlite3_test_control(int, int) */ 15749 case SQLITE_TESTCTRL_ASSERT: 15750 case SQLITE_TESTCTRL_ALWAYS: 15751 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: 15752 if( nArg==3 ){ 15753 int opt = booleanValue(azArg[2]); 15754 rc2 = sqlite3_test_control(testctrl, opt); 15755 isOk = 1; 15756 } 15757 break; 15758 15759 /* sqlite3_test_control(int, int) */ 15760 case SQLITE_TESTCTRL_LOCALTIME_FAULT: 15761 case SQLITE_TESTCTRL_NEVER_CORRUPT: 15762 if( nArg==3 ){ 15763 int opt = booleanValue(azArg[2]); 15764 rc2 = sqlite3_test_control(testctrl, opt); 15765 isOk = 3; 15766 } 15767 break; 15768 15769 case SQLITE_TESTCTRL_IMPOSTER: 15770 if( nArg==5 ){ 15771 rc2 = sqlite3_test_control(testctrl, p->db, 15772 azArg[2], 15773 integerValue(azArg[3]), 15774 integerValue(azArg[4])); 15775 isOk = 3; 15776 } 15777 break; 15778 15779 #ifdef YYCOVERAGE 15780 case SQLITE_TESTCTRL_PARSER_COVERAGE: 15781 if( nArg==2 ){ 15782 sqlite3_test_control(testctrl, p->out); 15783 isOk = 3; 15784 } 15785 #endif 15786 } 15787 } 15788 if( isOk==0 && iCtrl>=0 ){ 15789 utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd, aCtrl[iCtrl].zUsage); 15790 rc = 1; 15791 }else if( isOk==1 ){ 15792 raw_printf(p->out, "%d\n", rc2); 15793 }else if( isOk==2 ){ 15794 raw_printf(p->out, "0x%08x\n", rc2); 15795 } 15796 }else 15797 #endif /* !defined(SQLITE_UNTESTABLE) */ 15798 15799 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){ 15800 open_db(p, 0); 15801 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0); 15802 }else 15803 15804 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){ 15805 if( nArg==2 ){ 15806 enableTimer = booleanValue(azArg[1]); 15807 if( enableTimer && !HAS_TIMER ){ 15808 raw_printf(stderr, "Error: timer not available on this system.\n"); 15809 enableTimer = 0; 15810 } 15811 }else{ 15812 raw_printf(stderr, "Usage: .timer on|off\n"); 15813 rc = 1; 15814 } 15815 }else 15816 15817 #ifndef SQLITE_OMIT_TRACE 15818 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){ 15819 int mType = 0; 15820 int jj; 15821 open_db(p, 0); 15822 for(jj=1; jj<nArg; jj++){ 15823 const char *z = azArg[jj]; 15824 if( z[0]=='-' ){ 15825 if( optionMatch(z, "expanded") ){ 15826 p->eTraceType = SHELL_TRACE_EXPANDED; 15827 } 15828 #ifdef SQLITE_ENABLE_NORMALIZE 15829 else if( optionMatch(z, "normalized") ){ 15830 p->eTraceType = SHELL_TRACE_NORMALIZED; 15831 } 15832 #endif 15833 else if( optionMatch(z, "plain") ){ 15834 p->eTraceType = SHELL_TRACE_PLAIN; 15835 } 15836 else if( optionMatch(z, "profile") ){ 15837 mType |= SQLITE_TRACE_PROFILE; 15838 } 15839 else if( optionMatch(z, "row") ){ 15840 mType |= SQLITE_TRACE_ROW; 15841 } 15842 else if( optionMatch(z, "stmt") ){ 15843 mType |= SQLITE_TRACE_STMT; 15844 } 15845 else if( optionMatch(z, "close") ){ 15846 mType |= SQLITE_TRACE_CLOSE; 15847 } 15848 else { 15849 raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z); 15850 rc = 1; 15851 goto meta_command_exit; 15852 } 15853 }else{ 15854 output_file_close(p->traceOut); 15855 p->traceOut = output_file_open(azArg[1], 0); 15856 } 15857 } 15858 if( p->traceOut==0 ){ 15859 sqlite3_trace_v2(p->db, 0, 0, 0); 15860 }else{ 15861 if( mType==0 ) mType = SQLITE_TRACE_STMT; 15862 sqlite3_trace_v2(p->db, mType, sql_trace_callback, p); 15863 } 15864 }else 15865 #endif /* !defined(SQLITE_OMIT_TRACE) */ 15866 15867 #if SQLITE_USER_AUTHENTICATION 15868 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){ 15869 if( nArg<2 ){ 15870 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n"); 15871 rc = 1; 15872 goto meta_command_exit; 15873 } 15874 open_db(p, 0); 15875 if( strcmp(azArg[1],"login")==0 ){ 15876 if( nArg!=4 ){ 15877 raw_printf(stderr, "Usage: .user login USER PASSWORD\n"); 15878 rc = 1; 15879 goto meta_command_exit; 15880 } 15881 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3], strlen30(azArg[3])); 15882 if( rc ){ 15883 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]); 15884 rc = 1; 15885 } 15886 }else if( strcmp(azArg[1],"add")==0 ){ 15887 if( nArg!=5 ){ 15888 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n"); 15889 rc = 1; 15890 goto meta_command_exit; 15891 } 15892 rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 15893 booleanValue(azArg[4])); 15894 if( rc ){ 15895 raw_printf(stderr, "User-Add failed: %d\n", rc); 15896 rc = 1; 15897 } 15898 }else if( strcmp(azArg[1],"edit")==0 ){ 15899 if( nArg!=5 ){ 15900 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n"); 15901 rc = 1; 15902 goto meta_command_exit; 15903 } 15904 rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 15905 booleanValue(azArg[4])); 15906 if( rc ){ 15907 raw_printf(stderr, "User-Edit failed: %d\n", rc); 15908 rc = 1; 15909 } 15910 }else if( strcmp(azArg[1],"delete")==0 ){ 15911 if( nArg!=3 ){ 15912 raw_printf(stderr, "Usage: .user delete USER\n"); 15913 rc = 1; 15914 goto meta_command_exit; 15915 } 15916 rc = sqlite3_user_delete(p->db, azArg[2]); 15917 if( rc ){ 15918 raw_printf(stderr, "User-Delete failed: %d\n", rc); 15919 rc = 1; 15920 } 15921 }else{ 15922 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n"); 15923 rc = 1; 15924 goto meta_command_exit; 15925 } 15926 }else 15927 #endif /* SQLITE_USER_AUTHENTICATION */ 15928 15929 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){ 15930 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/, 15931 sqlite3_libversion(), sqlite3_sourceid()); 15932 #if SQLITE_HAVE_ZLIB 15933 utf8_printf(p->out, "zlib version %s\n", zlibVersion()); 15934 #endif 15935 #define CTIMEOPT_VAL_(opt) #opt 15936 #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) 15937 #if defined(__clang__) && defined(__clang_major__) 15938 utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "." 15939 CTIMEOPT_VAL(__clang_minor__) "." 15940 CTIMEOPT_VAL(__clang_patchlevel__) "\n"); 15941 #elif defined(_MSC_VER) 15942 utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) "\n"); 15943 #elif defined(__GNUC__) && defined(__VERSION__) 15944 utf8_printf(p->out, "gcc-" __VERSION__ "\n"); 15945 #endif 15946 }else 15947 15948 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){ 15949 const char *zDbName = nArg==2 ? azArg[1] : "main"; 15950 sqlite3_vfs *pVfs = 0; 15951 if( p->db ){ 15952 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs); 15953 if( pVfs ){ 15954 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName); 15955 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 15956 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 15957 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 15958 } 15959 } 15960 }else 15961 15962 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){ 15963 sqlite3_vfs *pVfs; 15964 sqlite3_vfs *pCurrent = 0; 15965 if( p->db ){ 15966 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent); 15967 } 15968 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){ 15969 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName, 15970 pVfs==pCurrent ? " <--- CURRENT" : ""); 15971 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 15972 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 15973 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 15974 if( pVfs->pNext ){ 15975 raw_printf(p->out, "-----------------------------------\n"); 15976 } 15977 } 15978 }else 15979 15980 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){ 15981 const char *zDbName = nArg==2 ? azArg[1] : "main"; 15982 char *zVfsName = 0; 15983 if( p->db ){ 15984 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName); 15985 if( zVfsName ){ 15986 utf8_printf(p->out, "%s\n", zVfsName); 15987 sqlite3_free(zVfsName); 15988 } 15989 } 15990 }else 15991 15992 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 15993 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){ 15994 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff; 15995 }else 15996 #endif 15997 15998 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ 15999 int j; 16000 assert( nArg<=ArraySize(azArg) ); 16001 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){ 16002 p->colWidth[j-1] = (int)integerValue(azArg[j]); 16003 } 16004 }else 16005 16006 { 16007 utf8_printf(stderr, "Error: unknown command or invalid arguments: " 16008 " \"%s\". Enter \".help\" for help\n", azArg[0]); 16009 rc = 1; 16010 } 16011 16012 meta_command_exit: 16013 if( p->outCount ){ 16014 p->outCount--; 16015 if( p->outCount==0 ) output_reset(p); 16016 } 16017 return rc; 16018 } 16019 16020 /* 16021 ** Return TRUE if a semicolon occurs anywhere in the first N characters 16022 ** of string z[]. 16023 */ 16024 static int line_contains_semicolon(const char *z, int N){ 16025 int i; 16026 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; } 16027 return 0; 16028 } 16029 16030 /* 16031 ** Test to see if a line consists entirely of whitespace. 16032 */ 16033 static int _all_whitespace(const char *z){ 16034 for(; *z; z++){ 16035 if( IsSpace(z[0]) ) continue; 16036 if( *z=='/' && z[1]=='*' ){ 16037 z += 2; 16038 while( *z && (*z!='*' || z[1]!='/') ){ z++; } 16039 if( *z==0 ) return 0; 16040 z++; 16041 continue; 16042 } 16043 if( *z=='-' && z[1]=='-' ){ 16044 z += 2; 16045 while( *z && *z!='\n' ){ z++; } 16046 if( *z==0 ) return 1; 16047 continue; 16048 } 16049 return 0; 16050 } 16051 return 1; 16052 } 16053 16054 /* 16055 ** Return TRUE if the line typed in is an SQL command terminator other 16056 ** than a semi-colon. The SQL Server style "go" command is understood 16057 ** as is the Oracle "/". 16058 */ 16059 static int line_is_command_terminator(const char *zLine){ 16060 while( IsSpace(zLine[0]) ){ zLine++; }; 16061 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){ 16062 return 1; /* Oracle */ 16063 } 16064 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' 16065 && _all_whitespace(&zLine[2]) ){ 16066 return 1; /* SQL Server */ 16067 } 16068 return 0; 16069 } 16070 16071 /* 16072 ** We need a default sqlite3_complete() implementation to use in case 16073 ** the shell is compiled with SQLITE_OMIT_COMPLETE. The default assumes 16074 ** any arbitrary text is a complete SQL statement. This is not very 16075 ** user-friendly, but it does seem to work. 16076 */ 16077 #ifdef SQLITE_OMIT_COMPLETE 16078 #define sqlite3_complete(x) 1 16079 #endif 16080 16081 /* 16082 ** Return true if zSql is a complete SQL statement. Return false if it 16083 ** ends in the middle of a string literal or C-style comment. 16084 */ 16085 static int line_is_complete(char *zSql, int nSql){ 16086 int rc; 16087 if( zSql==0 ) return 1; 16088 zSql[nSql] = ';'; 16089 zSql[nSql+1] = 0; 16090 rc = sqlite3_complete(zSql); 16091 zSql[nSql] = 0; 16092 return rc; 16093 } 16094 16095 /* 16096 ** Run a single line of SQL. Return the number of errors. 16097 */ 16098 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){ 16099 int rc; 16100 char *zErrMsg = 0; 16101 16102 open_db(p, 0); 16103 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql); 16104 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 16105 BEGIN_TIMER; 16106 rc = shell_exec(p, zSql, &zErrMsg); 16107 END_TIMER; 16108 if( rc || zErrMsg ){ 16109 char zPrefix[100]; 16110 if( in!=0 || !stdin_is_interactive ){ 16111 sqlite3_snprintf(sizeof(zPrefix), zPrefix, 16112 "Error: near line %d:", startline); 16113 }else{ 16114 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); 16115 } 16116 if( zErrMsg!=0 ){ 16117 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg); 16118 sqlite3_free(zErrMsg); 16119 zErrMsg = 0; 16120 }else{ 16121 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); 16122 } 16123 return 1; 16124 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){ 16125 raw_printf(p->out, "changes: %3d total_changes: %d\n", 16126 sqlite3_changes(p->db), sqlite3_total_changes(p->db)); 16127 } 16128 return 0; 16129 } 16130 16131 16132 /* 16133 ** Read input from *in and process it. If *in==0 then input 16134 ** is interactive - the user is typing it it. Otherwise, input 16135 ** is coming from a file or device. A prompt is issued and history 16136 ** is saved only if input is interactive. An interrupt signal will 16137 ** cause this routine to exit immediately, unless input is interactive. 16138 ** 16139 ** Return the number of errors. 16140 */ 16141 static int process_input(ShellState *p){ 16142 char *zLine = 0; /* A single input line */ 16143 char *zSql = 0; /* Accumulated SQL text */ 16144 int nLine; /* Length of current line */ 16145 int nSql = 0; /* Bytes of zSql[] used */ 16146 int nAlloc = 0; /* Allocated zSql[] space */ 16147 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */ 16148 int rc; /* Error code */ 16149 int errCnt = 0; /* Number of errors seen */ 16150 int startline = 0; /* Line number for start of current input */ 16151 16152 p->lineno = 0; 16153 while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){ 16154 fflush(p->out); 16155 zLine = one_input_line(p->in, zLine, nSql>0); 16156 if( zLine==0 ){ 16157 /* End of input */ 16158 if( p->in==0 && stdin_is_interactive ) printf("\n"); 16159 break; 16160 } 16161 if( seenInterrupt ){ 16162 if( p->in!=0 ) break; 16163 seenInterrupt = 0; 16164 } 16165 p->lineno++; 16166 if( nSql==0 && _all_whitespace(zLine) ){ 16167 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 16168 continue; 16169 } 16170 if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){ 16171 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 16172 if( zLine[0]=='.' ){ 16173 rc = do_meta_command(zLine, p); 16174 if( rc==2 ){ /* exit requested */ 16175 break; 16176 }else if( rc ){ 16177 errCnt++; 16178 } 16179 } 16180 continue; 16181 } 16182 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){ 16183 memcpy(zLine,";",2); 16184 } 16185 nLine = strlen30(zLine); 16186 if( nSql+nLine+2>=nAlloc ){ 16187 nAlloc = nSql+nLine+100; 16188 zSql = realloc(zSql, nAlloc); 16189 if( zSql==0 ) shell_out_of_memory(); 16190 } 16191 nSqlPrior = nSql; 16192 if( nSql==0 ){ 16193 int i; 16194 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){} 16195 assert( nAlloc>0 && zSql!=0 ); 16196 memcpy(zSql, zLine+i, nLine+1-i); 16197 startline = p->lineno; 16198 nSql = nLine-i; 16199 }else{ 16200 zSql[nSql++] = '\n'; 16201 memcpy(zSql+nSql, zLine, nLine+1); 16202 nSql += nLine; 16203 } 16204 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) 16205 && sqlite3_complete(zSql) ){ 16206 errCnt += runOneSqlLine(p, zSql, p->in, startline); 16207 nSql = 0; 16208 if( p->outCount ){ 16209 output_reset(p); 16210 p->outCount = 0; 16211 }else{ 16212 clearTempFile(p); 16213 } 16214 }else if( nSql && _all_whitespace(zSql) ){ 16215 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql); 16216 nSql = 0; 16217 } 16218 } 16219 if( nSql && !_all_whitespace(zSql) ){ 16220 errCnt += runOneSqlLine(p, zSql, p->in, startline); 16221 } 16222 free(zSql); 16223 free(zLine); 16224 return errCnt>0; 16225 } 16226 16227 /* 16228 ** Return a pathname which is the user's home directory. A 16229 ** 0 return indicates an error of some kind. 16230 */ 16231 static char *find_home_dir(int clearFlag){ 16232 static char *home_dir = NULL; 16233 if( clearFlag ){ 16234 free(home_dir); 16235 home_dir = 0; 16236 return 0; 16237 } 16238 if( home_dir ) return home_dir; 16239 16240 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \ 16241 && !defined(__RTP__) && !defined(_WRS_KERNEL) 16242 { 16243 struct passwd *pwent; 16244 uid_t uid = getuid(); 16245 if( (pwent=getpwuid(uid)) != NULL) { 16246 home_dir = pwent->pw_dir; 16247 } 16248 } 16249 #endif 16250 16251 #if defined(_WIN32_WCE) 16252 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() 16253 */ 16254 home_dir = "/"; 16255 #else 16256 16257 #if defined(_WIN32) || defined(WIN32) 16258 if (!home_dir) { 16259 home_dir = getenv("USERPROFILE"); 16260 } 16261 #endif 16262 16263 if (!home_dir) { 16264 home_dir = getenv("HOME"); 16265 } 16266 16267 #if defined(_WIN32) || defined(WIN32) 16268 if (!home_dir) { 16269 char *zDrive, *zPath; 16270 int n; 16271 zDrive = getenv("HOMEDRIVE"); 16272 zPath = getenv("HOMEPATH"); 16273 if( zDrive && zPath ){ 16274 n = strlen30(zDrive) + strlen30(zPath) + 1; 16275 home_dir = malloc( n ); 16276 if( home_dir==0 ) return 0; 16277 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); 16278 return home_dir; 16279 } 16280 home_dir = "c:\\"; 16281 } 16282 #endif 16283 16284 #endif /* !_WIN32_WCE */ 16285 16286 if( home_dir ){ 16287 int n = strlen30(home_dir) + 1; 16288 char *z = malloc( n ); 16289 if( z ) memcpy(z, home_dir, n); 16290 home_dir = z; 16291 } 16292 16293 return home_dir; 16294 } 16295 16296 /* 16297 ** Read input from the file given by sqliterc_override. Or if that 16298 ** parameter is NULL, take input from ~/.sqliterc 16299 ** 16300 ** Returns the number of errors. 16301 */ 16302 static void process_sqliterc( 16303 ShellState *p, /* Configuration data */ 16304 const char *sqliterc_override /* Name of config file. NULL to use default */ 16305 ){ 16306 char *home_dir = NULL; 16307 const char *sqliterc = sqliterc_override; 16308 char *zBuf = 0; 16309 FILE *inSaved = p->in; 16310 int savedLineno = p->lineno; 16311 16312 if (sqliterc == NULL) { 16313 home_dir = find_home_dir(0); 16314 if( home_dir==0 ){ 16315 raw_printf(stderr, "-- warning: cannot find home directory;" 16316 " cannot read ~/.sqliterc\n"); 16317 return; 16318 } 16319 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir); 16320 sqliterc = zBuf; 16321 } 16322 p->in = fopen(sqliterc,"rb"); 16323 if( p->in ){ 16324 if( stdin_is_interactive ){ 16325 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc); 16326 } 16327 process_input(p); 16328 fclose(p->in); 16329 } 16330 p->in = inSaved; 16331 p->lineno = savedLineno; 16332 sqlite3_free(zBuf); 16333 } 16334 16335 /* 16336 ** Show available command line options 16337 */ 16338 static const char zOptions[] = 16339 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 16340 " -A ARGS... run \".archive ARGS\" and exit\n" 16341 #endif 16342 " -append append the database to the end of the file\n" 16343 " -ascii set output mode to 'ascii'\n" 16344 " -bail stop after hitting an error\n" 16345 " -batch force batch I/O\n" 16346 " -column set output mode to 'column'\n" 16347 " -cmd COMMAND run \"COMMAND\" before reading stdin\n" 16348 " -csv set output mode to 'csv'\n" 16349 #if defined(SQLITE_ENABLE_DESERIALIZE) 16350 " -deserialize open the database using sqlite3_deserialize()\n" 16351 #endif 16352 " -echo print commands before execution\n" 16353 " -init FILENAME read/process named file\n" 16354 " -[no]header turn headers on or off\n" 16355 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 16356 " -heap SIZE Size of heap for memsys3 or memsys5\n" 16357 #endif 16358 " -help show this message\n" 16359 " -html set output mode to HTML\n" 16360 " -interactive force interactive I/O\n" 16361 " -line set output mode to 'line'\n" 16362 " -list set output mode to 'list'\n" 16363 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n" 16364 #if defined(SQLITE_ENABLE_DESERIALIZE) 16365 " -maxsize N maximum size for a --deserialize database\n" 16366 #endif 16367 " -memtrace trace all memory allocations and deallocations\n" 16368 " -mmap N default mmap size set to N\n" 16369 #ifdef SQLITE_ENABLE_MULTIPLEX 16370 " -multiplex enable the multiplexor VFS\n" 16371 #endif 16372 " -newline SEP set output row separator. Default: '\\n'\n" 16373 " -nullvalue TEXT set text string for NULL values. Default ''\n" 16374 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n" 16375 " -quote set output mode to 'quote'\n" 16376 " -readonly open the database read-only\n" 16377 " -separator SEP set output column separator. Default: '|'\n" 16378 #ifdef SQLITE_ENABLE_SORTER_REFERENCES 16379 " -sorterref SIZE sorter references threshold size\n" 16380 #endif 16381 " -stats print memory stats before each finalize\n" 16382 " -version show SQLite version\n" 16383 " -vfs NAME use NAME as the default VFS\n" 16384 #ifdef SQLITE_ENABLE_VFSTRACE 16385 " -vfstrace enable tracing of all VFS calls\n" 16386 #endif 16387 #ifdef SQLITE_HAVE_ZLIB 16388 " -zip open the file as a ZIP Archive\n" 16389 #endif 16390 ; 16391 static void usage(int showDetail){ 16392 utf8_printf(stderr, 16393 "Usage: %s [OPTIONS] FILENAME [SQL]\n" 16394 "FILENAME is the name of an SQLite database. A new database is created\n" 16395 "if the file does not previously exist.\n", Argv0); 16396 if( showDetail ){ 16397 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions); 16398 }else{ 16399 raw_printf(stderr, "Use the -help option for additional information\n"); 16400 } 16401 exit(1); 16402 } 16403 16404 /* 16405 ** Internal check: Verify that the SQLite is uninitialized. Print a 16406 ** error message if it is initialized. 16407 */ 16408 static void verify_uninitialized(void){ 16409 if( sqlite3_config(-1)==SQLITE_MISUSE ){ 16410 utf8_printf(stdout, "WARNING: attempt to configure SQLite after" 16411 " initialization.\n"); 16412 } 16413 } 16414 16415 /* 16416 ** Initialize the state information in data 16417 */ 16418 static void main_init(ShellState *data) { 16419 memset(data, 0, sizeof(*data)); 16420 data->normalMode = data->cMode = data->mode = MODE_List; 16421 data->autoExplain = 1; 16422 memcpy(data->colSeparator,SEP_Column, 2); 16423 memcpy(data->rowSeparator,SEP_Row, 2); 16424 data->showHeader = 0; 16425 data->shellFlgs = SHFLG_Lookaside; 16426 verify_uninitialized(); 16427 sqlite3_config(SQLITE_CONFIG_URI, 1); 16428 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); 16429 sqlite3_config(SQLITE_CONFIG_MULTITHREAD); 16430 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); 16431 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); 16432 } 16433 16434 /* 16435 ** Output text to the console in a font that attracts extra attention. 16436 */ 16437 #ifdef _WIN32 16438 static void printBold(const char *zText){ 16439 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); 16440 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo; 16441 GetConsoleScreenBufferInfo(out, &defaultScreenInfo); 16442 SetConsoleTextAttribute(out, 16443 FOREGROUND_RED|FOREGROUND_INTENSITY 16444 ); 16445 printf("%s", zText); 16446 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes); 16447 } 16448 #else 16449 static void printBold(const char *zText){ 16450 printf("\033[1m%s\033[0m", zText); 16451 } 16452 #endif 16453 16454 /* 16455 ** Get the argument to an --option. Throw an error and die if no argument 16456 ** is available. 16457 */ 16458 static char *cmdline_option_value(int argc, char **argv, int i){ 16459 if( i==argc ){ 16460 utf8_printf(stderr, "%s: Error: missing argument to %s\n", 16461 argv[0], argv[argc-1]); 16462 exit(1); 16463 } 16464 return argv[i]; 16465 } 16466 16467 #ifndef SQLITE_SHELL_IS_UTF8 16468 # if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER) 16469 # define SQLITE_SHELL_IS_UTF8 (0) 16470 # else 16471 # define SQLITE_SHELL_IS_UTF8 (1) 16472 # endif 16473 #endif 16474 16475 #if SQLITE_SHELL_IS_UTF8 16476 int SQLITE_CDECL main(int argc, char **argv){ 16477 #else 16478 int SQLITE_CDECL wmain(int argc, wchar_t **wargv){ 16479 char **argv; 16480 #endif 16481 char *zErrMsg = 0; 16482 ShellState data; 16483 const char *zInitFile = 0; 16484 int i; 16485 int rc = 0; 16486 int warnInmemoryDb = 0; 16487 int readStdin = 1; 16488 int nCmd = 0; 16489 char **azCmd = 0; 16490 const char *zVfs = 0; /* Value of -vfs command-line option */ 16491 #if !SQLITE_SHELL_IS_UTF8 16492 char **argvToFree = 0; 16493 int argcToFree = 0; 16494 #endif 16495 16496 setBinaryMode(stdin, 0); 16497 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */ 16498 stdin_is_interactive = isatty(0); 16499 stdout_is_console = isatty(1); 16500 16501 #if !defined(_WIN32_WCE) 16502 if( getenv("SQLITE_DEBUG_BREAK") ){ 16503 if( isatty(0) && isatty(2) ){ 16504 fprintf(stderr, 16505 "attach debugger to process %d and press any key to continue.\n", 16506 GETPID()); 16507 fgetc(stdin); 16508 }else{ 16509 #if defined(_WIN32) || defined(WIN32) 16510 DebugBreak(); 16511 #elif defined(SIGTRAP) 16512 raise(SIGTRAP); 16513 #endif 16514 } 16515 } 16516 #endif 16517 16518 #if USE_SYSTEM_SQLITE+0!=1 16519 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){ 16520 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n", 16521 sqlite3_sourceid(), SQLITE_SOURCE_ID); 16522 exit(1); 16523 } 16524 #endif 16525 main_init(&data); 16526 16527 /* On Windows, we must translate command-line arguments into UTF-8. 16528 ** The SQLite memory allocator subsystem has to be enabled in order to 16529 ** do this. But we want to run an sqlite3_shutdown() afterwards so that 16530 ** subsequent sqlite3_config() calls will work. So copy all results into 16531 ** memory that does not come from the SQLite memory allocator. 16532 */ 16533 #if !SQLITE_SHELL_IS_UTF8 16534 sqlite3_initialize(); 16535 argvToFree = malloc(sizeof(argv[0])*argc*2); 16536 argcToFree = argc; 16537 argv = argvToFree + argc; 16538 if( argv==0 ) shell_out_of_memory(); 16539 for(i=0; i<argc; i++){ 16540 char *z = sqlite3_win32_unicode_to_utf8(wargv[i]); 16541 int n; 16542 if( z==0 ) shell_out_of_memory(); 16543 n = (int)strlen(z); 16544 argv[i] = malloc( n+1 ); 16545 if( argv[i]==0 ) shell_out_of_memory(); 16546 memcpy(argv[i], z, n+1); 16547 argvToFree[i] = argv[i]; 16548 sqlite3_free(z); 16549 } 16550 sqlite3_shutdown(); 16551 #endif 16552 16553 assert( argc>=1 && argv && argv[0] ); 16554 Argv0 = argv[0]; 16555 16556 /* Make sure we have a valid signal handler early, before anything 16557 ** else is done. 16558 */ 16559 #ifdef SIGINT 16560 signal(SIGINT, interrupt_handler); 16561 #elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 16562 SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE); 16563 #endif 16564 16565 #ifdef SQLITE_SHELL_DBNAME_PROC 16566 { 16567 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name 16568 ** of a C-function that will provide the name of the database file. Use 16569 ** this compile-time option to embed this shell program in larger 16570 ** applications. */ 16571 extern void SQLITE_SHELL_DBNAME_PROC(const char**); 16572 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename); 16573 warnInmemoryDb = 0; 16574 } 16575 #endif 16576 16577 /* Do an initial pass through the command-line argument to locate 16578 ** the name of the database file, the name of the initialization file, 16579 ** the size of the alternative malloc heap, 16580 ** and the first command to execute. 16581 */ 16582 verify_uninitialized(); 16583 for(i=1; i<argc; i++){ 16584 char *z; 16585 z = argv[i]; 16586 if( z[0]!='-' ){ 16587 if( data.zDbFilename==0 ){ 16588 data.zDbFilename = z; 16589 }else{ 16590 /* Excesss arguments are interpreted as SQL (or dot-commands) and 16591 ** mean that nothing is read from stdin */ 16592 readStdin = 0; 16593 nCmd++; 16594 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd); 16595 if( azCmd==0 ) shell_out_of_memory(); 16596 azCmd[nCmd-1] = z; 16597 } 16598 } 16599 if( z[1]=='-' ) z++; 16600 if( strcmp(z,"-separator")==0 16601 || strcmp(z,"-nullvalue")==0 16602 || strcmp(z,"-newline")==0 16603 || strcmp(z,"-cmd")==0 16604 ){ 16605 (void)cmdline_option_value(argc, argv, ++i); 16606 }else if( strcmp(z,"-init")==0 ){ 16607 zInitFile = cmdline_option_value(argc, argv, ++i); 16608 }else if( strcmp(z,"-batch")==0 ){ 16609 /* Need to check for batch mode here to so we can avoid printing 16610 ** informational messages (like from process_sqliterc) before 16611 ** we do the actual processing of arguments later in a second pass. 16612 */ 16613 stdin_is_interactive = 0; 16614 }else if( strcmp(z,"-heap")==0 ){ 16615 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 16616 const char *zSize; 16617 sqlite3_int64 szHeap; 16618 16619 zSize = cmdline_option_value(argc, argv, ++i); 16620 szHeap = integerValue(zSize); 16621 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000; 16622 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64); 16623 #else 16624 (void)cmdline_option_value(argc, argv, ++i); 16625 #endif 16626 }else if( strcmp(z,"-pagecache")==0 ){ 16627 int n, sz; 16628 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 16629 if( sz>70000 ) sz = 70000; 16630 if( sz<0 ) sz = 0; 16631 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 16632 sqlite3_config(SQLITE_CONFIG_PAGECACHE, 16633 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n); 16634 data.shellFlgs |= SHFLG_Pagecache; 16635 }else if( strcmp(z,"-lookaside")==0 ){ 16636 int n, sz; 16637 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 16638 if( sz<0 ) sz = 0; 16639 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 16640 if( n<0 ) n = 0; 16641 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n); 16642 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside; 16643 #ifdef SQLITE_ENABLE_VFSTRACE 16644 }else if( strcmp(z,"-vfstrace")==0 ){ 16645 extern int vfstrace_register( 16646 const char *zTraceName, 16647 const char *zOldVfsName, 16648 int (*xOut)(const char*,void*), 16649 void *pOutArg, 16650 int makeDefault 16651 ); 16652 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1); 16653 #endif 16654 #ifdef SQLITE_ENABLE_MULTIPLEX 16655 }else if( strcmp(z,"-multiplex")==0 ){ 16656 extern int sqlite3_multiple_initialize(const char*,int); 16657 sqlite3_multiplex_initialize(0, 1); 16658 #endif 16659 }else if( strcmp(z,"-mmap")==0 ){ 16660 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 16661 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz); 16662 #ifdef SQLITE_ENABLE_SORTER_REFERENCES 16663 }else if( strcmp(z,"-sorterref")==0 ){ 16664 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 16665 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz); 16666 #endif 16667 }else if( strcmp(z,"-vfs")==0 ){ 16668 zVfs = cmdline_option_value(argc, argv, ++i); 16669 #ifdef SQLITE_HAVE_ZLIB 16670 }else if( strcmp(z,"-zip")==0 ){ 16671 data.openMode = SHELL_OPEN_ZIPFILE; 16672 #endif 16673 }else if( strcmp(z,"-append")==0 ){ 16674 data.openMode = SHELL_OPEN_APPENDVFS; 16675 #ifdef SQLITE_ENABLE_DESERIALIZE 16676 }else if( strcmp(z,"-deserialize")==0 ){ 16677 data.openMode = SHELL_OPEN_DESERIALIZE; 16678 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 16679 data.szMax = integerValue(argv[++i]); 16680 #endif 16681 }else if( strcmp(z,"-readonly")==0 ){ 16682 data.openMode = SHELL_OPEN_READONLY; 16683 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 16684 }else if( strncmp(z, "-A",2)==0 ){ 16685 /* All remaining command-line arguments are passed to the ".archive" 16686 ** command, so ignore them */ 16687 break; 16688 #endif 16689 }else if( strcmp(z, "-memtrace")==0 ){ 16690 sqlite3MemTraceActivate(stderr); 16691 } 16692 } 16693 verify_uninitialized(); 16694 16695 16696 #ifdef SQLITE_SHELL_INIT_PROC 16697 { 16698 /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name 16699 ** of a C-function that will perform initialization actions on SQLite that 16700 ** occur just before or after sqlite3_initialize(). Use this compile-time 16701 ** option to embed this shell program in larger applications. */ 16702 extern void SQLITE_SHELL_INIT_PROC(void); 16703 SQLITE_SHELL_INIT_PROC(); 16704 } 16705 #else 16706 /* All the sqlite3_config() calls have now been made. So it is safe 16707 ** to call sqlite3_initialize() and process any command line -vfs option. */ 16708 sqlite3_initialize(); 16709 #endif 16710 16711 if( zVfs ){ 16712 sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs); 16713 if( pVfs ){ 16714 sqlite3_vfs_register(pVfs, 1); 16715 }else{ 16716 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]); 16717 exit(1); 16718 } 16719 } 16720 16721 if( data.zDbFilename==0 ){ 16722 #ifndef SQLITE_OMIT_MEMORYDB 16723 data.zDbFilename = ":memory:"; 16724 warnInmemoryDb = argc==1; 16725 #else 16726 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0); 16727 return 1; 16728 #endif 16729 } 16730 data.out = stdout; 16731 sqlite3_appendvfs_init(0,0,0); 16732 16733 /* Go ahead and open the database file if it already exists. If the 16734 ** file does not exist, delay opening it. This prevents empty database 16735 ** files from being created if a user mistypes the database name argument 16736 ** to the sqlite command-line tool. 16737 */ 16738 if( access(data.zDbFilename, 0)==0 ){ 16739 open_db(&data, 0); 16740 } 16741 16742 /* Process the initialization file if there is one. If no -init option 16743 ** is given on the command line, look for a file named ~/.sqliterc and 16744 ** try to process it. 16745 */ 16746 process_sqliterc(&data,zInitFile); 16747 16748 /* Make a second pass through the command-line argument and set 16749 ** options. This second pass is delayed until after the initialization 16750 ** file is processed so that the command-line arguments will override 16751 ** settings in the initialization file. 16752 */ 16753 for(i=1; i<argc; i++){ 16754 char *z = argv[i]; 16755 if( z[0]!='-' ) continue; 16756 if( z[1]=='-' ){ z++; } 16757 if( strcmp(z,"-init")==0 ){ 16758 i++; 16759 }else if( strcmp(z,"-html")==0 ){ 16760 data.mode = MODE_Html; 16761 }else if( strcmp(z,"-list")==0 ){ 16762 data.mode = MODE_List; 16763 }else if( strcmp(z,"-quote")==0 ){ 16764 data.mode = MODE_Quote; 16765 }else if( strcmp(z,"-line")==0 ){ 16766 data.mode = MODE_Line; 16767 }else if( strcmp(z,"-column")==0 ){ 16768 data.mode = MODE_Column; 16769 }else if( strcmp(z,"-csv")==0 ){ 16770 data.mode = MODE_Csv; 16771 memcpy(data.colSeparator,",",2); 16772 #ifdef SQLITE_HAVE_ZLIB 16773 }else if( strcmp(z,"-zip")==0 ){ 16774 data.openMode = SHELL_OPEN_ZIPFILE; 16775 #endif 16776 }else if( strcmp(z,"-append")==0 ){ 16777 data.openMode = SHELL_OPEN_APPENDVFS; 16778 #ifdef SQLITE_ENABLE_DESERIALIZE 16779 }else if( strcmp(z,"-deserialize")==0 ){ 16780 data.openMode = SHELL_OPEN_DESERIALIZE; 16781 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 16782 data.szMax = integerValue(argv[++i]); 16783 #endif 16784 }else if( strcmp(z,"-readonly")==0 ){ 16785 data.openMode = SHELL_OPEN_READONLY; 16786 }else if( strcmp(z,"-ascii")==0 ){ 16787 data.mode = MODE_Ascii; 16788 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 16789 SEP_Unit); 16790 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 16791 SEP_Record); 16792 }else if( strcmp(z,"-separator")==0 ){ 16793 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 16794 "%s",cmdline_option_value(argc,argv,++i)); 16795 }else if( strcmp(z,"-newline")==0 ){ 16796 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 16797 "%s",cmdline_option_value(argc,argv,++i)); 16798 }else if( strcmp(z,"-nullvalue")==0 ){ 16799 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue, 16800 "%s",cmdline_option_value(argc,argv,++i)); 16801 }else if( strcmp(z,"-header")==0 ){ 16802 data.showHeader = 1; 16803 }else if( strcmp(z,"-noheader")==0 ){ 16804 data.showHeader = 0; 16805 }else if( strcmp(z,"-echo")==0 ){ 16806 ShellSetFlag(&data, SHFLG_Echo); 16807 }else if( strcmp(z,"-eqp")==0 ){ 16808 data.autoEQP = AUTOEQP_on; 16809 }else if( strcmp(z,"-eqpfull")==0 ){ 16810 data.autoEQP = AUTOEQP_full; 16811 }else if( strcmp(z,"-stats")==0 ){ 16812 data.statsOn = 1; 16813 }else if( strcmp(z,"-scanstats")==0 ){ 16814 data.scanstatsOn = 1; 16815 }else if( strcmp(z,"-backslash")==0 ){ 16816 /* Undocumented command-line option: -backslash 16817 ** Causes C-style backslash escapes to be evaluated in SQL statements 16818 ** prior to sending the SQL into SQLite. Useful for injecting 16819 ** crazy bytes in the middle of SQL statements for testing and debugging. 16820 */ 16821 ShellSetFlag(&data, SHFLG_Backslash); 16822 }else if( strcmp(z,"-bail")==0 ){ 16823 bail_on_error = 1; 16824 }else if( strcmp(z,"-version")==0 ){ 16825 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid()); 16826 return 0; 16827 }else if( strcmp(z,"-interactive")==0 ){ 16828 stdin_is_interactive = 1; 16829 }else if( strcmp(z,"-batch")==0 ){ 16830 stdin_is_interactive = 0; 16831 }else if( strcmp(z,"-heap")==0 ){ 16832 i++; 16833 }else if( strcmp(z,"-pagecache")==0 ){ 16834 i+=2; 16835 }else if( strcmp(z,"-lookaside")==0 ){ 16836 i+=2; 16837 }else if( strcmp(z,"-mmap")==0 ){ 16838 i++; 16839 }else if( strcmp(z,"-memtrace")==0 ){ 16840 i++; 16841 #ifdef SQLITE_ENABLE_SORTER_REFERENCES 16842 }else if( strcmp(z,"-sorterref")==0 ){ 16843 i++; 16844 #endif 16845 }else if( strcmp(z,"-vfs")==0 ){ 16846 i++; 16847 #ifdef SQLITE_ENABLE_VFSTRACE 16848 }else if( strcmp(z,"-vfstrace")==0 ){ 16849 i++; 16850 #endif 16851 #ifdef SQLITE_ENABLE_MULTIPLEX 16852 }else if( strcmp(z,"-multiplex")==0 ){ 16853 i++; 16854 #endif 16855 }else if( strcmp(z,"-help")==0 ){ 16856 usage(1); 16857 }else if( strcmp(z,"-cmd")==0 ){ 16858 /* Run commands that follow -cmd first and separately from commands 16859 ** that simply appear on the command-line. This seems goofy. It would 16860 ** be better if all commands ran in the order that they appear. But 16861 ** we retain the goofy behavior for historical compatibility. */ 16862 if( i==argc-1 ) break; 16863 z = cmdline_option_value(argc,argv,++i); 16864 if( z[0]=='.' ){ 16865 rc = do_meta_command(z, &data); 16866 if( rc && bail_on_error ) return rc==2 ? 0 : rc; 16867 }else{ 16868 open_db(&data, 0); 16869 rc = shell_exec(&data, z, &zErrMsg); 16870 if( zErrMsg!=0 ){ 16871 utf8_printf(stderr,"Error: %s\n", zErrMsg); 16872 if( bail_on_error ) return rc!=0 ? rc : 1; 16873 }else if( rc!=0 ){ 16874 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z); 16875 if( bail_on_error ) return rc; 16876 } 16877 } 16878 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 16879 }else if( strncmp(z, "-A", 2)==0 ){ 16880 if( nCmd>0 ){ 16881 utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands" 16882 " with \"%s\"\n", z); 16883 return 1; 16884 } 16885 open_db(&data, OPEN_DB_ZIPFILE); 16886 if( z[2] ){ 16887 argv[i] = &z[2]; 16888 arDotCommand(&data, 1, argv+(i-1), argc-(i-1)); 16889 }else{ 16890 arDotCommand(&data, 1, argv+i, argc-i); 16891 } 16892 readStdin = 0; 16893 break; 16894 #endif 16895 }else{ 16896 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z); 16897 raw_printf(stderr,"Use -help for a list of options.\n"); 16898 return 1; 16899 } 16900 data.cMode = data.mode; 16901 } 16902 16903 if( !readStdin ){ 16904 /* Run all arguments that do not begin with '-' as if they were separate 16905 ** command-line inputs, except for the argToSkip argument which contains 16906 ** the database filename. 16907 */ 16908 for(i=0; i<nCmd; i++){ 16909 if( azCmd[i][0]=='.' ){ 16910 rc = do_meta_command(azCmd[i], &data); 16911 if( rc ) return rc==2 ? 0 : rc; 16912 }else{ 16913 open_db(&data, 0); 16914 rc = shell_exec(&data, azCmd[i], &zErrMsg); 16915 if( zErrMsg!=0 ){ 16916 utf8_printf(stderr,"Error: %s\n", zErrMsg); 16917 return rc!=0 ? rc : 1; 16918 }else if( rc!=0 ){ 16919 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]); 16920 return rc; 16921 } 16922 } 16923 } 16924 free(azCmd); 16925 }else{ 16926 /* Run commands received from standard input 16927 */ 16928 if( stdin_is_interactive ){ 16929 char *zHome; 16930 char *zHistory; 16931 int nHistory; 16932 printf( 16933 "SQLite version %s %.19s\n" /*extra-version-info*/ 16934 "Enter \".help\" for usage hints.\n", 16935 sqlite3_libversion(), sqlite3_sourceid() 16936 ); 16937 if( warnInmemoryDb ){ 16938 printf("Connected to a "); 16939 printBold("transient in-memory database"); 16940 printf(".\nUse \".open FILENAME\" to reopen on a " 16941 "persistent database.\n"); 16942 } 16943 zHistory = getenv("SQLITE_HISTORY"); 16944 if( zHistory ){ 16945 zHistory = strdup(zHistory); 16946 }else if( (zHome = find_home_dir(0))!=0 ){ 16947 nHistory = strlen30(zHome) + 20; 16948 if( (zHistory = malloc(nHistory))!=0 ){ 16949 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome); 16950 } 16951 } 16952 if( zHistory ){ shell_read_history(zHistory); } 16953 #if HAVE_READLINE || HAVE_EDITLINE 16954 rl_attempted_completion_function = readline_completion; 16955 #elif HAVE_LINENOISE 16956 linenoiseSetCompletionCallback(linenoise_completion); 16957 #endif 16958 data.in = 0; 16959 rc = process_input(&data); 16960 if( zHistory ){ 16961 shell_stifle_history(2000); 16962 shell_write_history(zHistory); 16963 free(zHistory); 16964 } 16965 }else{ 16966 data.in = stdin; 16967 rc = process_input(&data); 16968 } 16969 } 16970 set_table_name(&data, 0); 16971 if( data.db ){ 16972 session_close_all(&data); 16973 close_db(data.db); 16974 } 16975 sqlite3_free(data.zFreeOnClose); 16976 find_home_dir(1); 16977 output_reset(&data); 16978 data.doXdgOpen = 0; 16979 clearTempFile(&data); 16980 #if !SQLITE_SHELL_IS_UTF8 16981 for(i=0; i<argcToFree; i++) free(argvToFree[i]); 16982 free(argvToFree); 16983 #endif 16984 /* Clear the global data structure so that valgrind will detect memory 16985 ** leaks */ 16986 memset(&data, 0, sizeof(data)); 16987 return rc; 16988 } 16989