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 /* #include "sqlite3.h" */ 987 988 /* 989 ** We need several things from the ANSI and MSVCRT headers. 990 */ 991 992 #include <stdio.h> 993 #include <stdlib.h> 994 #include <errno.h> 995 #include <io.h> 996 #include <limits.h> 997 #include <sys/types.h> 998 #include <sys/stat.h> 999 1000 /* 1001 ** We may need several defines that should have been in "sys/stat.h". 1002 */ 1003 1004 #ifndef S_ISREG 1005 #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) 1006 #endif 1007 1008 #ifndef S_ISDIR 1009 #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) 1010 #endif 1011 1012 #ifndef S_ISLNK 1013 #define S_ISLNK(mode) (0) 1014 #endif 1015 1016 /* 1017 ** We may need to provide the "mode_t" type. 1018 */ 1019 1020 #ifndef MODE_T_DEFINED 1021 #define MODE_T_DEFINED 1022 typedef unsigned short mode_t; 1023 #endif 1024 1025 /* 1026 ** We may need to provide the "ino_t" type. 1027 */ 1028 1029 #ifndef INO_T_DEFINED 1030 #define INO_T_DEFINED 1031 typedef unsigned short ino_t; 1032 #endif 1033 1034 /* 1035 ** We need to define "NAME_MAX" if it was not present in "limits.h". 1036 */ 1037 1038 #ifndef NAME_MAX 1039 # ifdef FILENAME_MAX 1040 # define NAME_MAX (FILENAME_MAX) 1041 # else 1042 # define NAME_MAX (260) 1043 # endif 1044 #endif 1045 1046 /* 1047 ** We need to define "NULL_INTPTR_T" and "BAD_INTPTR_T". 1048 */ 1049 1050 #ifndef NULL_INTPTR_T 1051 # define NULL_INTPTR_T ((intptr_t)(0)) 1052 #endif 1053 1054 #ifndef BAD_INTPTR_T 1055 # define BAD_INTPTR_T ((intptr_t)(-1)) 1056 #endif 1057 1058 /* 1059 ** We need to provide the necessary structures and related types. 1060 */ 1061 1062 #ifndef DIRENT_DEFINED 1063 #define DIRENT_DEFINED 1064 typedef struct DIRENT DIRENT; 1065 typedef DIRENT *LPDIRENT; 1066 struct DIRENT { 1067 ino_t d_ino; /* Sequence number, do not use. */ 1068 unsigned d_attributes; /* Win32 file attributes. */ 1069 char d_name[NAME_MAX + 1]; /* Name within the directory. */ 1070 }; 1071 #endif 1072 1073 #ifndef DIR_DEFINED 1074 #define DIR_DEFINED 1075 typedef struct DIR DIR; 1076 typedef DIR *LPDIR; 1077 struct DIR { 1078 intptr_t d_handle; /* Value returned by "_findfirst". */ 1079 DIRENT d_first; /* DIRENT constructed based on "_findfirst". */ 1080 DIRENT d_next; /* DIRENT constructed based on "_findnext". */ 1081 }; 1082 #endif 1083 1084 /* 1085 ** Provide a macro, for use by the implementation, to determine if a 1086 ** particular directory entry should be skipped over when searching for 1087 ** the next directory entry that should be returned by the readdir() or 1088 ** readdir_r() functions. 1089 */ 1090 1091 #ifndef is_filtered 1092 # define is_filtered(a) ((((a).attrib)&_A_HIDDEN) || (((a).attrib)&_A_SYSTEM)) 1093 #endif 1094 1095 /* 1096 ** Provide the function prototype for the POSIX compatiable getenv() 1097 ** function. This function is not thread-safe. 1098 */ 1099 1100 extern const char *windirent_getenv(const char *name); 1101 1102 /* 1103 ** Finally, we can provide the function prototypes for the opendir(), 1104 ** readdir(), readdir_r(), and closedir() POSIX functions. 1105 */ 1106 1107 extern LPDIR opendir(const char *dirname); 1108 extern LPDIRENT readdir(LPDIR dirp); 1109 extern INT readdir_r(LPDIR dirp, LPDIRENT entry, LPDIRENT *result); 1110 extern INT closedir(LPDIR dirp); 1111 1112 #endif /* defined(WIN32) && defined(_MSC_VER) */ 1113 1114 /************************* End test_windirent.h ********************/ 1115 /************************* Begin test_windirent.c ******************/ 1116 /* 1117 ** 2015 November 30 1118 ** 1119 ** The author disclaims copyright to this source code. In place of 1120 ** a legal notice, here is a blessing: 1121 ** 1122 ** May you do good and not evil. 1123 ** May you find forgiveness for yourself and forgive others. 1124 ** May you share freely, never taking more than you give. 1125 ** 1126 ************************************************************************* 1127 ** This file contains code to implement most of the opendir() family of 1128 ** POSIX functions on Win32 using the MSVCRT. 1129 */ 1130 1131 #if defined(_WIN32) && defined(_MSC_VER) 1132 /* #include "test_windirent.h" */ 1133 1134 /* 1135 ** Implementation of the POSIX getenv() function using the Win32 API. 1136 ** This function is not thread-safe. 1137 */ 1138 const char *windirent_getenv( 1139 const char *name 1140 ){ 1141 static char value[32768]; /* Maximum length, per MSDN */ 1142 DWORD dwSize = sizeof(value) / sizeof(char); /* Size in chars */ 1143 DWORD dwRet; /* Value returned by GetEnvironmentVariableA() */ 1144 1145 memset(value, 0, sizeof(value)); 1146 dwRet = GetEnvironmentVariableA(name, value, dwSize); 1147 if( dwRet==0 || dwRet>dwSize ){ 1148 /* 1149 ** The function call to GetEnvironmentVariableA() failed -OR- 1150 ** the buffer is not large enough. Either way, return NULL. 1151 */ 1152 return 0; 1153 }else{ 1154 /* 1155 ** The function call to GetEnvironmentVariableA() succeeded 1156 ** -AND- the buffer contains the entire value. 1157 */ 1158 return value; 1159 } 1160 } 1161 1162 /* 1163 ** Implementation of the POSIX opendir() function using the MSVCRT. 1164 */ 1165 LPDIR opendir( 1166 const char *dirname 1167 ){ 1168 struct _finddata_t data; 1169 LPDIR dirp = (LPDIR)sqlite3_malloc(sizeof(DIR)); 1170 SIZE_T namesize = sizeof(data.name) / sizeof(data.name[0]); 1171 1172 if( dirp==NULL ) return NULL; 1173 memset(dirp, 0, sizeof(DIR)); 1174 1175 /* TODO: Remove this if Unix-style root paths are not used. */ 1176 if( sqlite3_stricmp(dirname, "/")==0 ){ 1177 dirname = windirent_getenv("SystemDrive"); 1178 } 1179 1180 memset(&data, 0, sizeof(struct _finddata_t)); 1181 _snprintf(data.name, namesize, "%s\\*", dirname); 1182 dirp->d_handle = _findfirst(data.name, &data); 1183 1184 if( dirp->d_handle==BAD_INTPTR_T ){ 1185 closedir(dirp); 1186 return NULL; 1187 } 1188 1189 /* TODO: Remove this block to allow hidden and/or system files. */ 1190 if( is_filtered(data) ){ 1191 next: 1192 1193 memset(&data, 0, sizeof(struct _finddata_t)); 1194 if( _findnext(dirp->d_handle, &data)==-1 ){ 1195 closedir(dirp); 1196 return NULL; 1197 } 1198 1199 /* TODO: Remove this block to allow hidden and/or system files. */ 1200 if( is_filtered(data) ) goto next; 1201 } 1202 1203 dirp->d_first.d_attributes = data.attrib; 1204 strncpy(dirp->d_first.d_name, data.name, NAME_MAX); 1205 dirp->d_first.d_name[NAME_MAX] = '\0'; 1206 1207 return dirp; 1208 } 1209 1210 /* 1211 ** Implementation of the POSIX readdir() function using the MSVCRT. 1212 */ 1213 LPDIRENT readdir( 1214 LPDIR dirp 1215 ){ 1216 struct _finddata_t data; 1217 1218 if( dirp==NULL ) return NULL; 1219 1220 if( dirp->d_first.d_ino==0 ){ 1221 dirp->d_first.d_ino++; 1222 dirp->d_next.d_ino++; 1223 1224 return &dirp->d_first; 1225 } 1226 1227 next: 1228 1229 memset(&data, 0, sizeof(struct _finddata_t)); 1230 if( _findnext(dirp->d_handle, &data)==-1 ) return NULL; 1231 1232 /* TODO: Remove this block to allow hidden and/or system files. */ 1233 if( is_filtered(data) ) goto next; 1234 1235 dirp->d_next.d_ino++; 1236 dirp->d_next.d_attributes = data.attrib; 1237 strncpy(dirp->d_next.d_name, data.name, NAME_MAX); 1238 dirp->d_next.d_name[NAME_MAX] = '\0'; 1239 1240 return &dirp->d_next; 1241 } 1242 1243 /* 1244 ** Implementation of the POSIX readdir_r() function using the MSVCRT. 1245 */ 1246 INT readdir_r( 1247 LPDIR dirp, 1248 LPDIRENT entry, 1249 LPDIRENT *result 1250 ){ 1251 struct _finddata_t data; 1252 1253 if( dirp==NULL ) return EBADF; 1254 1255 if( dirp->d_first.d_ino==0 ){ 1256 dirp->d_first.d_ino++; 1257 dirp->d_next.d_ino++; 1258 1259 entry->d_ino = dirp->d_first.d_ino; 1260 entry->d_attributes = dirp->d_first.d_attributes; 1261 strncpy(entry->d_name, dirp->d_first.d_name, NAME_MAX); 1262 entry->d_name[NAME_MAX] = '\0'; 1263 1264 *result = entry; 1265 return 0; 1266 } 1267 1268 next: 1269 1270 memset(&data, 0, sizeof(struct _finddata_t)); 1271 if( _findnext(dirp->d_handle, &data)==-1 ){ 1272 *result = NULL; 1273 return ENOENT; 1274 } 1275 1276 /* TODO: Remove this block to allow hidden and/or system files. */ 1277 if( is_filtered(data) ) goto next; 1278 1279 entry->d_ino = (ino_t)-1; /* not available */ 1280 entry->d_attributes = data.attrib; 1281 strncpy(entry->d_name, data.name, NAME_MAX); 1282 entry->d_name[NAME_MAX] = '\0'; 1283 1284 *result = entry; 1285 return 0; 1286 } 1287 1288 /* 1289 ** Implementation of the POSIX closedir() function using the MSVCRT. 1290 */ 1291 INT closedir( 1292 LPDIR dirp 1293 ){ 1294 INT result = 0; 1295 1296 if( dirp==NULL ) return EINVAL; 1297 1298 if( dirp->d_handle!=NULL_INTPTR_T && dirp->d_handle!=BAD_INTPTR_T ){ 1299 result = _findclose(dirp->d_handle); 1300 } 1301 1302 sqlite3_free(dirp); 1303 return result; 1304 } 1305 1306 #endif /* defined(WIN32) && defined(_MSC_VER) */ 1307 1308 /************************* End test_windirent.c ********************/ 1309 #define dirent DIRENT 1310 #endif 1311 /************************* Begin ../ext/misc/shathree.c ******************/ 1312 /* 1313 ** 2017-03-08 1314 ** 1315 ** The author disclaims copyright to this source code. In place of 1316 ** a legal notice, here is a blessing: 1317 ** 1318 ** May you do good and not evil. 1319 ** May you find forgiveness for yourself and forgive others. 1320 ** May you share freely, never taking more than you give. 1321 ** 1322 ****************************************************************************** 1323 ** 1324 ** This SQLite extension implements functions that compute SHA3 hashes. 1325 ** Two SQL functions are implemented: 1326 ** 1327 ** sha3(X,SIZE) 1328 ** sha3_query(Y,SIZE) 1329 ** 1330 ** The sha3(X) function computes the SHA3 hash of the input X, or NULL if 1331 ** X is NULL. 1332 ** 1333 ** The sha3_query(Y) function evalutes all queries in the SQL statements of Y 1334 ** and returns a hash of their results. 1335 ** 1336 ** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm 1337 ** is used. If SIZE is included it must be one of the integers 224, 256, 1338 ** 384, or 512, to determine SHA3 hash variant that is computed. 1339 */ 1340 /* #include "sqlite3ext.h" */ 1341 SQLITE_EXTENSION_INIT1 1342 #include <assert.h> 1343 #include <string.h> 1344 #include <stdarg.h> 1345 /* typedef sqlite3_uint64 u64; */ 1346 1347 /****************************************************************************** 1348 ** The Hash Engine 1349 */ 1350 /* 1351 ** Macros to determine whether the machine is big or little endian, 1352 ** and whether or not that determination is run-time or compile-time. 1353 ** 1354 ** For best performance, an attempt is made to guess at the byte-order 1355 ** using C-preprocessor macros. If that is unsuccessful, or if 1356 ** -DSHA3_BYTEORDER=0 is set, then byte-order is determined 1357 ** at run-time. 1358 */ 1359 #ifndef SHA3_BYTEORDER 1360 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ 1361 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ 1362 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ 1363 defined(__arm__) 1364 # define SHA3_BYTEORDER 1234 1365 # elif defined(sparc) || defined(__ppc__) 1366 # define SHA3_BYTEORDER 4321 1367 # else 1368 # define SHA3_BYTEORDER 0 1369 # endif 1370 #endif 1371 1372 1373 /* 1374 ** State structure for a SHA3 hash in progress 1375 */ 1376 typedef struct SHA3Context SHA3Context; 1377 struct SHA3Context { 1378 union { 1379 u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */ 1380 unsigned char x[1600]; /* ... or 1600 bytes */ 1381 } u; 1382 unsigned nRate; /* Bytes of input accepted per Keccak iteration */ 1383 unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */ 1384 unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */ 1385 }; 1386 1387 /* 1388 ** A single step of the Keccak mixing function for a 1600-bit state 1389 */ 1390 static void KeccakF1600Step(SHA3Context *p){ 1391 int i; 1392 u64 b0, b1, b2, b3, b4; 1393 u64 c0, c1, c2, c3, c4; 1394 u64 d0, d1, d2, d3, d4; 1395 static const u64 RC[] = { 1396 0x0000000000000001ULL, 0x0000000000008082ULL, 1397 0x800000000000808aULL, 0x8000000080008000ULL, 1398 0x000000000000808bULL, 0x0000000080000001ULL, 1399 0x8000000080008081ULL, 0x8000000000008009ULL, 1400 0x000000000000008aULL, 0x0000000000000088ULL, 1401 0x0000000080008009ULL, 0x000000008000000aULL, 1402 0x000000008000808bULL, 0x800000000000008bULL, 1403 0x8000000000008089ULL, 0x8000000000008003ULL, 1404 0x8000000000008002ULL, 0x8000000000000080ULL, 1405 0x000000000000800aULL, 0x800000008000000aULL, 1406 0x8000000080008081ULL, 0x8000000000008080ULL, 1407 0x0000000080000001ULL, 0x8000000080008008ULL 1408 }; 1409 # define a00 (p->u.s[0]) 1410 # define a01 (p->u.s[1]) 1411 # define a02 (p->u.s[2]) 1412 # define a03 (p->u.s[3]) 1413 # define a04 (p->u.s[4]) 1414 # define a10 (p->u.s[5]) 1415 # define a11 (p->u.s[6]) 1416 # define a12 (p->u.s[7]) 1417 # define a13 (p->u.s[8]) 1418 # define a14 (p->u.s[9]) 1419 # define a20 (p->u.s[10]) 1420 # define a21 (p->u.s[11]) 1421 # define a22 (p->u.s[12]) 1422 # define a23 (p->u.s[13]) 1423 # define a24 (p->u.s[14]) 1424 # define a30 (p->u.s[15]) 1425 # define a31 (p->u.s[16]) 1426 # define a32 (p->u.s[17]) 1427 # define a33 (p->u.s[18]) 1428 # define a34 (p->u.s[19]) 1429 # define a40 (p->u.s[20]) 1430 # define a41 (p->u.s[21]) 1431 # define a42 (p->u.s[22]) 1432 # define a43 (p->u.s[23]) 1433 # define a44 (p->u.s[24]) 1434 # define ROL64(a,x) ((a<<x)|(a>>(64-x))) 1435 1436 for(i=0; i<24; i+=4){ 1437 c0 = a00^a10^a20^a30^a40; 1438 c1 = a01^a11^a21^a31^a41; 1439 c2 = a02^a12^a22^a32^a42; 1440 c3 = a03^a13^a23^a33^a43; 1441 c4 = a04^a14^a24^a34^a44; 1442 d0 = c4^ROL64(c1, 1); 1443 d1 = c0^ROL64(c2, 1); 1444 d2 = c1^ROL64(c3, 1); 1445 d3 = c2^ROL64(c4, 1); 1446 d4 = c3^ROL64(c0, 1); 1447 1448 b0 = (a00^d0); 1449 b1 = ROL64((a11^d1), 44); 1450 b2 = ROL64((a22^d2), 43); 1451 b3 = ROL64((a33^d3), 21); 1452 b4 = ROL64((a44^d4), 14); 1453 a00 = b0 ^((~b1)& b2 ); 1454 a00 ^= RC[i]; 1455 a11 = b1 ^((~b2)& b3 ); 1456 a22 = b2 ^((~b3)& b4 ); 1457 a33 = b3 ^((~b4)& b0 ); 1458 a44 = b4 ^((~b0)& b1 ); 1459 1460 b2 = ROL64((a20^d0), 3); 1461 b3 = ROL64((a31^d1), 45); 1462 b4 = ROL64((a42^d2), 61); 1463 b0 = ROL64((a03^d3), 28); 1464 b1 = ROL64((a14^d4), 20); 1465 a20 = b0 ^((~b1)& b2 ); 1466 a31 = b1 ^((~b2)& b3 ); 1467 a42 = b2 ^((~b3)& b4 ); 1468 a03 = b3 ^((~b4)& b0 ); 1469 a14 = b4 ^((~b0)& b1 ); 1470 1471 b4 = ROL64((a40^d0), 18); 1472 b0 = ROL64((a01^d1), 1); 1473 b1 = ROL64((a12^d2), 6); 1474 b2 = ROL64((a23^d3), 25); 1475 b3 = ROL64((a34^d4), 8); 1476 a40 = b0 ^((~b1)& b2 ); 1477 a01 = b1 ^((~b2)& b3 ); 1478 a12 = b2 ^((~b3)& b4 ); 1479 a23 = b3 ^((~b4)& b0 ); 1480 a34 = b4 ^((~b0)& b1 ); 1481 1482 b1 = ROL64((a10^d0), 36); 1483 b2 = ROL64((a21^d1), 10); 1484 b3 = ROL64((a32^d2), 15); 1485 b4 = ROL64((a43^d3), 56); 1486 b0 = ROL64((a04^d4), 27); 1487 a10 = b0 ^((~b1)& b2 ); 1488 a21 = b1 ^((~b2)& b3 ); 1489 a32 = b2 ^((~b3)& b4 ); 1490 a43 = b3 ^((~b4)& b0 ); 1491 a04 = b4 ^((~b0)& b1 ); 1492 1493 b3 = ROL64((a30^d0), 41); 1494 b4 = ROL64((a41^d1), 2); 1495 b0 = ROL64((a02^d2), 62); 1496 b1 = ROL64((a13^d3), 55); 1497 b2 = ROL64((a24^d4), 39); 1498 a30 = b0 ^((~b1)& b2 ); 1499 a41 = b1 ^((~b2)& b3 ); 1500 a02 = b2 ^((~b3)& b4 ); 1501 a13 = b3 ^((~b4)& b0 ); 1502 a24 = b4 ^((~b0)& b1 ); 1503 1504 c0 = a00^a20^a40^a10^a30; 1505 c1 = a11^a31^a01^a21^a41; 1506 c2 = a22^a42^a12^a32^a02; 1507 c3 = a33^a03^a23^a43^a13; 1508 c4 = a44^a14^a34^a04^a24; 1509 d0 = c4^ROL64(c1, 1); 1510 d1 = c0^ROL64(c2, 1); 1511 d2 = c1^ROL64(c3, 1); 1512 d3 = c2^ROL64(c4, 1); 1513 d4 = c3^ROL64(c0, 1); 1514 1515 b0 = (a00^d0); 1516 b1 = ROL64((a31^d1), 44); 1517 b2 = ROL64((a12^d2), 43); 1518 b3 = ROL64((a43^d3), 21); 1519 b4 = ROL64((a24^d4), 14); 1520 a00 = b0 ^((~b1)& b2 ); 1521 a00 ^= RC[i+1]; 1522 a31 = b1 ^((~b2)& b3 ); 1523 a12 = b2 ^((~b3)& b4 ); 1524 a43 = b3 ^((~b4)& b0 ); 1525 a24 = b4 ^((~b0)& b1 ); 1526 1527 b2 = ROL64((a40^d0), 3); 1528 b3 = ROL64((a21^d1), 45); 1529 b4 = ROL64((a02^d2), 61); 1530 b0 = ROL64((a33^d3), 28); 1531 b1 = ROL64((a14^d4), 20); 1532 a40 = b0 ^((~b1)& b2 ); 1533 a21 = b1 ^((~b2)& b3 ); 1534 a02 = b2 ^((~b3)& b4 ); 1535 a33 = b3 ^((~b4)& b0 ); 1536 a14 = b4 ^((~b0)& b1 ); 1537 1538 b4 = ROL64((a30^d0), 18); 1539 b0 = ROL64((a11^d1), 1); 1540 b1 = ROL64((a42^d2), 6); 1541 b2 = ROL64((a23^d3), 25); 1542 b3 = ROL64((a04^d4), 8); 1543 a30 = b0 ^((~b1)& b2 ); 1544 a11 = b1 ^((~b2)& b3 ); 1545 a42 = b2 ^((~b3)& b4 ); 1546 a23 = b3 ^((~b4)& b0 ); 1547 a04 = b4 ^((~b0)& b1 ); 1548 1549 b1 = ROL64((a20^d0), 36); 1550 b2 = ROL64((a01^d1), 10); 1551 b3 = ROL64((a32^d2), 15); 1552 b4 = ROL64((a13^d3), 56); 1553 b0 = ROL64((a44^d4), 27); 1554 a20 = b0 ^((~b1)& b2 ); 1555 a01 = b1 ^((~b2)& b3 ); 1556 a32 = b2 ^((~b3)& b4 ); 1557 a13 = b3 ^((~b4)& b0 ); 1558 a44 = b4 ^((~b0)& b1 ); 1559 1560 b3 = ROL64((a10^d0), 41); 1561 b4 = ROL64((a41^d1), 2); 1562 b0 = ROL64((a22^d2), 62); 1563 b1 = ROL64((a03^d3), 55); 1564 b2 = ROL64((a34^d4), 39); 1565 a10 = b0 ^((~b1)& b2 ); 1566 a41 = b1 ^((~b2)& b3 ); 1567 a22 = b2 ^((~b3)& b4 ); 1568 a03 = b3 ^((~b4)& b0 ); 1569 a34 = b4 ^((~b0)& b1 ); 1570 1571 c0 = a00^a40^a30^a20^a10; 1572 c1 = a31^a21^a11^a01^a41; 1573 c2 = a12^a02^a42^a32^a22; 1574 c3 = a43^a33^a23^a13^a03; 1575 c4 = a24^a14^a04^a44^a34; 1576 d0 = c4^ROL64(c1, 1); 1577 d1 = c0^ROL64(c2, 1); 1578 d2 = c1^ROL64(c3, 1); 1579 d3 = c2^ROL64(c4, 1); 1580 d4 = c3^ROL64(c0, 1); 1581 1582 b0 = (a00^d0); 1583 b1 = ROL64((a21^d1), 44); 1584 b2 = ROL64((a42^d2), 43); 1585 b3 = ROL64((a13^d3), 21); 1586 b4 = ROL64((a34^d4), 14); 1587 a00 = b0 ^((~b1)& b2 ); 1588 a00 ^= RC[i+2]; 1589 a21 = b1 ^((~b2)& b3 ); 1590 a42 = b2 ^((~b3)& b4 ); 1591 a13 = b3 ^((~b4)& b0 ); 1592 a34 = b4 ^((~b0)& b1 ); 1593 1594 b2 = ROL64((a30^d0), 3); 1595 b3 = ROL64((a01^d1), 45); 1596 b4 = ROL64((a22^d2), 61); 1597 b0 = ROL64((a43^d3), 28); 1598 b1 = ROL64((a14^d4), 20); 1599 a30 = b0 ^((~b1)& b2 ); 1600 a01 = b1 ^((~b2)& b3 ); 1601 a22 = b2 ^((~b3)& b4 ); 1602 a43 = b3 ^((~b4)& b0 ); 1603 a14 = b4 ^((~b0)& b1 ); 1604 1605 b4 = ROL64((a10^d0), 18); 1606 b0 = ROL64((a31^d1), 1); 1607 b1 = ROL64((a02^d2), 6); 1608 b2 = ROL64((a23^d3), 25); 1609 b3 = ROL64((a44^d4), 8); 1610 a10 = b0 ^((~b1)& b2 ); 1611 a31 = b1 ^((~b2)& b3 ); 1612 a02 = b2 ^((~b3)& b4 ); 1613 a23 = b3 ^((~b4)& b0 ); 1614 a44 = b4 ^((~b0)& b1 ); 1615 1616 b1 = ROL64((a40^d0), 36); 1617 b2 = ROL64((a11^d1), 10); 1618 b3 = ROL64((a32^d2), 15); 1619 b4 = ROL64((a03^d3), 56); 1620 b0 = ROL64((a24^d4), 27); 1621 a40 = b0 ^((~b1)& b2 ); 1622 a11 = b1 ^((~b2)& b3 ); 1623 a32 = b2 ^((~b3)& b4 ); 1624 a03 = b3 ^((~b4)& b0 ); 1625 a24 = b4 ^((~b0)& b1 ); 1626 1627 b3 = ROL64((a20^d0), 41); 1628 b4 = ROL64((a41^d1), 2); 1629 b0 = ROL64((a12^d2), 62); 1630 b1 = ROL64((a33^d3), 55); 1631 b2 = ROL64((a04^d4), 39); 1632 a20 = b0 ^((~b1)& b2 ); 1633 a41 = b1 ^((~b2)& b3 ); 1634 a12 = b2 ^((~b3)& b4 ); 1635 a33 = b3 ^((~b4)& b0 ); 1636 a04 = b4 ^((~b0)& b1 ); 1637 1638 c0 = a00^a30^a10^a40^a20; 1639 c1 = a21^a01^a31^a11^a41; 1640 c2 = a42^a22^a02^a32^a12; 1641 c3 = a13^a43^a23^a03^a33; 1642 c4 = a34^a14^a44^a24^a04; 1643 d0 = c4^ROL64(c1, 1); 1644 d1 = c0^ROL64(c2, 1); 1645 d2 = c1^ROL64(c3, 1); 1646 d3 = c2^ROL64(c4, 1); 1647 d4 = c3^ROL64(c0, 1); 1648 1649 b0 = (a00^d0); 1650 b1 = ROL64((a01^d1), 44); 1651 b2 = ROL64((a02^d2), 43); 1652 b3 = ROL64((a03^d3), 21); 1653 b4 = ROL64((a04^d4), 14); 1654 a00 = b0 ^((~b1)& b2 ); 1655 a00 ^= RC[i+3]; 1656 a01 = b1 ^((~b2)& b3 ); 1657 a02 = b2 ^((~b3)& b4 ); 1658 a03 = b3 ^((~b4)& b0 ); 1659 a04 = b4 ^((~b0)& b1 ); 1660 1661 b2 = ROL64((a10^d0), 3); 1662 b3 = ROL64((a11^d1), 45); 1663 b4 = ROL64((a12^d2), 61); 1664 b0 = ROL64((a13^d3), 28); 1665 b1 = ROL64((a14^d4), 20); 1666 a10 = b0 ^((~b1)& b2 ); 1667 a11 = b1 ^((~b2)& b3 ); 1668 a12 = b2 ^((~b3)& b4 ); 1669 a13 = b3 ^((~b4)& b0 ); 1670 a14 = b4 ^((~b0)& b1 ); 1671 1672 b4 = ROL64((a20^d0), 18); 1673 b0 = ROL64((a21^d1), 1); 1674 b1 = ROL64((a22^d2), 6); 1675 b2 = ROL64((a23^d3), 25); 1676 b3 = ROL64((a24^d4), 8); 1677 a20 = b0 ^((~b1)& b2 ); 1678 a21 = b1 ^((~b2)& b3 ); 1679 a22 = b2 ^((~b3)& b4 ); 1680 a23 = b3 ^((~b4)& b0 ); 1681 a24 = b4 ^((~b0)& b1 ); 1682 1683 b1 = ROL64((a30^d0), 36); 1684 b2 = ROL64((a31^d1), 10); 1685 b3 = ROL64((a32^d2), 15); 1686 b4 = ROL64((a33^d3), 56); 1687 b0 = ROL64((a34^d4), 27); 1688 a30 = b0 ^((~b1)& b2 ); 1689 a31 = b1 ^((~b2)& b3 ); 1690 a32 = b2 ^((~b3)& b4 ); 1691 a33 = b3 ^((~b4)& b0 ); 1692 a34 = b4 ^((~b0)& b1 ); 1693 1694 b3 = ROL64((a40^d0), 41); 1695 b4 = ROL64((a41^d1), 2); 1696 b0 = ROL64((a42^d2), 62); 1697 b1 = ROL64((a43^d3), 55); 1698 b2 = ROL64((a44^d4), 39); 1699 a40 = b0 ^((~b1)& b2 ); 1700 a41 = b1 ^((~b2)& b3 ); 1701 a42 = b2 ^((~b3)& b4 ); 1702 a43 = b3 ^((~b4)& b0 ); 1703 a44 = b4 ^((~b0)& b1 ); 1704 } 1705 } 1706 1707 /* 1708 ** Initialize a new hash. iSize determines the size of the hash 1709 ** in bits and should be one of 224, 256, 384, or 512. Or iSize 1710 ** can be zero to use the default hash size of 256 bits. 1711 */ 1712 static void SHA3Init(SHA3Context *p, int iSize){ 1713 memset(p, 0, sizeof(*p)); 1714 if( iSize>=128 && iSize<=512 ){ 1715 p->nRate = (1600 - ((iSize + 31)&~31)*2)/8; 1716 }else{ 1717 p->nRate = (1600 - 2*256)/8; 1718 } 1719 #if SHA3_BYTEORDER==1234 1720 /* Known to be little-endian at compile-time. No-op */ 1721 #elif SHA3_BYTEORDER==4321 1722 p->ixMask = 7; /* Big-endian */ 1723 #else 1724 { 1725 static unsigned int one = 1; 1726 if( 1==*(unsigned char*)&one ){ 1727 /* Little endian. No byte swapping. */ 1728 p->ixMask = 0; 1729 }else{ 1730 /* Big endian. Byte swap. */ 1731 p->ixMask = 7; 1732 } 1733 } 1734 #endif 1735 } 1736 1737 /* 1738 ** Make consecutive calls to the SHA3Update function to add new content 1739 ** to the hash 1740 */ 1741 static void SHA3Update( 1742 SHA3Context *p, 1743 const unsigned char *aData, 1744 unsigned int nData 1745 ){ 1746 unsigned int i = 0; 1747 #if SHA3_BYTEORDER==1234 1748 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){ 1749 for(; i+7<nData; i+=8){ 1750 p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i]; 1751 p->nLoaded += 8; 1752 if( p->nLoaded>=p->nRate ){ 1753 KeccakF1600Step(p); 1754 p->nLoaded = 0; 1755 } 1756 } 1757 } 1758 #endif 1759 for(; i<nData; i++){ 1760 #if SHA3_BYTEORDER==1234 1761 p->u.x[p->nLoaded] ^= aData[i]; 1762 #elif SHA3_BYTEORDER==4321 1763 p->u.x[p->nLoaded^0x07] ^= aData[i]; 1764 #else 1765 p->u.x[p->nLoaded^p->ixMask] ^= aData[i]; 1766 #endif 1767 p->nLoaded++; 1768 if( p->nLoaded==p->nRate ){ 1769 KeccakF1600Step(p); 1770 p->nLoaded = 0; 1771 } 1772 } 1773 } 1774 1775 /* 1776 ** After all content has been added, invoke SHA3Final() to compute 1777 ** the final hash. The function returns a pointer to the binary 1778 ** hash value. 1779 */ 1780 static unsigned char *SHA3Final(SHA3Context *p){ 1781 unsigned int i; 1782 if( p->nLoaded==p->nRate-1 ){ 1783 const unsigned char c1 = 0x86; 1784 SHA3Update(p, &c1, 1); 1785 }else{ 1786 const unsigned char c2 = 0x06; 1787 const unsigned char c3 = 0x80; 1788 SHA3Update(p, &c2, 1); 1789 p->nLoaded = p->nRate - 1; 1790 SHA3Update(p, &c3, 1); 1791 } 1792 for(i=0; i<p->nRate; i++){ 1793 p->u.x[i+p->nRate] = p->u.x[i^p->ixMask]; 1794 } 1795 return &p->u.x[p->nRate]; 1796 } 1797 /* End of the hashing logic 1798 *****************************************************************************/ 1799 1800 /* 1801 ** Implementation of the sha3(X,SIZE) function. 1802 ** 1803 ** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default 1804 ** size is 256. If X is a BLOB, it is hashed as is. 1805 ** For all other non-NULL types of input, X is converted into a UTF-8 string 1806 ** and the string is hashed without the trailing 0x00 terminator. The hash 1807 ** of a NULL value is NULL. 1808 */ 1809 static void sha3Func( 1810 sqlite3_context *context, 1811 int argc, 1812 sqlite3_value **argv 1813 ){ 1814 SHA3Context cx; 1815 int eType = sqlite3_value_type(argv[0]); 1816 int nByte = sqlite3_value_bytes(argv[0]); 1817 int iSize; 1818 if( argc==1 ){ 1819 iSize = 256; 1820 }else{ 1821 iSize = sqlite3_value_int(argv[1]); 1822 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ 1823 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " 1824 "384 512", -1); 1825 return; 1826 } 1827 } 1828 if( eType==SQLITE_NULL ) return; 1829 SHA3Init(&cx, iSize); 1830 if( eType==SQLITE_BLOB ){ 1831 SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte); 1832 }else{ 1833 SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte); 1834 } 1835 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); 1836 } 1837 1838 /* Compute a string using sqlite3_vsnprintf() with a maximum length 1839 ** of 50 bytes and add it to the hash. 1840 */ 1841 static void hash_step_vformat( 1842 SHA3Context *p, /* Add content to this context */ 1843 const char *zFormat, 1844 ... 1845 ){ 1846 va_list ap; 1847 int n; 1848 char zBuf[50]; 1849 va_start(ap, zFormat); 1850 sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap); 1851 va_end(ap); 1852 n = (int)strlen(zBuf); 1853 SHA3Update(p, (unsigned char*)zBuf, n); 1854 } 1855 1856 /* 1857 ** Implementation of the sha3_query(SQL,SIZE) function. 1858 ** 1859 ** This function compiles and runs the SQL statement(s) given in the 1860 ** argument. The results are hashed using a SIZE-bit SHA3. The default 1861 ** size is 256. 1862 ** 1863 ** The format of the byte stream that is hashed is summarized as follows: 1864 ** 1865 ** S<n>:<sql> 1866 ** R 1867 ** N 1868 ** I<int> 1869 ** F<ieee-float> 1870 ** B<size>:<bytes> 1871 ** T<size>:<text> 1872 ** 1873 ** <sql> is the original SQL text for each statement run and <n> is 1874 ** the size of that text. The SQL text is UTF-8. A single R character 1875 ** occurs before the start of each row. N means a NULL value. 1876 ** I mean an 8-byte little-endian integer <int>. F is a floating point 1877 ** number with an 8-byte little-endian IEEE floating point value <ieee-float>. 1878 ** B means blobs of <size> bytes. T means text rendered as <size> 1879 ** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII 1880 ** text integers. 1881 ** 1882 ** For each SQL statement in the X input, there is one S segment. Each 1883 ** S segment is followed by zero or more R segments, one for each row in the 1884 ** result set. After each R, there are one or more N, I, F, B, or T segments, 1885 ** one for each column in the result set. Segments are concatentated directly 1886 ** with no delimiters of any kind. 1887 */ 1888 static void sha3QueryFunc( 1889 sqlite3_context *context, 1890 int argc, 1891 sqlite3_value **argv 1892 ){ 1893 sqlite3 *db = sqlite3_context_db_handle(context); 1894 const char *zSql = (const char*)sqlite3_value_text(argv[0]); 1895 sqlite3_stmt *pStmt = 0; 1896 int nCol; /* Number of columns in the result set */ 1897 int i; /* Loop counter */ 1898 int rc; 1899 int n; 1900 const char *z; 1901 SHA3Context cx; 1902 int iSize; 1903 1904 if( argc==1 ){ 1905 iSize = 256; 1906 }else{ 1907 iSize = sqlite3_value_int(argv[1]); 1908 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ 1909 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " 1910 "384 512", -1); 1911 return; 1912 } 1913 } 1914 if( zSql==0 ) return; 1915 SHA3Init(&cx, iSize); 1916 while( zSql[0] ){ 1917 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql); 1918 if( rc ){ 1919 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s", 1920 zSql, sqlite3_errmsg(db)); 1921 sqlite3_finalize(pStmt); 1922 sqlite3_result_error(context, zMsg, -1); 1923 sqlite3_free(zMsg); 1924 return; 1925 } 1926 if( !sqlite3_stmt_readonly(pStmt) ){ 1927 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt)); 1928 sqlite3_finalize(pStmt); 1929 sqlite3_result_error(context, zMsg, -1); 1930 sqlite3_free(zMsg); 1931 return; 1932 } 1933 nCol = sqlite3_column_count(pStmt); 1934 z = sqlite3_sql(pStmt); 1935 n = (int)strlen(z); 1936 hash_step_vformat(&cx,"S%d:",n); 1937 SHA3Update(&cx,(unsigned char*)z,n); 1938 1939 /* Compute a hash over the result of the query */ 1940 while( SQLITE_ROW==sqlite3_step(pStmt) ){ 1941 SHA3Update(&cx,(const unsigned char*)"R",1); 1942 for(i=0; i<nCol; i++){ 1943 switch( sqlite3_column_type(pStmt,i) ){ 1944 case SQLITE_NULL: { 1945 SHA3Update(&cx, (const unsigned char*)"N",1); 1946 break; 1947 } 1948 case SQLITE_INTEGER: { 1949 sqlite3_uint64 u; 1950 int j; 1951 unsigned char x[9]; 1952 sqlite3_int64 v = sqlite3_column_int64(pStmt,i); 1953 memcpy(&u, &v, 8); 1954 for(j=8; j>=1; j--){ 1955 x[j] = u & 0xff; 1956 u >>= 8; 1957 } 1958 x[0] = 'I'; 1959 SHA3Update(&cx, x, 9); 1960 break; 1961 } 1962 case SQLITE_FLOAT: { 1963 sqlite3_uint64 u; 1964 int j; 1965 unsigned char x[9]; 1966 double r = sqlite3_column_double(pStmt,i); 1967 memcpy(&u, &r, 8); 1968 for(j=8; j>=1; j--){ 1969 x[j] = u & 0xff; 1970 u >>= 8; 1971 } 1972 x[0] = 'F'; 1973 SHA3Update(&cx,x,9); 1974 break; 1975 } 1976 case SQLITE_TEXT: { 1977 int n2 = sqlite3_column_bytes(pStmt, i); 1978 const unsigned char *z2 = sqlite3_column_text(pStmt, i); 1979 hash_step_vformat(&cx,"T%d:",n2); 1980 SHA3Update(&cx, z2, n2); 1981 break; 1982 } 1983 case SQLITE_BLOB: { 1984 int n2 = sqlite3_column_bytes(pStmt, i); 1985 const unsigned char *z2 = sqlite3_column_blob(pStmt, i); 1986 hash_step_vformat(&cx,"B%d:",n2); 1987 SHA3Update(&cx, z2, n2); 1988 break; 1989 } 1990 } 1991 } 1992 } 1993 sqlite3_finalize(pStmt); 1994 } 1995 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); 1996 } 1997 1998 1999 #ifdef _WIN32 2000 2001 #endif 2002 int sqlite3_shathree_init( 2003 sqlite3 *db, 2004 char **pzErrMsg, 2005 const sqlite3_api_routines *pApi 2006 ){ 2007 int rc = SQLITE_OK; 2008 SQLITE_EXTENSION_INIT2(pApi); 2009 (void)pzErrMsg; /* Unused parameter */ 2010 rc = sqlite3_create_function(db, "sha3", 1, SQLITE_UTF8, 0, 2011 sha3Func, 0, 0); 2012 if( rc==SQLITE_OK ){ 2013 rc = sqlite3_create_function(db, "sha3", 2, SQLITE_UTF8, 0, 2014 sha3Func, 0, 0); 2015 } 2016 if( rc==SQLITE_OK ){ 2017 rc = sqlite3_create_function(db, "sha3_query", 1, SQLITE_UTF8, 0, 2018 sha3QueryFunc, 0, 0); 2019 } 2020 if( rc==SQLITE_OK ){ 2021 rc = sqlite3_create_function(db, "sha3_query", 2, SQLITE_UTF8, 0, 2022 sha3QueryFunc, 0, 0); 2023 } 2024 return rc; 2025 } 2026 2027 /************************* End ../ext/misc/shathree.c ********************/ 2028 /************************* Begin ../ext/misc/fileio.c ******************/ 2029 /* 2030 ** 2014-06-13 2031 ** 2032 ** The author disclaims copyright to this source code. In place of 2033 ** a legal notice, here is a blessing: 2034 ** 2035 ** May you do good and not evil. 2036 ** May you find forgiveness for yourself and forgive others. 2037 ** May you share freely, never taking more than you give. 2038 ** 2039 ****************************************************************************** 2040 ** 2041 ** This SQLite extension implements SQL functions readfile() and 2042 ** writefile(), and eponymous virtual type "fsdir". 2043 ** 2044 ** WRITEFILE(FILE, DATA [, MODE [, MTIME]]): 2045 ** 2046 ** If neither of the optional arguments is present, then this UDF 2047 ** function writes blob DATA to file FILE. If successful, the number 2048 ** of bytes written is returned. If an error occurs, NULL is returned. 2049 ** 2050 ** If the first option argument - MODE - is present, then it must 2051 ** be passed an integer value that corresponds to a POSIX mode 2052 ** value (file type + permissions, as returned in the stat.st_mode 2053 ** field by the stat() system call). Three types of files may 2054 ** be written/created: 2055 ** 2056 ** regular files: (mode & 0170000)==0100000 2057 ** symbolic links: (mode & 0170000)==0120000 2058 ** directories: (mode & 0170000)==0040000 2059 ** 2060 ** For a directory, the DATA is ignored. For a symbolic link, it is 2061 ** interpreted as text and used as the target of the link. For a 2062 ** regular file, it is interpreted as a blob and written into the 2063 ** named file. Regardless of the type of file, its permissions are 2064 ** set to (mode & 0777) before returning. 2065 ** 2066 ** If the optional MTIME argument is present, then it is interpreted 2067 ** as an integer - the number of seconds since the unix epoch. The 2068 ** modification-time of the target file is set to this value before 2069 ** returning. 2070 ** 2071 ** If three or more arguments are passed to this function and an 2072 ** error is encountered, an exception is raised. 2073 ** 2074 ** READFILE(FILE): 2075 ** 2076 ** Read and return the contents of file FILE (type blob) from disk. 2077 ** 2078 ** FSDIR: 2079 ** 2080 ** Used as follows: 2081 ** 2082 ** SELECT * FROM fsdir($path [, $dir]); 2083 ** 2084 ** Parameter $path is an absolute or relative pathname. If the file that it 2085 ** refers to does not exist, it is an error. If the path refers to a regular 2086 ** file or symbolic link, it returns a single row. Or, if the path refers 2087 ** to a directory, it returns one row for the directory, and one row for each 2088 ** file within the hierarchy rooted at $path. 2089 ** 2090 ** Each row has the following columns: 2091 ** 2092 ** name: Path to file or directory (text value). 2093 ** mode: Value of stat.st_mode for directory entry (an integer). 2094 ** mtime: Value of stat.st_mtime for directory entry (an integer). 2095 ** data: For a regular file, a blob containing the file data. For a 2096 ** symlink, a text value containing the text of the link. For a 2097 ** directory, NULL. 2098 ** 2099 ** If a non-NULL value is specified for the optional $dir parameter and 2100 ** $path is a relative path, then $path is interpreted relative to $dir. 2101 ** And the paths returned in the "name" column of the table are also 2102 ** relative to directory $dir. 2103 */ 2104 /* #include "sqlite3ext.h" */ 2105 SQLITE_EXTENSION_INIT1 2106 #include <stdio.h> 2107 #include <string.h> 2108 #include <assert.h> 2109 2110 #include <sys/types.h> 2111 #include <sys/stat.h> 2112 #include <fcntl.h> 2113 #if !defined(_WIN32) && !defined(WIN32) 2114 # include <unistd.h> 2115 # include <dirent.h> 2116 # include <utime.h> 2117 # include <sys/time.h> 2118 #else 2119 # include "windows.h" 2120 # include <io.h> 2121 # include <direct.h> 2122 /* # include "test_windirent.h" */ 2123 # define dirent DIRENT 2124 # ifndef chmod 2125 # define chmod _chmod 2126 # endif 2127 # ifndef stat 2128 # define stat _stat 2129 # endif 2130 # define mkdir(path,mode) _mkdir(path) 2131 # define lstat(path,buf) stat(path,buf) 2132 #endif 2133 #include <time.h> 2134 #include <errno.h> 2135 2136 2137 /* 2138 ** Structure of the fsdir() table-valued function 2139 */ 2140 /* 0 1 2 3 4 5 */ 2141 #define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)" 2142 #define FSDIR_COLUMN_NAME 0 /* Name of the file */ 2143 #define FSDIR_COLUMN_MODE 1 /* Access mode */ 2144 #define FSDIR_COLUMN_MTIME 2 /* Last modification time */ 2145 #define FSDIR_COLUMN_DATA 3 /* File content */ 2146 #define FSDIR_COLUMN_PATH 4 /* Path to top of search */ 2147 #define FSDIR_COLUMN_DIR 5 /* Path is relative to this directory */ 2148 2149 2150 /* 2151 ** Set the result stored by context ctx to a blob containing the 2152 ** contents of file zName. Or, leave the result unchanged (NULL) 2153 ** if the file does not exist or is unreadable. 2154 ** 2155 ** If the file exceeds the SQLite blob size limit, through an 2156 ** SQLITE_TOOBIG error. 2157 ** 2158 ** Throw an SQLITE_IOERR if there are difficulties pulling the file 2159 ** off of disk. 2160 */ 2161 static void readFileContents(sqlite3_context *ctx, const char *zName){ 2162 FILE *in; 2163 sqlite3_int64 nIn; 2164 void *pBuf; 2165 sqlite3 *db; 2166 int mxBlob; 2167 2168 in = fopen(zName, "rb"); 2169 if( in==0 ){ 2170 /* File does not exist or is unreadable. Leave the result set to NULL. */ 2171 return; 2172 } 2173 fseek(in, 0, SEEK_END); 2174 nIn = ftell(in); 2175 rewind(in); 2176 db = sqlite3_context_db_handle(ctx); 2177 mxBlob = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1); 2178 if( nIn>mxBlob ){ 2179 sqlite3_result_error_code(ctx, SQLITE_TOOBIG); 2180 fclose(in); 2181 return; 2182 } 2183 pBuf = sqlite3_malloc64( nIn ? nIn : 1 ); 2184 if( pBuf==0 ){ 2185 sqlite3_result_error_nomem(ctx); 2186 fclose(in); 2187 return; 2188 } 2189 if( nIn==(sqlite3_int64)fread(pBuf, 1, (size_t)nIn, in) ){ 2190 sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free); 2191 }else{ 2192 sqlite3_result_error_code(ctx, SQLITE_IOERR); 2193 sqlite3_free(pBuf); 2194 } 2195 fclose(in); 2196 } 2197 2198 /* 2199 ** Implementation of the "readfile(X)" SQL function. The entire content 2200 ** of the file named X is read and returned as a BLOB. NULL is returned 2201 ** if the file does not exist or is unreadable. 2202 */ 2203 static void readfileFunc( 2204 sqlite3_context *context, 2205 int argc, 2206 sqlite3_value **argv 2207 ){ 2208 const char *zName; 2209 (void)(argc); /* Unused parameter */ 2210 zName = (const char*)sqlite3_value_text(argv[0]); 2211 if( zName==0 ) return; 2212 readFileContents(context, zName); 2213 } 2214 2215 /* 2216 ** Set the error message contained in context ctx to the results of 2217 ** vprintf(zFmt, ...). 2218 */ 2219 static void ctxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){ 2220 char *zMsg = 0; 2221 va_list ap; 2222 va_start(ap, zFmt); 2223 zMsg = sqlite3_vmprintf(zFmt, ap); 2224 sqlite3_result_error(ctx, zMsg, -1); 2225 sqlite3_free(zMsg); 2226 va_end(ap); 2227 } 2228 2229 #if defined(_WIN32) 2230 /* 2231 ** This function is designed to convert a Win32 FILETIME structure into the 2232 ** number of seconds since the Unix Epoch (1970-01-01 00:00:00 UTC). 2233 */ 2234 static sqlite3_uint64 fileTimeToUnixTime( 2235 LPFILETIME pFileTime 2236 ){ 2237 SYSTEMTIME epochSystemTime; 2238 ULARGE_INTEGER epochIntervals; 2239 FILETIME epochFileTime; 2240 ULARGE_INTEGER fileIntervals; 2241 2242 memset(&epochSystemTime, 0, sizeof(SYSTEMTIME)); 2243 epochSystemTime.wYear = 1970; 2244 epochSystemTime.wMonth = 1; 2245 epochSystemTime.wDay = 1; 2246 SystemTimeToFileTime(&epochSystemTime, &epochFileTime); 2247 epochIntervals.LowPart = epochFileTime.dwLowDateTime; 2248 epochIntervals.HighPart = epochFileTime.dwHighDateTime; 2249 2250 fileIntervals.LowPart = pFileTime->dwLowDateTime; 2251 fileIntervals.HighPart = pFileTime->dwHighDateTime; 2252 2253 return (fileIntervals.QuadPart - epochIntervals.QuadPart) / 10000000; 2254 } 2255 2256 /* 2257 ** This function attempts to normalize the time values found in the stat() 2258 ** buffer to UTC. This is necessary on Win32, where the runtime library 2259 ** appears to return these values as local times. 2260 */ 2261 static void statTimesToUtc( 2262 const char *zPath, 2263 struct stat *pStatBuf 2264 ){ 2265 HANDLE hFindFile; 2266 WIN32_FIND_DATAW fd; 2267 LPWSTR zUnicodeName; 2268 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); 2269 zUnicodeName = sqlite3_win32_utf8_to_unicode(zPath); 2270 if( zUnicodeName ){ 2271 memset(&fd, 0, sizeof(WIN32_FIND_DATAW)); 2272 hFindFile = FindFirstFileW(zUnicodeName, &fd); 2273 if( hFindFile!=NULL ){ 2274 pStatBuf->st_ctime = (time_t)fileTimeToUnixTime(&fd.ftCreationTime); 2275 pStatBuf->st_atime = (time_t)fileTimeToUnixTime(&fd.ftLastAccessTime); 2276 pStatBuf->st_mtime = (time_t)fileTimeToUnixTime(&fd.ftLastWriteTime); 2277 FindClose(hFindFile); 2278 } 2279 sqlite3_free(zUnicodeName); 2280 } 2281 } 2282 #endif 2283 2284 /* 2285 ** This function is used in place of stat(). On Windows, special handling 2286 ** is required in order for the included time to be returned as UTC. On all 2287 ** other systems, this function simply calls stat(). 2288 */ 2289 static int fileStat( 2290 const char *zPath, 2291 struct stat *pStatBuf 2292 ){ 2293 #if defined(_WIN32) 2294 int rc = stat(zPath, pStatBuf); 2295 if( rc==0 ) statTimesToUtc(zPath, pStatBuf); 2296 return rc; 2297 #else 2298 return stat(zPath, pStatBuf); 2299 #endif 2300 } 2301 2302 /* 2303 ** This function is used in place of lstat(). On Windows, special handling 2304 ** is required in order for the included time to be returned as UTC. On all 2305 ** other systems, this function simply calls lstat(). 2306 */ 2307 static int fileLinkStat( 2308 const char *zPath, 2309 struct stat *pStatBuf 2310 ){ 2311 #if defined(_WIN32) 2312 int rc = lstat(zPath, pStatBuf); 2313 if( rc==0 ) statTimesToUtc(zPath, pStatBuf); 2314 return rc; 2315 #else 2316 return lstat(zPath, pStatBuf); 2317 #endif 2318 } 2319 2320 /* 2321 ** Argument zFile is the name of a file that will be created and/or written 2322 ** by SQL function writefile(). This function ensures that the directory 2323 ** zFile will be written to exists, creating it if required. The permissions 2324 ** for any path components created by this function are set in accordance 2325 ** with the current umask. 2326 ** 2327 ** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise, 2328 ** SQLITE_OK is returned if the directory is successfully created, or 2329 ** SQLITE_ERROR otherwise. 2330 */ 2331 static int makeDirectory( 2332 const char *zFile 2333 ){ 2334 char *zCopy = sqlite3_mprintf("%s", zFile); 2335 int rc = SQLITE_OK; 2336 2337 if( zCopy==0 ){ 2338 rc = SQLITE_NOMEM; 2339 }else{ 2340 int nCopy = (int)strlen(zCopy); 2341 int i = 1; 2342 2343 while( rc==SQLITE_OK ){ 2344 struct stat sStat; 2345 int rc2; 2346 2347 for(; zCopy[i]!='/' && i<nCopy; i++); 2348 if( i==nCopy ) break; 2349 zCopy[i] = '\0'; 2350 2351 rc2 = fileStat(zCopy, &sStat); 2352 if( rc2!=0 ){ 2353 if( mkdir(zCopy, 0777) ) rc = SQLITE_ERROR; 2354 }else{ 2355 if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR; 2356 } 2357 zCopy[i] = '/'; 2358 i++; 2359 } 2360 2361 sqlite3_free(zCopy); 2362 } 2363 2364 return rc; 2365 } 2366 2367 /* 2368 ** This function does the work for the writefile() UDF. Refer to 2369 ** header comments at the top of this file for details. 2370 */ 2371 static int writeFile( 2372 sqlite3_context *pCtx, /* Context to return bytes written in */ 2373 const char *zFile, /* File to write */ 2374 sqlite3_value *pData, /* Data to write */ 2375 mode_t mode, /* MODE parameter passed to writefile() */ 2376 sqlite3_int64 mtime /* MTIME parameter (or -1 to not set time) */ 2377 ){ 2378 #if !defined(_WIN32) && !defined(WIN32) 2379 if( S_ISLNK(mode) ){ 2380 const char *zTo = (const char*)sqlite3_value_text(pData); 2381 if( symlink(zTo, zFile)<0 ) return 1; 2382 }else 2383 #endif 2384 { 2385 if( S_ISDIR(mode) ){ 2386 if( mkdir(zFile, mode) ){ 2387 /* The mkdir() call to create the directory failed. This might not 2388 ** be an error though - if there is already a directory at the same 2389 ** path and either the permissions already match or can be changed 2390 ** to do so using chmod(), it is not an error. */ 2391 struct stat sStat; 2392 if( errno!=EEXIST 2393 || 0!=fileStat(zFile, &sStat) 2394 || !S_ISDIR(sStat.st_mode) 2395 || ((sStat.st_mode&0777)!=(mode&0777) && 0!=chmod(zFile, mode&0777)) 2396 ){ 2397 return 1; 2398 } 2399 } 2400 }else{ 2401 sqlite3_int64 nWrite = 0; 2402 const char *z; 2403 int rc = 0; 2404 FILE *out = fopen(zFile, "wb"); 2405 if( out==0 ) return 1; 2406 z = (const char*)sqlite3_value_blob(pData); 2407 if( z ){ 2408 sqlite3_int64 n = fwrite(z, 1, sqlite3_value_bytes(pData), out); 2409 nWrite = sqlite3_value_bytes(pData); 2410 if( nWrite!=n ){ 2411 rc = 1; 2412 } 2413 } 2414 fclose(out); 2415 if( rc==0 && mode && chmod(zFile, mode & 0777) ){ 2416 rc = 1; 2417 } 2418 if( rc ) return 2; 2419 sqlite3_result_int64(pCtx, nWrite); 2420 } 2421 } 2422 2423 if( mtime>=0 ){ 2424 #if defined(_WIN32) 2425 /* Windows */ 2426 FILETIME lastAccess; 2427 FILETIME lastWrite; 2428 SYSTEMTIME currentTime; 2429 LONGLONG intervals; 2430 HANDLE hFile; 2431 LPWSTR zUnicodeName; 2432 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); 2433 2434 GetSystemTime(¤tTime); 2435 SystemTimeToFileTime(¤tTime, &lastAccess); 2436 intervals = Int32x32To64(mtime, 10000000) + 116444736000000000; 2437 lastWrite.dwLowDateTime = (DWORD)intervals; 2438 lastWrite.dwHighDateTime = intervals >> 32; 2439 zUnicodeName = sqlite3_win32_utf8_to_unicode(zFile); 2440 if( zUnicodeName==0 ){ 2441 return 1; 2442 } 2443 hFile = CreateFileW( 2444 zUnicodeName, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, 2445 FILE_FLAG_BACKUP_SEMANTICS, NULL 2446 ); 2447 sqlite3_free(zUnicodeName); 2448 if( hFile!=INVALID_HANDLE_VALUE ){ 2449 BOOL bResult = SetFileTime(hFile, NULL, &lastAccess, &lastWrite); 2450 CloseHandle(hFile); 2451 return !bResult; 2452 }else{ 2453 return 1; 2454 } 2455 #elif defined(AT_FDCWD) && 0 /* utimensat() is not universally available */ 2456 /* Recent unix */ 2457 struct timespec times[2]; 2458 times[0].tv_nsec = times[1].tv_nsec = 0; 2459 times[0].tv_sec = time(0); 2460 times[1].tv_sec = mtime; 2461 if( utimensat(AT_FDCWD, zFile, times, AT_SYMLINK_NOFOLLOW) ){ 2462 return 1; 2463 } 2464 #else 2465 /* Legacy unix */ 2466 struct timeval times[2]; 2467 times[0].tv_usec = times[1].tv_usec = 0; 2468 times[0].tv_sec = time(0); 2469 times[1].tv_sec = mtime; 2470 if( utimes(zFile, times) ){ 2471 return 1; 2472 } 2473 #endif 2474 } 2475 2476 return 0; 2477 } 2478 2479 /* 2480 ** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function. 2481 ** Refer to header comments at the top of this file for details. 2482 */ 2483 static void writefileFunc( 2484 sqlite3_context *context, 2485 int argc, 2486 sqlite3_value **argv 2487 ){ 2488 const char *zFile; 2489 mode_t mode = 0; 2490 int res; 2491 sqlite3_int64 mtime = -1; 2492 2493 if( argc<2 || argc>4 ){ 2494 sqlite3_result_error(context, 2495 "wrong number of arguments to function writefile()", -1 2496 ); 2497 return; 2498 } 2499 2500 zFile = (const char*)sqlite3_value_text(argv[0]); 2501 if( zFile==0 ) return; 2502 if( argc>=3 ){ 2503 mode = (mode_t)sqlite3_value_int(argv[2]); 2504 } 2505 if( argc==4 ){ 2506 mtime = sqlite3_value_int64(argv[3]); 2507 } 2508 2509 res = writeFile(context, zFile, argv[1], mode, mtime); 2510 if( res==1 && errno==ENOENT ){ 2511 if( makeDirectory(zFile)==SQLITE_OK ){ 2512 res = writeFile(context, zFile, argv[1], mode, mtime); 2513 } 2514 } 2515 2516 if( argc>2 && res!=0 ){ 2517 if( S_ISLNK(mode) ){ 2518 ctxErrorMsg(context, "failed to create symlink: %s", zFile); 2519 }else if( S_ISDIR(mode) ){ 2520 ctxErrorMsg(context, "failed to create directory: %s", zFile); 2521 }else{ 2522 ctxErrorMsg(context, "failed to write file: %s", zFile); 2523 } 2524 } 2525 } 2526 2527 /* 2528 ** SQL function: lsmode(MODE) 2529 ** 2530 ** Given a numberic st_mode from stat(), convert it into a human-readable 2531 ** text string in the style of "ls -l". 2532 */ 2533 static void lsModeFunc( 2534 sqlite3_context *context, 2535 int argc, 2536 sqlite3_value **argv 2537 ){ 2538 int i; 2539 int iMode = sqlite3_value_int(argv[0]); 2540 char z[16]; 2541 (void)argc; 2542 if( S_ISLNK(iMode) ){ 2543 z[0] = 'l'; 2544 }else if( S_ISREG(iMode) ){ 2545 z[0] = '-'; 2546 }else if( S_ISDIR(iMode) ){ 2547 z[0] = 'd'; 2548 }else{ 2549 z[0] = '?'; 2550 } 2551 for(i=0; i<3; i++){ 2552 int m = (iMode >> ((2-i)*3)); 2553 char *a = &z[1 + i*3]; 2554 a[0] = (m & 0x4) ? 'r' : '-'; 2555 a[1] = (m & 0x2) ? 'w' : '-'; 2556 a[2] = (m & 0x1) ? 'x' : '-'; 2557 } 2558 z[10] = '\0'; 2559 sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT); 2560 } 2561 2562 #ifndef SQLITE_OMIT_VIRTUALTABLE 2563 2564 /* 2565 ** Cursor type for recursively iterating through a directory structure. 2566 */ 2567 typedef struct fsdir_cursor fsdir_cursor; 2568 typedef struct FsdirLevel FsdirLevel; 2569 2570 struct FsdirLevel { 2571 DIR *pDir; /* From opendir() */ 2572 char *zDir; /* Name of directory (nul-terminated) */ 2573 }; 2574 2575 struct fsdir_cursor { 2576 sqlite3_vtab_cursor base; /* Base class - must be first */ 2577 2578 int nLvl; /* Number of entries in aLvl[] array */ 2579 int iLvl; /* Index of current entry */ 2580 FsdirLevel *aLvl; /* Hierarchy of directories being traversed */ 2581 2582 const char *zBase; 2583 int nBase; 2584 2585 struct stat sStat; /* Current lstat() results */ 2586 char *zPath; /* Path to current entry */ 2587 sqlite3_int64 iRowid; /* Current rowid */ 2588 }; 2589 2590 typedef struct fsdir_tab fsdir_tab; 2591 struct fsdir_tab { 2592 sqlite3_vtab base; /* Base class - must be first */ 2593 }; 2594 2595 /* 2596 ** Construct a new fsdir virtual table object. 2597 */ 2598 static int fsdirConnect( 2599 sqlite3 *db, 2600 void *pAux, 2601 int argc, const char *const*argv, 2602 sqlite3_vtab **ppVtab, 2603 char **pzErr 2604 ){ 2605 fsdir_tab *pNew = 0; 2606 int rc; 2607 (void)pAux; 2608 (void)argc; 2609 (void)argv; 2610 (void)pzErr; 2611 rc = sqlite3_declare_vtab(db, "CREATE TABLE x" FSDIR_SCHEMA); 2612 if( rc==SQLITE_OK ){ 2613 pNew = (fsdir_tab*)sqlite3_malloc( sizeof(*pNew) ); 2614 if( pNew==0 ) return SQLITE_NOMEM; 2615 memset(pNew, 0, sizeof(*pNew)); 2616 } 2617 *ppVtab = (sqlite3_vtab*)pNew; 2618 return rc; 2619 } 2620 2621 /* 2622 ** This method is the destructor for fsdir vtab objects. 2623 */ 2624 static int fsdirDisconnect(sqlite3_vtab *pVtab){ 2625 sqlite3_free(pVtab); 2626 return SQLITE_OK; 2627 } 2628 2629 /* 2630 ** Constructor for a new fsdir_cursor object. 2631 */ 2632 static int fsdirOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 2633 fsdir_cursor *pCur; 2634 (void)p; 2635 pCur = sqlite3_malloc( sizeof(*pCur) ); 2636 if( pCur==0 ) return SQLITE_NOMEM; 2637 memset(pCur, 0, sizeof(*pCur)); 2638 pCur->iLvl = -1; 2639 *ppCursor = &pCur->base; 2640 return SQLITE_OK; 2641 } 2642 2643 /* 2644 ** Reset a cursor back to the state it was in when first returned 2645 ** by fsdirOpen(). 2646 */ 2647 static void fsdirResetCursor(fsdir_cursor *pCur){ 2648 int i; 2649 for(i=0; i<=pCur->iLvl; i++){ 2650 FsdirLevel *pLvl = &pCur->aLvl[i]; 2651 if( pLvl->pDir ) closedir(pLvl->pDir); 2652 sqlite3_free(pLvl->zDir); 2653 } 2654 sqlite3_free(pCur->zPath); 2655 sqlite3_free(pCur->aLvl); 2656 pCur->aLvl = 0; 2657 pCur->zPath = 0; 2658 pCur->zBase = 0; 2659 pCur->nBase = 0; 2660 pCur->nLvl = 0; 2661 pCur->iLvl = -1; 2662 pCur->iRowid = 1; 2663 } 2664 2665 /* 2666 ** Destructor for an fsdir_cursor. 2667 */ 2668 static int fsdirClose(sqlite3_vtab_cursor *cur){ 2669 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2670 2671 fsdirResetCursor(pCur); 2672 sqlite3_free(pCur); 2673 return SQLITE_OK; 2674 } 2675 2676 /* 2677 ** Set the error message for the virtual table associated with cursor 2678 ** pCur to the results of vprintf(zFmt, ...). 2679 */ 2680 static void fsdirSetErrmsg(fsdir_cursor *pCur, const char *zFmt, ...){ 2681 va_list ap; 2682 va_start(ap, zFmt); 2683 pCur->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap); 2684 va_end(ap); 2685 } 2686 2687 2688 /* 2689 ** Advance an fsdir_cursor to its next row of output. 2690 */ 2691 static int fsdirNext(sqlite3_vtab_cursor *cur){ 2692 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2693 mode_t m = pCur->sStat.st_mode; 2694 2695 pCur->iRowid++; 2696 if( S_ISDIR(m) ){ 2697 /* Descend into this directory */ 2698 int iNew = pCur->iLvl + 1; 2699 FsdirLevel *pLvl; 2700 if( iNew>=pCur->nLvl ){ 2701 int nNew = iNew+1; 2702 sqlite3_int64 nByte = nNew*sizeof(FsdirLevel); 2703 FsdirLevel *aNew = (FsdirLevel*)sqlite3_realloc64(pCur->aLvl, nByte); 2704 if( aNew==0 ) return SQLITE_NOMEM; 2705 memset(&aNew[pCur->nLvl], 0, sizeof(FsdirLevel)*(nNew-pCur->nLvl)); 2706 pCur->aLvl = aNew; 2707 pCur->nLvl = nNew; 2708 } 2709 pCur->iLvl = iNew; 2710 pLvl = &pCur->aLvl[iNew]; 2711 2712 pLvl->zDir = pCur->zPath; 2713 pCur->zPath = 0; 2714 pLvl->pDir = opendir(pLvl->zDir); 2715 if( pLvl->pDir==0 ){ 2716 fsdirSetErrmsg(pCur, "cannot read directory: %s", pCur->zPath); 2717 return SQLITE_ERROR; 2718 } 2719 } 2720 2721 while( pCur->iLvl>=0 ){ 2722 FsdirLevel *pLvl = &pCur->aLvl[pCur->iLvl]; 2723 struct dirent *pEntry = readdir(pLvl->pDir); 2724 if( pEntry ){ 2725 if( pEntry->d_name[0]=='.' ){ 2726 if( pEntry->d_name[1]=='.' && pEntry->d_name[2]=='\0' ) continue; 2727 if( pEntry->d_name[1]=='\0' ) continue; 2728 } 2729 sqlite3_free(pCur->zPath); 2730 pCur->zPath = sqlite3_mprintf("%s/%s", pLvl->zDir, pEntry->d_name); 2731 if( pCur->zPath==0 ) return SQLITE_NOMEM; 2732 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ 2733 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); 2734 return SQLITE_ERROR; 2735 } 2736 return SQLITE_OK; 2737 } 2738 closedir(pLvl->pDir); 2739 sqlite3_free(pLvl->zDir); 2740 pLvl->pDir = 0; 2741 pLvl->zDir = 0; 2742 pCur->iLvl--; 2743 } 2744 2745 /* EOF */ 2746 sqlite3_free(pCur->zPath); 2747 pCur->zPath = 0; 2748 return SQLITE_OK; 2749 } 2750 2751 /* 2752 ** Return values of columns for the row at which the series_cursor 2753 ** is currently pointing. 2754 */ 2755 static int fsdirColumn( 2756 sqlite3_vtab_cursor *cur, /* The cursor */ 2757 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 2758 int i /* Which column to return */ 2759 ){ 2760 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2761 switch( i ){ 2762 case FSDIR_COLUMN_NAME: { 2763 sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT); 2764 break; 2765 } 2766 2767 case FSDIR_COLUMN_MODE: 2768 sqlite3_result_int64(ctx, pCur->sStat.st_mode); 2769 break; 2770 2771 case FSDIR_COLUMN_MTIME: 2772 sqlite3_result_int64(ctx, pCur->sStat.st_mtime); 2773 break; 2774 2775 case FSDIR_COLUMN_DATA: { 2776 mode_t m = pCur->sStat.st_mode; 2777 if( S_ISDIR(m) ){ 2778 sqlite3_result_null(ctx); 2779 #if !defined(_WIN32) && !defined(WIN32) 2780 }else if( S_ISLNK(m) ){ 2781 char aStatic[64]; 2782 char *aBuf = aStatic; 2783 sqlite3_int64 nBuf = 64; 2784 int n; 2785 2786 while( 1 ){ 2787 n = readlink(pCur->zPath, aBuf, nBuf); 2788 if( n<nBuf ) break; 2789 if( aBuf!=aStatic ) sqlite3_free(aBuf); 2790 nBuf = nBuf*2; 2791 aBuf = sqlite3_malloc64(nBuf); 2792 if( aBuf==0 ){ 2793 sqlite3_result_error_nomem(ctx); 2794 return SQLITE_NOMEM; 2795 } 2796 } 2797 2798 sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT); 2799 if( aBuf!=aStatic ) sqlite3_free(aBuf); 2800 #endif 2801 }else{ 2802 readFileContents(ctx, pCur->zPath); 2803 } 2804 } 2805 case FSDIR_COLUMN_PATH: 2806 default: { 2807 /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters. 2808 ** always return their values as NULL */ 2809 break; 2810 } 2811 } 2812 return SQLITE_OK; 2813 } 2814 2815 /* 2816 ** Return the rowid for the current row. In this implementation, the 2817 ** first row returned is assigned rowid value 1, and each subsequent 2818 ** row a value 1 more than that of the previous. 2819 */ 2820 static int fsdirRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 2821 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2822 *pRowid = pCur->iRowid; 2823 return SQLITE_OK; 2824 } 2825 2826 /* 2827 ** Return TRUE if the cursor has been moved off of the last 2828 ** row of output. 2829 */ 2830 static int fsdirEof(sqlite3_vtab_cursor *cur){ 2831 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2832 return (pCur->zPath==0); 2833 } 2834 2835 /* 2836 ** xFilter callback. 2837 ** 2838 ** idxNum==1 PATH parameter only 2839 ** idxNum==2 Both PATH and DIR supplied 2840 */ 2841 static int fsdirFilter( 2842 sqlite3_vtab_cursor *cur, 2843 int idxNum, const char *idxStr, 2844 int argc, sqlite3_value **argv 2845 ){ 2846 const char *zDir = 0; 2847 fsdir_cursor *pCur = (fsdir_cursor*)cur; 2848 (void)idxStr; 2849 fsdirResetCursor(pCur); 2850 2851 if( idxNum==0 ){ 2852 fsdirSetErrmsg(pCur, "table function fsdir requires an argument"); 2853 return SQLITE_ERROR; 2854 } 2855 2856 assert( argc==idxNum && (argc==1 || argc==2) ); 2857 zDir = (const char*)sqlite3_value_text(argv[0]); 2858 if( zDir==0 ){ 2859 fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument"); 2860 return SQLITE_ERROR; 2861 } 2862 if( argc==2 ){ 2863 pCur->zBase = (const char*)sqlite3_value_text(argv[1]); 2864 } 2865 if( pCur->zBase ){ 2866 pCur->nBase = (int)strlen(pCur->zBase)+1; 2867 pCur->zPath = sqlite3_mprintf("%s/%s", pCur->zBase, zDir); 2868 }else{ 2869 pCur->zPath = sqlite3_mprintf("%s", zDir); 2870 } 2871 2872 if( pCur->zPath==0 ){ 2873 return SQLITE_NOMEM; 2874 } 2875 if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ 2876 fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); 2877 return SQLITE_ERROR; 2878 } 2879 2880 return SQLITE_OK; 2881 } 2882 2883 /* 2884 ** SQLite will invoke this method one or more times while planning a query 2885 ** that uses the generate_series virtual table. This routine needs to create 2886 ** a query plan for each invocation and compute an estimated cost for that 2887 ** plan. 2888 ** 2889 ** In this implementation idxNum is used to represent the 2890 ** query plan. idxStr is unused. 2891 ** 2892 ** The query plan is represented by values of idxNum: 2893 ** 2894 ** (1) The path value is supplied by argv[0] 2895 ** (2) Path is in argv[0] and dir is in argv[1] 2896 */ 2897 static int fsdirBestIndex( 2898 sqlite3_vtab *tab, 2899 sqlite3_index_info *pIdxInfo 2900 ){ 2901 int i; /* Loop over constraints */ 2902 int idxPath = -1; /* Index in pIdxInfo->aConstraint of PATH= */ 2903 int idxDir = -1; /* Index in pIdxInfo->aConstraint of DIR= */ 2904 int seenPath = 0; /* True if an unusable PATH= constraint is seen */ 2905 int seenDir = 0; /* True if an unusable DIR= constraint is seen */ 2906 const struct sqlite3_index_constraint *pConstraint; 2907 2908 (void)tab; 2909 pConstraint = pIdxInfo->aConstraint; 2910 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 2911 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 2912 switch( pConstraint->iColumn ){ 2913 case FSDIR_COLUMN_PATH: { 2914 if( pConstraint->usable ){ 2915 idxPath = i; 2916 seenPath = 0; 2917 }else if( idxPath<0 ){ 2918 seenPath = 1; 2919 } 2920 break; 2921 } 2922 case FSDIR_COLUMN_DIR: { 2923 if( pConstraint->usable ){ 2924 idxDir = i; 2925 seenDir = 0; 2926 }else if( idxDir<0 ){ 2927 seenDir = 1; 2928 } 2929 break; 2930 } 2931 } 2932 } 2933 if( seenPath || seenDir ){ 2934 /* If input parameters are unusable, disallow this plan */ 2935 return SQLITE_CONSTRAINT; 2936 } 2937 2938 if( idxPath<0 ){ 2939 pIdxInfo->idxNum = 0; 2940 /* The pIdxInfo->estimatedCost should have been initialized to a huge 2941 ** number. Leave it unchanged. */ 2942 pIdxInfo->estimatedRows = 0x7fffffff; 2943 }else{ 2944 pIdxInfo->aConstraintUsage[idxPath].omit = 1; 2945 pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1; 2946 if( idxDir>=0 ){ 2947 pIdxInfo->aConstraintUsage[idxDir].omit = 1; 2948 pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2; 2949 pIdxInfo->idxNum = 2; 2950 pIdxInfo->estimatedCost = 10.0; 2951 }else{ 2952 pIdxInfo->idxNum = 1; 2953 pIdxInfo->estimatedCost = 100.0; 2954 } 2955 } 2956 2957 return SQLITE_OK; 2958 } 2959 2960 /* 2961 ** Register the "fsdir" virtual table. 2962 */ 2963 static int fsdirRegister(sqlite3 *db){ 2964 static sqlite3_module fsdirModule = { 2965 0, /* iVersion */ 2966 0, /* xCreate */ 2967 fsdirConnect, /* xConnect */ 2968 fsdirBestIndex, /* xBestIndex */ 2969 fsdirDisconnect, /* xDisconnect */ 2970 0, /* xDestroy */ 2971 fsdirOpen, /* xOpen - open a cursor */ 2972 fsdirClose, /* xClose - close a cursor */ 2973 fsdirFilter, /* xFilter - configure scan constraints */ 2974 fsdirNext, /* xNext - advance a cursor */ 2975 fsdirEof, /* xEof - check for end of scan */ 2976 fsdirColumn, /* xColumn - read data */ 2977 fsdirRowid, /* xRowid - read data */ 2978 0, /* xUpdate */ 2979 0, /* xBegin */ 2980 0, /* xSync */ 2981 0, /* xCommit */ 2982 0, /* xRollback */ 2983 0, /* xFindMethod */ 2984 0, /* xRename */ 2985 0, /* xSavepoint */ 2986 0, /* xRelease */ 2987 0, /* xRollbackTo */ 2988 0, /* xShadowName */ 2989 }; 2990 2991 int rc = sqlite3_create_module(db, "fsdir", &fsdirModule, 0); 2992 return rc; 2993 } 2994 #else /* SQLITE_OMIT_VIRTUALTABLE */ 2995 # define fsdirRegister(x) SQLITE_OK 2996 #endif 2997 2998 #ifdef _WIN32 2999 3000 #endif 3001 int sqlite3_fileio_init( 3002 sqlite3 *db, 3003 char **pzErrMsg, 3004 const sqlite3_api_routines *pApi 3005 ){ 3006 int rc = SQLITE_OK; 3007 SQLITE_EXTENSION_INIT2(pApi); 3008 (void)pzErrMsg; /* Unused parameter */ 3009 rc = sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0, 3010 readfileFunc, 0, 0); 3011 if( rc==SQLITE_OK ){ 3012 rc = sqlite3_create_function(db, "writefile", -1, SQLITE_UTF8, 0, 3013 writefileFunc, 0, 0); 3014 } 3015 if( rc==SQLITE_OK ){ 3016 rc = sqlite3_create_function(db, "lsmode", 1, SQLITE_UTF8, 0, 3017 lsModeFunc, 0, 0); 3018 } 3019 if( rc==SQLITE_OK ){ 3020 rc = fsdirRegister(db); 3021 } 3022 return rc; 3023 } 3024 3025 /************************* End ../ext/misc/fileio.c ********************/ 3026 /************************* Begin ../ext/misc/completion.c ******************/ 3027 /* 3028 ** 2017-07-10 3029 ** 3030 ** The author disclaims copyright to this source code. In place of 3031 ** a legal notice, here is a blessing: 3032 ** 3033 ** May you do good and not evil. 3034 ** May you find forgiveness for yourself and forgive others. 3035 ** May you share freely, never taking more than you give. 3036 ** 3037 ************************************************************************* 3038 ** 3039 ** This file implements an eponymous virtual table that returns suggested 3040 ** completions for a partial SQL input. 3041 ** 3042 ** Suggested usage: 3043 ** 3044 ** SELECT DISTINCT candidate COLLATE nocase 3045 ** FROM completion($prefix,$wholeline) 3046 ** ORDER BY 1; 3047 ** 3048 ** The two query parameters are optional. $prefix is the text of the 3049 ** current word being typed and that is to be completed. $wholeline is 3050 ** the complete input line, used for context. 3051 ** 3052 ** The raw completion() table might return the same candidate multiple 3053 ** times, for example if the same column name is used to two or more 3054 ** tables. And the candidates are returned in an arbitrary order. Hence, 3055 ** the DISTINCT and ORDER BY are recommended. 3056 ** 3057 ** This virtual table operates at the speed of human typing, and so there 3058 ** is no attempt to make it fast. Even a slow implementation will be much 3059 ** faster than any human can type. 3060 ** 3061 */ 3062 /* #include "sqlite3ext.h" */ 3063 SQLITE_EXTENSION_INIT1 3064 #include <assert.h> 3065 #include <string.h> 3066 #include <ctype.h> 3067 3068 #ifndef SQLITE_OMIT_VIRTUALTABLE 3069 3070 /* completion_vtab is a subclass of sqlite3_vtab which will 3071 ** serve as the underlying representation of a completion virtual table 3072 */ 3073 typedef struct completion_vtab completion_vtab; 3074 struct completion_vtab { 3075 sqlite3_vtab base; /* Base class - must be first */ 3076 sqlite3 *db; /* Database connection for this completion vtab */ 3077 }; 3078 3079 /* completion_cursor is a subclass of sqlite3_vtab_cursor which will 3080 ** serve as the underlying representation of a cursor that scans 3081 ** over rows of the result 3082 */ 3083 typedef struct completion_cursor completion_cursor; 3084 struct completion_cursor { 3085 sqlite3_vtab_cursor base; /* Base class - must be first */ 3086 sqlite3 *db; /* Database connection for this cursor */ 3087 int nPrefix, nLine; /* Number of bytes in zPrefix and zLine */ 3088 char *zPrefix; /* The prefix for the word we want to complete */ 3089 char *zLine; /* The whole that we want to complete */ 3090 const char *zCurrentRow; /* Current output row */ 3091 int szRow; /* Length of the zCurrentRow string */ 3092 sqlite3_stmt *pStmt; /* Current statement */ 3093 sqlite3_int64 iRowid; /* The rowid */ 3094 int ePhase; /* Current phase */ 3095 int j; /* inter-phase counter */ 3096 }; 3097 3098 /* Values for ePhase: 3099 */ 3100 #define COMPLETION_FIRST_PHASE 1 3101 #define COMPLETION_KEYWORDS 1 3102 #define COMPLETION_PRAGMAS 2 3103 #define COMPLETION_FUNCTIONS 3 3104 #define COMPLETION_COLLATIONS 4 3105 #define COMPLETION_INDEXES 5 3106 #define COMPLETION_TRIGGERS 6 3107 #define COMPLETION_DATABASES 7 3108 #define COMPLETION_TABLES 8 /* Also VIEWs and TRIGGERs */ 3109 #define COMPLETION_COLUMNS 9 3110 #define COMPLETION_MODULES 10 3111 #define COMPLETION_EOF 11 3112 3113 /* 3114 ** The completionConnect() method is invoked to create a new 3115 ** completion_vtab that describes the completion virtual table. 3116 ** 3117 ** Think of this routine as the constructor for completion_vtab objects. 3118 ** 3119 ** All this routine needs to do is: 3120 ** 3121 ** (1) Allocate the completion_vtab object and initialize all fields. 3122 ** 3123 ** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the 3124 ** result set of queries against completion will look like. 3125 */ 3126 static int completionConnect( 3127 sqlite3 *db, 3128 void *pAux, 3129 int argc, const char *const*argv, 3130 sqlite3_vtab **ppVtab, 3131 char **pzErr 3132 ){ 3133 completion_vtab *pNew; 3134 int rc; 3135 3136 (void)(pAux); /* Unused parameter */ 3137 (void)(argc); /* Unused parameter */ 3138 (void)(argv); /* Unused parameter */ 3139 (void)(pzErr); /* Unused parameter */ 3140 3141 /* Column numbers */ 3142 #define COMPLETION_COLUMN_CANDIDATE 0 /* Suggested completion of the input */ 3143 #define COMPLETION_COLUMN_PREFIX 1 /* Prefix of the word to be completed */ 3144 #define COMPLETION_COLUMN_WHOLELINE 2 /* Entire line seen so far */ 3145 #define COMPLETION_COLUMN_PHASE 3 /* ePhase - used for debugging only */ 3146 3147 rc = sqlite3_declare_vtab(db, 3148 "CREATE TABLE x(" 3149 " candidate TEXT," 3150 " prefix TEXT HIDDEN," 3151 " wholeline TEXT HIDDEN," 3152 " phase INT HIDDEN" /* Used for debugging only */ 3153 ")"); 3154 if( rc==SQLITE_OK ){ 3155 pNew = sqlite3_malloc( sizeof(*pNew) ); 3156 *ppVtab = (sqlite3_vtab*)pNew; 3157 if( pNew==0 ) return SQLITE_NOMEM; 3158 memset(pNew, 0, sizeof(*pNew)); 3159 pNew->db = db; 3160 } 3161 return rc; 3162 } 3163 3164 /* 3165 ** This method is the destructor for completion_cursor objects. 3166 */ 3167 static int completionDisconnect(sqlite3_vtab *pVtab){ 3168 sqlite3_free(pVtab); 3169 return SQLITE_OK; 3170 } 3171 3172 /* 3173 ** Constructor for a new completion_cursor object. 3174 */ 3175 static int completionOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 3176 completion_cursor *pCur; 3177 pCur = sqlite3_malloc( sizeof(*pCur) ); 3178 if( pCur==0 ) return SQLITE_NOMEM; 3179 memset(pCur, 0, sizeof(*pCur)); 3180 pCur->db = ((completion_vtab*)p)->db; 3181 *ppCursor = &pCur->base; 3182 return SQLITE_OK; 3183 } 3184 3185 /* 3186 ** Reset the completion_cursor. 3187 */ 3188 static void completionCursorReset(completion_cursor *pCur){ 3189 sqlite3_free(pCur->zPrefix); pCur->zPrefix = 0; pCur->nPrefix = 0; 3190 sqlite3_free(pCur->zLine); pCur->zLine = 0; pCur->nLine = 0; 3191 sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0; 3192 pCur->j = 0; 3193 } 3194 3195 /* 3196 ** Destructor for a completion_cursor. 3197 */ 3198 static int completionClose(sqlite3_vtab_cursor *cur){ 3199 completionCursorReset((completion_cursor*)cur); 3200 sqlite3_free(cur); 3201 return SQLITE_OK; 3202 } 3203 3204 /* 3205 ** Advance a completion_cursor to its next row of output. 3206 ** 3207 ** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object 3208 ** record the current state of the scan. This routine sets ->zCurrentRow 3209 ** to the current row of output and then returns. If no more rows remain, 3210 ** then ->ePhase is set to COMPLETION_EOF which will signal the virtual 3211 ** table that has reached the end of its scan. 3212 ** 3213 ** The current implementation just lists potential identifiers and 3214 ** keywords and filters them by zPrefix. Future enhancements should 3215 ** take zLine into account to try to restrict the set of identifiers and 3216 ** keywords based on what would be legal at the current point of input. 3217 */ 3218 static int completionNext(sqlite3_vtab_cursor *cur){ 3219 completion_cursor *pCur = (completion_cursor*)cur; 3220 int eNextPhase = 0; /* Next phase to try if current phase reaches end */ 3221 int iCol = -1; /* If >=0, step pCur->pStmt and use the i-th column */ 3222 pCur->iRowid++; 3223 while( pCur->ePhase!=COMPLETION_EOF ){ 3224 switch( pCur->ePhase ){ 3225 case COMPLETION_KEYWORDS: { 3226 if( pCur->j >= sqlite3_keyword_count() ){ 3227 pCur->zCurrentRow = 0; 3228 pCur->ePhase = COMPLETION_DATABASES; 3229 }else{ 3230 sqlite3_keyword_name(pCur->j++, &pCur->zCurrentRow, &pCur->szRow); 3231 } 3232 iCol = -1; 3233 break; 3234 } 3235 case COMPLETION_DATABASES: { 3236 if( pCur->pStmt==0 ){ 3237 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, 3238 &pCur->pStmt, 0); 3239 } 3240 iCol = 1; 3241 eNextPhase = COMPLETION_TABLES; 3242 break; 3243 } 3244 case COMPLETION_TABLES: { 3245 if( pCur->pStmt==0 ){ 3246 sqlite3_stmt *pS2; 3247 char *zSql = 0; 3248 const char *zSep = ""; 3249 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); 3250 while( sqlite3_step(pS2)==SQLITE_ROW ){ 3251 const char *zDb = (const char*)sqlite3_column_text(pS2, 1); 3252 zSql = sqlite3_mprintf( 3253 "%z%s" 3254 "SELECT name FROM \"%w\".sqlite_master", 3255 zSql, zSep, zDb 3256 ); 3257 if( zSql==0 ) return SQLITE_NOMEM; 3258 zSep = " UNION "; 3259 } 3260 sqlite3_finalize(pS2); 3261 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); 3262 sqlite3_free(zSql); 3263 } 3264 iCol = 0; 3265 eNextPhase = COMPLETION_COLUMNS; 3266 break; 3267 } 3268 case COMPLETION_COLUMNS: { 3269 if( pCur->pStmt==0 ){ 3270 sqlite3_stmt *pS2; 3271 char *zSql = 0; 3272 const char *zSep = ""; 3273 sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); 3274 while( sqlite3_step(pS2)==SQLITE_ROW ){ 3275 const char *zDb = (const char*)sqlite3_column_text(pS2, 1); 3276 zSql = sqlite3_mprintf( 3277 "%z%s" 3278 "SELECT pti.name FROM \"%w\".sqlite_master AS sm" 3279 " JOIN pragma_table_info(sm.name,%Q) AS pti" 3280 " WHERE sm.type='table'", 3281 zSql, zSep, zDb, zDb 3282 ); 3283 if( zSql==0 ) return SQLITE_NOMEM; 3284 zSep = " UNION "; 3285 } 3286 sqlite3_finalize(pS2); 3287 sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); 3288 sqlite3_free(zSql); 3289 } 3290 iCol = 0; 3291 eNextPhase = COMPLETION_EOF; 3292 break; 3293 } 3294 } 3295 if( iCol<0 ){ 3296 /* This case is when the phase presets zCurrentRow */ 3297 if( pCur->zCurrentRow==0 ) continue; 3298 }else{ 3299 if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){ 3300 /* Extract the next row of content */ 3301 pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol); 3302 pCur->szRow = sqlite3_column_bytes(pCur->pStmt, iCol); 3303 }else{ 3304 /* When all rows are finished, advance to the next phase */ 3305 sqlite3_finalize(pCur->pStmt); 3306 pCur->pStmt = 0; 3307 pCur->ePhase = eNextPhase; 3308 continue; 3309 } 3310 } 3311 if( pCur->nPrefix==0 ) break; 3312 if( pCur->nPrefix<=pCur->szRow 3313 && sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0 3314 ){ 3315 break; 3316 } 3317 } 3318 3319 return SQLITE_OK; 3320 } 3321 3322 /* 3323 ** Return values of columns for the row at which the completion_cursor 3324 ** is currently pointing. 3325 */ 3326 static int completionColumn( 3327 sqlite3_vtab_cursor *cur, /* The cursor */ 3328 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 3329 int i /* Which column to return */ 3330 ){ 3331 completion_cursor *pCur = (completion_cursor*)cur; 3332 switch( i ){ 3333 case COMPLETION_COLUMN_CANDIDATE: { 3334 sqlite3_result_text(ctx, pCur->zCurrentRow, pCur->szRow,SQLITE_TRANSIENT); 3335 break; 3336 } 3337 case COMPLETION_COLUMN_PREFIX: { 3338 sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT); 3339 break; 3340 } 3341 case COMPLETION_COLUMN_WHOLELINE: { 3342 sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT); 3343 break; 3344 } 3345 case COMPLETION_COLUMN_PHASE: { 3346 sqlite3_result_int(ctx, pCur->ePhase); 3347 break; 3348 } 3349 } 3350 return SQLITE_OK; 3351 } 3352 3353 /* 3354 ** Return the rowid for the current row. In this implementation, the 3355 ** rowid is the same as the output value. 3356 */ 3357 static int completionRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 3358 completion_cursor *pCur = (completion_cursor*)cur; 3359 *pRowid = pCur->iRowid; 3360 return SQLITE_OK; 3361 } 3362 3363 /* 3364 ** Return TRUE if the cursor has been moved off of the last 3365 ** row of output. 3366 */ 3367 static int completionEof(sqlite3_vtab_cursor *cur){ 3368 completion_cursor *pCur = (completion_cursor*)cur; 3369 return pCur->ePhase >= COMPLETION_EOF; 3370 } 3371 3372 /* 3373 ** This method is called to "rewind" the completion_cursor object back 3374 ** to the first row of output. This method is always called at least 3375 ** once prior to any call to completionColumn() or completionRowid() or 3376 ** completionEof(). 3377 */ 3378 static int completionFilter( 3379 sqlite3_vtab_cursor *pVtabCursor, 3380 int idxNum, const char *idxStr, 3381 int argc, sqlite3_value **argv 3382 ){ 3383 completion_cursor *pCur = (completion_cursor *)pVtabCursor; 3384 int iArg = 0; 3385 (void)(idxStr); /* Unused parameter */ 3386 (void)(argc); /* Unused parameter */ 3387 completionCursorReset(pCur); 3388 if( idxNum & 1 ){ 3389 pCur->nPrefix = sqlite3_value_bytes(argv[iArg]); 3390 if( pCur->nPrefix>0 ){ 3391 pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); 3392 if( pCur->zPrefix==0 ) return SQLITE_NOMEM; 3393 } 3394 iArg = 1; 3395 } 3396 if( idxNum & 2 ){ 3397 pCur->nLine = sqlite3_value_bytes(argv[iArg]); 3398 if( pCur->nLine>0 ){ 3399 pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); 3400 if( pCur->zLine==0 ) return SQLITE_NOMEM; 3401 } 3402 } 3403 if( pCur->zLine!=0 && pCur->zPrefix==0 ){ 3404 int i = pCur->nLine; 3405 while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){ 3406 i--; 3407 } 3408 pCur->nPrefix = pCur->nLine - i; 3409 if( pCur->nPrefix>0 ){ 3410 pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i); 3411 if( pCur->zPrefix==0 ) return SQLITE_NOMEM; 3412 } 3413 } 3414 pCur->iRowid = 0; 3415 pCur->ePhase = COMPLETION_FIRST_PHASE; 3416 return completionNext(pVtabCursor); 3417 } 3418 3419 /* 3420 ** SQLite will invoke this method one or more times while planning a query 3421 ** that uses the completion virtual table. This routine needs to create 3422 ** a query plan for each invocation and compute an estimated cost for that 3423 ** plan. 3424 ** 3425 ** There are two hidden parameters that act as arguments to the table-valued 3426 ** function: "prefix" and "wholeline". Bit 0 of idxNum is set if "prefix" 3427 ** is available and bit 1 is set if "wholeline" is available. 3428 */ 3429 static int completionBestIndex( 3430 sqlite3_vtab *tab, 3431 sqlite3_index_info *pIdxInfo 3432 ){ 3433 int i; /* Loop over constraints */ 3434 int idxNum = 0; /* The query plan bitmask */ 3435 int prefixIdx = -1; /* Index of the start= constraint, or -1 if none */ 3436 int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */ 3437 int nArg = 0; /* Number of arguments that completeFilter() expects */ 3438 const struct sqlite3_index_constraint *pConstraint; 3439 3440 (void)(tab); /* Unused parameter */ 3441 pConstraint = pIdxInfo->aConstraint; 3442 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 3443 if( pConstraint->usable==0 ) continue; 3444 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 3445 switch( pConstraint->iColumn ){ 3446 case COMPLETION_COLUMN_PREFIX: 3447 prefixIdx = i; 3448 idxNum |= 1; 3449 break; 3450 case COMPLETION_COLUMN_WHOLELINE: 3451 wholelineIdx = i; 3452 idxNum |= 2; 3453 break; 3454 } 3455 } 3456 if( prefixIdx>=0 ){ 3457 pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg; 3458 pIdxInfo->aConstraintUsage[prefixIdx].omit = 1; 3459 } 3460 if( wholelineIdx>=0 ){ 3461 pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg; 3462 pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1; 3463 } 3464 pIdxInfo->idxNum = idxNum; 3465 pIdxInfo->estimatedCost = (double)5000 - 1000*nArg; 3466 pIdxInfo->estimatedRows = 500 - 100*nArg; 3467 return SQLITE_OK; 3468 } 3469 3470 /* 3471 ** This following structure defines all the methods for the 3472 ** completion virtual table. 3473 */ 3474 static sqlite3_module completionModule = { 3475 0, /* iVersion */ 3476 0, /* xCreate */ 3477 completionConnect, /* xConnect */ 3478 completionBestIndex, /* xBestIndex */ 3479 completionDisconnect, /* xDisconnect */ 3480 0, /* xDestroy */ 3481 completionOpen, /* xOpen - open a cursor */ 3482 completionClose, /* xClose - close a cursor */ 3483 completionFilter, /* xFilter - configure scan constraints */ 3484 completionNext, /* xNext - advance a cursor */ 3485 completionEof, /* xEof - check for end of scan */ 3486 completionColumn, /* xColumn - read data */ 3487 completionRowid, /* xRowid - read data */ 3488 0, /* xUpdate */ 3489 0, /* xBegin */ 3490 0, /* xSync */ 3491 0, /* xCommit */ 3492 0, /* xRollback */ 3493 0, /* xFindMethod */ 3494 0, /* xRename */ 3495 0, /* xSavepoint */ 3496 0, /* xRelease */ 3497 0, /* xRollbackTo */ 3498 0 /* xShadowName */ 3499 }; 3500 3501 #endif /* SQLITE_OMIT_VIRTUALTABLE */ 3502 3503 int sqlite3CompletionVtabInit(sqlite3 *db){ 3504 int rc = SQLITE_OK; 3505 #ifndef SQLITE_OMIT_VIRTUALTABLE 3506 rc = sqlite3_create_module(db, "completion", &completionModule, 0); 3507 #endif 3508 return rc; 3509 } 3510 3511 #ifdef _WIN32 3512 3513 #endif 3514 int sqlite3_completion_init( 3515 sqlite3 *db, 3516 char **pzErrMsg, 3517 const sqlite3_api_routines *pApi 3518 ){ 3519 int rc = SQLITE_OK; 3520 SQLITE_EXTENSION_INIT2(pApi); 3521 (void)(pzErrMsg); /* Unused parameter */ 3522 #ifndef SQLITE_OMIT_VIRTUALTABLE 3523 rc = sqlite3CompletionVtabInit(db); 3524 #endif 3525 return rc; 3526 } 3527 3528 /************************* End ../ext/misc/completion.c ********************/ 3529 /************************* Begin ../ext/misc/appendvfs.c ******************/ 3530 /* 3531 ** 2017-10-20 3532 ** 3533 ** The author disclaims copyright to this source code. In place of 3534 ** a legal notice, here is a blessing: 3535 ** 3536 ** May you do good and not evil. 3537 ** May you find forgiveness for yourself and forgive others. 3538 ** May you share freely, never taking more than you give. 3539 ** 3540 ****************************************************************************** 3541 ** 3542 ** This file implements a VFS shim that allows an SQLite database to be 3543 ** appended onto the end of some other file, such as an executable. 3544 ** 3545 ** A special record must appear at the end of the file that identifies the 3546 ** file as an appended database and provides an offset to page 1. For 3547 ** best performance page 1 should be located at a disk page boundary, though 3548 ** that is not required. 3549 ** 3550 ** When opening a database using this VFS, the connection might treat 3551 ** the file as an ordinary SQLite database, or it might treat is as a 3552 ** database appended onto some other file. Here are the rules: 3553 ** 3554 ** (1) When opening a new empty file, that file is treated as an ordinary 3555 ** database. 3556 ** 3557 ** (2) When opening a file that begins with the standard SQLite prefix 3558 ** string "SQLite format 3", that file is treated as an ordinary 3559 ** database. 3560 ** 3561 ** (3) When opening a file that ends with the appendvfs trailer string 3562 ** "Start-Of-SQLite3-NNNNNNNN" that file is treated as an appended 3563 ** database. 3564 ** 3565 ** (4) If none of the above apply and the SQLITE_OPEN_CREATE flag is 3566 ** set, then a new database is appended to the already existing file. 3567 ** 3568 ** (5) Otherwise, SQLITE_CANTOPEN is returned. 3569 ** 3570 ** To avoid unnecessary complications with the PENDING_BYTE, the size of 3571 ** the file containing the database is limited to 1GB. This VFS will refuse 3572 ** to read or write past the 1GB mark. This restriction might be lifted in 3573 ** future versions. For now, if you need a large database, then keep the 3574 ** database in a separate file. 3575 ** 3576 ** If the file being opened is not an appended database, then this shim is 3577 ** a pass-through into the default underlying VFS. 3578 **/ 3579 /* #include "sqlite3ext.h" */ 3580 SQLITE_EXTENSION_INIT1 3581 #include <string.h> 3582 #include <assert.h> 3583 3584 /* The append mark at the end of the database is: 3585 ** 3586 ** Start-Of-SQLite3-NNNNNNNN 3587 ** 123456789 123456789 12345 3588 ** 3589 ** The NNNNNNNN represents a 64-bit big-endian unsigned integer which is 3590 ** the offset to page 1. 3591 */ 3592 #define APND_MARK_PREFIX "Start-Of-SQLite3-" 3593 #define APND_MARK_PREFIX_SZ 17 3594 #define APND_MARK_SIZE 25 3595 3596 /* 3597 ** Maximum size of the combined prefix + database + append-mark. This 3598 ** must be less than 0x40000000 to avoid locking issues on Windows. 3599 */ 3600 #define APND_MAX_SIZE (65536*15259) 3601 3602 /* 3603 ** Forward declaration of objects used by this utility 3604 */ 3605 typedef struct sqlite3_vfs ApndVfs; 3606 typedef struct ApndFile ApndFile; 3607 3608 /* Access to a lower-level VFS that (might) implement dynamic loading, 3609 ** access to randomness, etc. 3610 */ 3611 #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) 3612 #define ORIGFILE(p) ((sqlite3_file*)(((ApndFile*)(p))+1)) 3613 3614 /* An open file */ 3615 struct ApndFile { 3616 sqlite3_file base; /* IO methods */ 3617 sqlite3_int64 iPgOne; /* File offset to page 1 */ 3618 sqlite3_int64 iMark; /* Start of the append-mark */ 3619 }; 3620 3621 /* 3622 ** Methods for ApndFile 3623 */ 3624 static int apndClose(sqlite3_file*); 3625 static int apndRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); 3626 static int apndWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); 3627 static int apndTruncate(sqlite3_file*, sqlite3_int64 size); 3628 static int apndSync(sqlite3_file*, int flags); 3629 static int apndFileSize(sqlite3_file*, sqlite3_int64 *pSize); 3630 static int apndLock(sqlite3_file*, int); 3631 static int apndUnlock(sqlite3_file*, int); 3632 static int apndCheckReservedLock(sqlite3_file*, int *pResOut); 3633 static int apndFileControl(sqlite3_file*, int op, void *pArg); 3634 static int apndSectorSize(sqlite3_file*); 3635 static int apndDeviceCharacteristics(sqlite3_file*); 3636 static int apndShmMap(sqlite3_file*, int iPg, int pgsz, int, void volatile**); 3637 static int apndShmLock(sqlite3_file*, int offset, int n, int flags); 3638 static void apndShmBarrier(sqlite3_file*); 3639 static int apndShmUnmap(sqlite3_file*, int deleteFlag); 3640 static int apndFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); 3641 static int apndUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); 3642 3643 /* 3644 ** Methods for ApndVfs 3645 */ 3646 static int apndOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); 3647 static int apndDelete(sqlite3_vfs*, const char *zName, int syncDir); 3648 static int apndAccess(sqlite3_vfs*, const char *zName, int flags, int *); 3649 static int apndFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); 3650 static void *apndDlOpen(sqlite3_vfs*, const char *zFilename); 3651 static void apndDlError(sqlite3_vfs*, int nByte, char *zErrMsg); 3652 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); 3653 static void apndDlClose(sqlite3_vfs*, void*); 3654 static int apndRandomness(sqlite3_vfs*, int nByte, char *zOut); 3655 static int apndSleep(sqlite3_vfs*, int microseconds); 3656 static int apndCurrentTime(sqlite3_vfs*, double*); 3657 static int apndGetLastError(sqlite3_vfs*, int, char *); 3658 static int apndCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); 3659 static int apndSetSystemCall(sqlite3_vfs*, const char*,sqlite3_syscall_ptr); 3660 static sqlite3_syscall_ptr apndGetSystemCall(sqlite3_vfs*, const char *z); 3661 static const char *apndNextSystemCall(sqlite3_vfs*, const char *zName); 3662 3663 static sqlite3_vfs apnd_vfs = { 3664 3, /* iVersion (set when registered) */ 3665 0, /* szOsFile (set when registered) */ 3666 1024, /* mxPathname */ 3667 0, /* pNext */ 3668 "apndvfs", /* zName */ 3669 0, /* pAppData (set when registered) */ 3670 apndOpen, /* xOpen */ 3671 apndDelete, /* xDelete */ 3672 apndAccess, /* xAccess */ 3673 apndFullPathname, /* xFullPathname */ 3674 apndDlOpen, /* xDlOpen */ 3675 apndDlError, /* xDlError */ 3676 apndDlSym, /* xDlSym */ 3677 apndDlClose, /* xDlClose */ 3678 apndRandomness, /* xRandomness */ 3679 apndSleep, /* xSleep */ 3680 apndCurrentTime, /* xCurrentTime */ 3681 apndGetLastError, /* xGetLastError */ 3682 apndCurrentTimeInt64, /* xCurrentTimeInt64 */ 3683 apndSetSystemCall, /* xSetSystemCall */ 3684 apndGetSystemCall, /* xGetSystemCall */ 3685 apndNextSystemCall /* xNextSystemCall */ 3686 }; 3687 3688 static const sqlite3_io_methods apnd_io_methods = { 3689 3, /* iVersion */ 3690 apndClose, /* xClose */ 3691 apndRead, /* xRead */ 3692 apndWrite, /* xWrite */ 3693 apndTruncate, /* xTruncate */ 3694 apndSync, /* xSync */ 3695 apndFileSize, /* xFileSize */ 3696 apndLock, /* xLock */ 3697 apndUnlock, /* xUnlock */ 3698 apndCheckReservedLock, /* xCheckReservedLock */ 3699 apndFileControl, /* xFileControl */ 3700 apndSectorSize, /* xSectorSize */ 3701 apndDeviceCharacteristics, /* xDeviceCharacteristics */ 3702 apndShmMap, /* xShmMap */ 3703 apndShmLock, /* xShmLock */ 3704 apndShmBarrier, /* xShmBarrier */ 3705 apndShmUnmap, /* xShmUnmap */ 3706 apndFetch, /* xFetch */ 3707 apndUnfetch /* xUnfetch */ 3708 }; 3709 3710 3711 3712 /* 3713 ** Close an apnd-file. 3714 */ 3715 static int apndClose(sqlite3_file *pFile){ 3716 pFile = ORIGFILE(pFile); 3717 return pFile->pMethods->xClose(pFile); 3718 } 3719 3720 /* 3721 ** Read data from an apnd-file. 3722 */ 3723 static int apndRead( 3724 sqlite3_file *pFile, 3725 void *zBuf, 3726 int iAmt, 3727 sqlite_int64 iOfst 3728 ){ 3729 ApndFile *p = (ApndFile *)pFile; 3730 pFile = ORIGFILE(pFile); 3731 return pFile->pMethods->xRead(pFile, zBuf, iAmt, iOfst+p->iPgOne); 3732 } 3733 3734 /* 3735 ** Add the append-mark onto the end of the file. 3736 */ 3737 static int apndWriteMark(ApndFile *p, sqlite3_file *pFile){ 3738 int i; 3739 unsigned char a[APND_MARK_SIZE]; 3740 memcpy(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ); 3741 for(i=0; i<8; i++){ 3742 a[APND_MARK_PREFIX_SZ+i] = (p->iPgOne >> (56 - i*8)) & 0xff; 3743 } 3744 return pFile->pMethods->xWrite(pFile, a, APND_MARK_SIZE, p->iMark); 3745 } 3746 3747 /* 3748 ** Write data to an apnd-file. 3749 */ 3750 static int apndWrite( 3751 sqlite3_file *pFile, 3752 const void *zBuf, 3753 int iAmt, 3754 sqlite_int64 iOfst 3755 ){ 3756 int rc; 3757 ApndFile *p = (ApndFile *)pFile; 3758 pFile = ORIGFILE(pFile); 3759 if( iOfst+iAmt>=APND_MAX_SIZE ) return SQLITE_FULL; 3760 rc = pFile->pMethods->xWrite(pFile, zBuf, iAmt, iOfst+p->iPgOne); 3761 if( rc==SQLITE_OK && iOfst + iAmt + p->iPgOne > p->iMark ){ 3762 sqlite3_int64 sz = 0; 3763 rc = pFile->pMethods->xFileSize(pFile, &sz); 3764 if( rc==SQLITE_OK ){ 3765 p->iMark = sz - APND_MARK_SIZE; 3766 if( iOfst + iAmt + p->iPgOne > p->iMark ){ 3767 p->iMark = p->iPgOne + iOfst + iAmt; 3768 rc = apndWriteMark(p, pFile); 3769 } 3770 } 3771 } 3772 return rc; 3773 } 3774 3775 /* 3776 ** Truncate an apnd-file. 3777 */ 3778 static int apndTruncate(sqlite3_file *pFile, sqlite_int64 size){ 3779 int rc; 3780 ApndFile *p = (ApndFile *)pFile; 3781 pFile = ORIGFILE(pFile); 3782 rc = pFile->pMethods->xTruncate(pFile, size+p->iPgOne+APND_MARK_SIZE); 3783 if( rc==SQLITE_OK ){ 3784 p->iMark = p->iPgOne+size; 3785 rc = apndWriteMark(p, pFile); 3786 } 3787 return rc; 3788 } 3789 3790 /* 3791 ** Sync an apnd-file. 3792 */ 3793 static int apndSync(sqlite3_file *pFile, int flags){ 3794 pFile = ORIGFILE(pFile); 3795 return pFile->pMethods->xSync(pFile, flags); 3796 } 3797 3798 /* 3799 ** Return the current file-size of an apnd-file. 3800 */ 3801 static int apndFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 3802 ApndFile *p = (ApndFile *)pFile; 3803 int rc; 3804 pFile = ORIGFILE(p); 3805 rc = pFile->pMethods->xFileSize(pFile, pSize); 3806 if( rc==SQLITE_OK && p->iPgOne ){ 3807 *pSize -= p->iPgOne + APND_MARK_SIZE; 3808 } 3809 return rc; 3810 } 3811 3812 /* 3813 ** Lock an apnd-file. 3814 */ 3815 static int apndLock(sqlite3_file *pFile, int eLock){ 3816 pFile = ORIGFILE(pFile); 3817 return pFile->pMethods->xLock(pFile, eLock); 3818 } 3819 3820 /* 3821 ** Unlock an apnd-file. 3822 */ 3823 static int apndUnlock(sqlite3_file *pFile, int eLock){ 3824 pFile = ORIGFILE(pFile); 3825 return pFile->pMethods->xUnlock(pFile, eLock); 3826 } 3827 3828 /* 3829 ** Check if another file-handle holds a RESERVED lock on an apnd-file. 3830 */ 3831 static int apndCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 3832 pFile = ORIGFILE(pFile); 3833 return pFile->pMethods->xCheckReservedLock(pFile, pResOut); 3834 } 3835 3836 /* 3837 ** File control method. For custom operations on an apnd-file. 3838 */ 3839 static int apndFileControl(sqlite3_file *pFile, int op, void *pArg){ 3840 ApndFile *p = (ApndFile *)pFile; 3841 int rc; 3842 pFile = ORIGFILE(pFile); 3843 rc = pFile->pMethods->xFileControl(pFile, op, pArg); 3844 if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){ 3845 *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", p->iPgOne, *(char**)pArg); 3846 } 3847 return rc; 3848 } 3849 3850 /* 3851 ** Return the sector-size in bytes for an apnd-file. 3852 */ 3853 static int apndSectorSize(sqlite3_file *pFile){ 3854 pFile = ORIGFILE(pFile); 3855 return pFile->pMethods->xSectorSize(pFile); 3856 } 3857 3858 /* 3859 ** Return the device characteristic flags supported by an apnd-file. 3860 */ 3861 static int apndDeviceCharacteristics(sqlite3_file *pFile){ 3862 pFile = ORIGFILE(pFile); 3863 return pFile->pMethods->xDeviceCharacteristics(pFile); 3864 } 3865 3866 /* Create a shared memory file mapping */ 3867 static int apndShmMap( 3868 sqlite3_file *pFile, 3869 int iPg, 3870 int pgsz, 3871 int bExtend, 3872 void volatile **pp 3873 ){ 3874 pFile = ORIGFILE(pFile); 3875 return pFile->pMethods->xShmMap(pFile,iPg,pgsz,bExtend,pp); 3876 } 3877 3878 /* Perform locking on a shared-memory segment */ 3879 static int apndShmLock(sqlite3_file *pFile, int offset, int n, int flags){ 3880 pFile = ORIGFILE(pFile); 3881 return pFile->pMethods->xShmLock(pFile,offset,n,flags); 3882 } 3883 3884 /* Memory barrier operation on shared memory */ 3885 static void apndShmBarrier(sqlite3_file *pFile){ 3886 pFile = ORIGFILE(pFile); 3887 pFile->pMethods->xShmBarrier(pFile); 3888 } 3889 3890 /* Unmap a shared memory segment */ 3891 static int apndShmUnmap(sqlite3_file *pFile, int deleteFlag){ 3892 pFile = ORIGFILE(pFile); 3893 return pFile->pMethods->xShmUnmap(pFile,deleteFlag); 3894 } 3895 3896 /* Fetch a page of a memory-mapped file */ 3897 static int apndFetch( 3898 sqlite3_file *pFile, 3899 sqlite3_int64 iOfst, 3900 int iAmt, 3901 void **pp 3902 ){ 3903 ApndFile *p = (ApndFile *)pFile; 3904 pFile = ORIGFILE(pFile); 3905 return pFile->pMethods->xFetch(pFile, iOfst+p->iPgOne, iAmt, pp); 3906 } 3907 3908 /* Release a memory-mapped page */ 3909 static int apndUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ 3910 ApndFile *p = (ApndFile *)pFile; 3911 pFile = ORIGFILE(pFile); 3912 return pFile->pMethods->xUnfetch(pFile, iOfst+p->iPgOne, pPage); 3913 } 3914 3915 /* 3916 ** Check to see if the file is an ordinary SQLite database file. 3917 */ 3918 static int apndIsOrdinaryDatabaseFile(sqlite3_int64 sz, sqlite3_file *pFile){ 3919 int rc; 3920 char zHdr[16]; 3921 static const char aSqliteHdr[] = "SQLite format 3"; 3922 if( sz<512 ) return 0; 3923 rc = pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), 0); 3924 if( rc ) return 0; 3925 return memcmp(zHdr, aSqliteHdr, sizeof(zHdr))==0; 3926 } 3927 3928 /* 3929 ** Try to read the append-mark off the end of a file. Return the 3930 ** start of the appended database if the append-mark is present. If 3931 ** there is no append-mark, return -1; 3932 */ 3933 static sqlite3_int64 apndReadMark(sqlite3_int64 sz, sqlite3_file *pFile){ 3934 int rc, i; 3935 sqlite3_int64 iMark; 3936 unsigned char a[APND_MARK_SIZE]; 3937 3938 if( sz<=APND_MARK_SIZE ) return -1; 3939 rc = pFile->pMethods->xRead(pFile, a, APND_MARK_SIZE, sz-APND_MARK_SIZE); 3940 if( rc ) return -1; 3941 if( memcmp(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ)!=0 ) return -1; 3942 iMark = ((sqlite3_int64)(a[APND_MARK_PREFIX_SZ]&0x7f))<<56; 3943 for(i=1; i<8; i++){ 3944 iMark += (sqlite3_int64)a[APND_MARK_PREFIX_SZ+i]<<(56-8*i); 3945 } 3946 return iMark; 3947 } 3948 3949 /* 3950 ** Open an apnd file handle. 3951 */ 3952 static int apndOpen( 3953 sqlite3_vfs *pVfs, 3954 const char *zName, 3955 sqlite3_file *pFile, 3956 int flags, 3957 int *pOutFlags 3958 ){ 3959 ApndFile *p; 3960 sqlite3_file *pSubFile; 3961 sqlite3_vfs *pSubVfs; 3962 int rc; 3963 sqlite3_int64 sz; 3964 pSubVfs = ORIGVFS(pVfs); 3965 if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){ 3966 return pSubVfs->xOpen(pSubVfs, zName, pFile, flags, pOutFlags); 3967 } 3968 p = (ApndFile*)pFile; 3969 memset(p, 0, sizeof(*p)); 3970 pSubFile = ORIGFILE(pFile); 3971 p->base.pMethods = &apnd_io_methods; 3972 rc = pSubVfs->xOpen(pSubVfs, zName, pSubFile, flags, pOutFlags); 3973 if( rc ) goto apnd_open_done; 3974 rc = pSubFile->pMethods->xFileSize(pSubFile, &sz); 3975 if( rc ){ 3976 pSubFile->pMethods->xClose(pSubFile); 3977 goto apnd_open_done; 3978 } 3979 if( apndIsOrdinaryDatabaseFile(sz, pSubFile) ){ 3980 memmove(pFile, pSubFile, pSubVfs->szOsFile); 3981 return SQLITE_OK; 3982 } 3983 p->iMark = 0; 3984 p->iPgOne = apndReadMark(sz, pFile); 3985 if( p->iPgOne>0 ){ 3986 return SQLITE_OK; 3987 } 3988 if( (flags & SQLITE_OPEN_CREATE)==0 ){ 3989 pSubFile->pMethods->xClose(pSubFile); 3990 rc = SQLITE_CANTOPEN; 3991 } 3992 p->iPgOne = (sz+0xfff) & ~(sqlite3_int64)0xfff; 3993 apnd_open_done: 3994 if( rc ) pFile->pMethods = 0; 3995 return rc; 3996 } 3997 3998 /* 3999 ** All other VFS methods are pass-thrus. 4000 */ 4001 static int apndDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ 4002 return ORIGVFS(pVfs)->xDelete(ORIGVFS(pVfs), zPath, dirSync); 4003 } 4004 static int apndAccess( 4005 sqlite3_vfs *pVfs, 4006 const char *zPath, 4007 int flags, 4008 int *pResOut 4009 ){ 4010 return ORIGVFS(pVfs)->xAccess(ORIGVFS(pVfs), zPath, flags, pResOut); 4011 } 4012 static int apndFullPathname( 4013 sqlite3_vfs *pVfs, 4014 const char *zPath, 4015 int nOut, 4016 char *zOut 4017 ){ 4018 return ORIGVFS(pVfs)->xFullPathname(ORIGVFS(pVfs),zPath,nOut,zOut); 4019 } 4020 static void *apndDlOpen(sqlite3_vfs *pVfs, const char *zPath){ 4021 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); 4022 } 4023 static void apndDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ 4024 ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); 4025 } 4026 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ 4027 return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); 4028 } 4029 static void apndDlClose(sqlite3_vfs *pVfs, void *pHandle){ 4030 ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); 4031 } 4032 static int apndRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ 4033 return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); 4034 } 4035 static int apndSleep(sqlite3_vfs *pVfs, int nMicro){ 4036 return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); 4037 } 4038 static int apndCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ 4039 return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); 4040 } 4041 static int apndGetLastError(sqlite3_vfs *pVfs, int a, char *b){ 4042 return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); 4043 } 4044 static int apndCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ 4045 return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); 4046 } 4047 static int apndSetSystemCall( 4048 sqlite3_vfs *pVfs, 4049 const char *zName, 4050 sqlite3_syscall_ptr pCall 4051 ){ 4052 return ORIGVFS(pVfs)->xSetSystemCall(ORIGVFS(pVfs),zName,pCall); 4053 } 4054 static sqlite3_syscall_ptr apndGetSystemCall( 4055 sqlite3_vfs *pVfs, 4056 const char *zName 4057 ){ 4058 return ORIGVFS(pVfs)->xGetSystemCall(ORIGVFS(pVfs),zName); 4059 } 4060 static const char *apndNextSystemCall(sqlite3_vfs *pVfs, const char *zName){ 4061 return ORIGVFS(pVfs)->xNextSystemCall(ORIGVFS(pVfs), zName); 4062 } 4063 4064 4065 #ifdef _WIN32 4066 4067 #endif 4068 /* 4069 ** This routine is called when the extension is loaded. 4070 ** Register the new VFS. 4071 */ 4072 int sqlite3_appendvfs_init( 4073 sqlite3 *db, 4074 char **pzErrMsg, 4075 const sqlite3_api_routines *pApi 4076 ){ 4077 int rc = SQLITE_OK; 4078 sqlite3_vfs *pOrig; 4079 SQLITE_EXTENSION_INIT2(pApi); 4080 (void)pzErrMsg; 4081 (void)db; 4082 pOrig = sqlite3_vfs_find(0); 4083 apnd_vfs.iVersion = pOrig->iVersion; 4084 apnd_vfs.pAppData = pOrig; 4085 apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile); 4086 rc = sqlite3_vfs_register(&apnd_vfs, 0); 4087 #ifdef APPENDVFS_TEST 4088 if( rc==SQLITE_OK ){ 4089 rc = sqlite3_auto_extension((void(*)(void))apndvfsRegister); 4090 } 4091 #endif 4092 if( rc==SQLITE_OK ) rc = SQLITE_OK_LOAD_PERMANENTLY; 4093 return rc; 4094 } 4095 4096 /************************* End ../ext/misc/appendvfs.c ********************/ 4097 /************************* Begin ../ext/misc/memtrace.c ******************/ 4098 /* 4099 ** 2019-01-21 4100 ** 4101 ** The author disclaims copyright to this source code. In place of 4102 ** a legal notice, here is a blessing: 4103 ** 4104 ** May you do good and not evil. 4105 ** May you find forgiveness for yourself and forgive others. 4106 ** May you share freely, never taking more than you give. 4107 ** 4108 ************************************************************************* 4109 ** 4110 ** This file implements an extension that uses the SQLITE_CONFIG_MALLOC 4111 ** mechanism to add a tracing layer on top of SQLite. If this extension 4112 ** is registered prior to sqlite3_initialize(), it will cause all memory 4113 ** allocation activities to be logged on standard output, or to some other 4114 ** FILE specified by the initializer. 4115 ** 4116 ** This file needs to be compiled into the application that uses it. 4117 ** 4118 ** This extension is used to implement the --memtrace option of the 4119 ** command-line shell. 4120 */ 4121 #include <assert.h> 4122 #include <string.h> 4123 #include <stdio.h> 4124 4125 /* The original memory allocation routines */ 4126 static sqlite3_mem_methods memtraceBase; 4127 static FILE *memtraceOut; 4128 4129 /* Methods that trace memory allocations */ 4130 static void *memtraceMalloc(int n){ 4131 if( memtraceOut ){ 4132 fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n", 4133 memtraceBase.xRoundup(n)); 4134 } 4135 return memtraceBase.xMalloc(n); 4136 } 4137 static void memtraceFree(void *p){ 4138 if( p==0 ) return; 4139 if( memtraceOut ){ 4140 fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p)); 4141 } 4142 memtraceBase.xFree(p); 4143 } 4144 static void *memtraceRealloc(void *p, int n){ 4145 if( p==0 ) return memtraceMalloc(n); 4146 if( n==0 ){ 4147 memtraceFree(p); 4148 return 0; 4149 } 4150 if( memtraceOut ){ 4151 fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n", 4152 memtraceBase.xSize(p), memtraceBase.xRoundup(n)); 4153 } 4154 return memtraceBase.xRealloc(p, n); 4155 } 4156 static int memtraceSize(void *p){ 4157 return memtraceBase.xSize(p); 4158 } 4159 static int memtraceRoundup(int n){ 4160 return memtraceBase.xRoundup(n); 4161 } 4162 static int memtraceInit(void *p){ 4163 return memtraceBase.xInit(p); 4164 } 4165 static void memtraceShutdown(void *p){ 4166 memtraceBase.xShutdown(p); 4167 } 4168 4169 /* The substitute memory allocator */ 4170 static sqlite3_mem_methods ersaztMethods = { 4171 memtraceMalloc, 4172 memtraceFree, 4173 memtraceRealloc, 4174 memtraceSize, 4175 memtraceRoundup, 4176 memtraceInit, 4177 memtraceShutdown, 4178 0 4179 }; 4180 4181 /* Begin tracing memory allocations to out. */ 4182 int sqlite3MemTraceActivate(FILE *out){ 4183 int rc = SQLITE_OK; 4184 if( memtraceBase.xMalloc==0 ){ 4185 rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase); 4186 if( rc==SQLITE_OK ){ 4187 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods); 4188 } 4189 } 4190 memtraceOut = out; 4191 return rc; 4192 } 4193 4194 /* Deactivate memory tracing */ 4195 int sqlite3MemTraceDeactivate(void){ 4196 int rc = SQLITE_OK; 4197 if( memtraceBase.xMalloc!=0 ){ 4198 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase); 4199 if( rc==SQLITE_OK ){ 4200 memset(&memtraceBase, 0, sizeof(memtraceBase)); 4201 } 4202 } 4203 memtraceOut = 0; 4204 return rc; 4205 } 4206 4207 /************************* End ../ext/misc/memtrace.c ********************/ 4208 #ifdef SQLITE_HAVE_ZLIB 4209 /************************* Begin ../ext/misc/zipfile.c ******************/ 4210 /* 4211 ** 2017-12-26 4212 ** 4213 ** The author disclaims copyright to this source code. In place of 4214 ** a legal notice, here is a blessing: 4215 ** 4216 ** May you do good and not evil. 4217 ** May you find forgiveness for yourself and forgive others. 4218 ** May you share freely, never taking more than you give. 4219 ** 4220 ****************************************************************************** 4221 ** 4222 ** This file implements a virtual table for reading and writing ZIP archive 4223 ** files. 4224 ** 4225 ** Usage example: 4226 ** 4227 ** SELECT name, sz, datetime(mtime,'unixepoch') FROM zipfile($filename); 4228 ** 4229 ** Current limitations: 4230 ** 4231 ** * No support for encryption 4232 ** * No support for ZIP archives spanning multiple files 4233 ** * No support for zip64 extensions 4234 ** * Only the "inflate/deflate" (zlib) compression method is supported 4235 */ 4236 /* #include "sqlite3ext.h" */ 4237 SQLITE_EXTENSION_INIT1 4238 #include <stdio.h> 4239 #include <string.h> 4240 #include <assert.h> 4241 4242 #include <zlib.h> 4243 4244 #ifndef SQLITE_OMIT_VIRTUALTABLE 4245 4246 #ifndef SQLITE_AMALGAMATION 4247 4248 /* typedef sqlite3_int64 i64; */ 4249 /* typedef unsigned char u8; */ 4250 typedef unsigned short u16; 4251 typedef unsigned long u32; 4252 #define MIN(a,b) ((a)<(b) ? (a) : (b)) 4253 4254 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) 4255 # define ALWAYS(X) (1) 4256 # define NEVER(X) (0) 4257 #elif !defined(NDEBUG) 4258 # define ALWAYS(X) ((X)?1:(assert(0),0)) 4259 # define NEVER(X) ((X)?(assert(0),1):0) 4260 #else 4261 # define ALWAYS(X) (X) 4262 # define NEVER(X) (X) 4263 #endif 4264 4265 #endif /* SQLITE_AMALGAMATION */ 4266 4267 /* 4268 ** Definitions for mode bitmasks S_IFDIR, S_IFREG and S_IFLNK. 4269 ** 4270 ** In some ways it would be better to obtain these values from system 4271 ** header files. But, the dependency is undesirable and (a) these 4272 ** have been stable for decades, (b) the values are part of POSIX and 4273 ** are also made explicit in [man stat], and (c) are part of the 4274 ** file format for zip archives. 4275 */ 4276 #ifndef S_IFDIR 4277 # define S_IFDIR 0040000 4278 #endif 4279 #ifndef S_IFREG 4280 # define S_IFREG 0100000 4281 #endif 4282 #ifndef S_IFLNK 4283 # define S_IFLNK 0120000 4284 #endif 4285 4286 static const char ZIPFILE_SCHEMA[] = 4287 "CREATE TABLE y(" 4288 "name PRIMARY KEY," /* 0: Name of file in zip archive */ 4289 "mode," /* 1: POSIX mode for file */ 4290 "mtime," /* 2: Last modification time (secs since 1970)*/ 4291 "sz," /* 3: Size of object */ 4292 "rawdata," /* 4: Raw data */ 4293 "data," /* 5: Uncompressed data */ 4294 "method," /* 6: Compression method (integer) */ 4295 "z HIDDEN" /* 7: Name of zip file */ 4296 ") WITHOUT ROWID;"; 4297 4298 #define ZIPFILE_F_COLUMN_IDX 7 /* Index of column "file" in the above */ 4299 #define ZIPFILE_BUFFER_SIZE (64*1024) 4300 4301 4302 /* 4303 ** Magic numbers used to read and write zip files. 4304 ** 4305 ** ZIPFILE_NEWENTRY_MADEBY: 4306 ** Use this value for the "version-made-by" field in new zip file 4307 ** entries. The upper byte indicates "unix", and the lower byte 4308 ** indicates that the zip file matches pkzip specification 3.0. 4309 ** This is what info-zip seems to do. 4310 ** 4311 ** ZIPFILE_NEWENTRY_REQUIRED: 4312 ** Value for "version-required-to-extract" field of new entries. 4313 ** Version 2.0 is required to support folders and deflate compression. 4314 ** 4315 ** ZIPFILE_NEWENTRY_FLAGS: 4316 ** Value for "general-purpose-bit-flags" field of new entries. Bit 4317 ** 11 means "utf-8 filename and comment". 4318 ** 4319 ** ZIPFILE_SIGNATURE_CDS: 4320 ** First 4 bytes of a valid CDS record. 4321 ** 4322 ** ZIPFILE_SIGNATURE_LFH: 4323 ** First 4 bytes of a valid LFH record. 4324 ** 4325 ** ZIPFILE_SIGNATURE_EOCD 4326 ** First 4 bytes of a valid EOCD record. 4327 */ 4328 #define ZIPFILE_EXTRA_TIMESTAMP 0x5455 4329 #define ZIPFILE_NEWENTRY_MADEBY ((3<<8) + 30) 4330 #define ZIPFILE_NEWENTRY_REQUIRED 20 4331 #define ZIPFILE_NEWENTRY_FLAGS 0x800 4332 #define ZIPFILE_SIGNATURE_CDS 0x02014b50 4333 #define ZIPFILE_SIGNATURE_LFH 0x04034b50 4334 #define ZIPFILE_SIGNATURE_EOCD 0x06054b50 4335 4336 /* 4337 ** The sizes of the fixed-size part of each of the three main data 4338 ** structures in a zip archive. 4339 */ 4340 #define ZIPFILE_LFH_FIXED_SZ 30 4341 #define ZIPFILE_EOCD_FIXED_SZ 22 4342 #define ZIPFILE_CDS_FIXED_SZ 46 4343 4344 /* 4345 *** 4.3.16 End of central directory record: 4346 *** 4347 *** end of central dir signature 4 bytes (0x06054b50) 4348 *** number of this disk 2 bytes 4349 *** number of the disk with the 4350 *** start of the central directory 2 bytes 4351 *** total number of entries in the 4352 *** central directory on this disk 2 bytes 4353 *** total number of entries in 4354 *** the central directory 2 bytes 4355 *** size of the central directory 4 bytes 4356 *** offset of start of central 4357 *** directory with respect to 4358 *** the starting disk number 4 bytes 4359 *** .ZIP file comment length 2 bytes 4360 *** .ZIP file comment (variable size) 4361 */ 4362 typedef struct ZipfileEOCD ZipfileEOCD; 4363 struct ZipfileEOCD { 4364 u16 iDisk; 4365 u16 iFirstDisk; 4366 u16 nEntry; 4367 u16 nEntryTotal; 4368 u32 nSize; 4369 u32 iOffset; 4370 }; 4371 4372 /* 4373 *** 4.3.12 Central directory structure: 4374 *** 4375 *** ... 4376 *** 4377 *** central file header signature 4 bytes (0x02014b50) 4378 *** version made by 2 bytes 4379 *** version needed to extract 2 bytes 4380 *** general purpose bit flag 2 bytes 4381 *** compression method 2 bytes 4382 *** last mod file time 2 bytes 4383 *** last mod file date 2 bytes 4384 *** crc-32 4 bytes 4385 *** compressed size 4 bytes 4386 *** uncompressed size 4 bytes 4387 *** file name length 2 bytes 4388 *** extra field length 2 bytes 4389 *** file comment length 2 bytes 4390 *** disk number start 2 bytes 4391 *** internal file attributes 2 bytes 4392 *** external file attributes 4 bytes 4393 *** relative offset of local header 4 bytes 4394 */ 4395 typedef struct ZipfileCDS ZipfileCDS; 4396 struct ZipfileCDS { 4397 u16 iVersionMadeBy; 4398 u16 iVersionExtract; 4399 u16 flags; 4400 u16 iCompression; 4401 u16 mTime; 4402 u16 mDate; 4403 u32 crc32; 4404 u32 szCompressed; 4405 u32 szUncompressed; 4406 u16 nFile; 4407 u16 nExtra; 4408 u16 nComment; 4409 u16 iDiskStart; 4410 u16 iInternalAttr; 4411 u32 iExternalAttr; 4412 u32 iOffset; 4413 char *zFile; /* Filename (sqlite3_malloc()) */ 4414 }; 4415 4416 /* 4417 *** 4.3.7 Local file header: 4418 *** 4419 *** local file header signature 4 bytes (0x04034b50) 4420 *** version needed to extract 2 bytes 4421 *** general purpose bit flag 2 bytes 4422 *** compression method 2 bytes 4423 *** last mod file time 2 bytes 4424 *** last mod file date 2 bytes 4425 *** crc-32 4 bytes 4426 *** compressed size 4 bytes 4427 *** uncompressed size 4 bytes 4428 *** file name length 2 bytes 4429 *** extra field length 2 bytes 4430 *** 4431 */ 4432 typedef struct ZipfileLFH ZipfileLFH; 4433 struct ZipfileLFH { 4434 u16 iVersionExtract; 4435 u16 flags; 4436 u16 iCompression; 4437 u16 mTime; 4438 u16 mDate; 4439 u32 crc32; 4440 u32 szCompressed; 4441 u32 szUncompressed; 4442 u16 nFile; 4443 u16 nExtra; 4444 }; 4445 4446 typedef struct ZipfileEntry ZipfileEntry; 4447 struct ZipfileEntry { 4448 ZipfileCDS cds; /* Parsed CDS record */ 4449 u32 mUnixTime; /* Modification time, in UNIX format */ 4450 u8 *aExtra; /* cds.nExtra+cds.nComment bytes of extra data */ 4451 i64 iDataOff; /* Offset to data in file (if aData==0) */ 4452 u8 *aData; /* cds.szCompressed bytes of compressed data */ 4453 ZipfileEntry *pNext; /* Next element in in-memory CDS */ 4454 }; 4455 4456 /* 4457 ** Cursor type for zipfile tables. 4458 */ 4459 typedef struct ZipfileCsr ZipfileCsr; 4460 struct ZipfileCsr { 4461 sqlite3_vtab_cursor base; /* Base class - must be first */ 4462 i64 iId; /* Cursor ID */ 4463 u8 bEof; /* True when at EOF */ 4464 u8 bNoop; /* If next xNext() call is no-op */ 4465 4466 /* Used outside of write transactions */ 4467 FILE *pFile; /* Zip file */ 4468 i64 iNextOff; /* Offset of next record in central directory */ 4469 ZipfileEOCD eocd; /* Parse of central directory record */ 4470 4471 ZipfileEntry *pFreeEntry; /* Free this list when cursor is closed or reset */ 4472 ZipfileEntry *pCurrent; /* Current entry */ 4473 ZipfileCsr *pCsrNext; /* Next cursor on same virtual table */ 4474 }; 4475 4476 typedef struct ZipfileTab ZipfileTab; 4477 struct ZipfileTab { 4478 sqlite3_vtab base; /* Base class - must be first */ 4479 char *zFile; /* Zip file this table accesses (may be NULL) */ 4480 sqlite3 *db; /* Host database connection */ 4481 u8 *aBuffer; /* Temporary buffer used for various tasks */ 4482 4483 ZipfileCsr *pCsrList; /* List of cursors */ 4484 i64 iNextCsrid; 4485 4486 /* The following are used by write transactions only */ 4487 ZipfileEntry *pFirstEntry; /* Linked list of all files (if pWriteFd!=0) */ 4488 ZipfileEntry *pLastEntry; /* Last element in pFirstEntry list */ 4489 FILE *pWriteFd; /* File handle open on zip archive */ 4490 i64 szCurrent; /* Current size of zip archive */ 4491 i64 szOrig; /* Size of archive at start of transaction */ 4492 }; 4493 4494 /* 4495 ** Set the error message contained in context ctx to the results of 4496 ** vprintf(zFmt, ...). 4497 */ 4498 static void zipfileCtxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){ 4499 char *zMsg = 0; 4500 va_list ap; 4501 va_start(ap, zFmt); 4502 zMsg = sqlite3_vmprintf(zFmt, ap); 4503 sqlite3_result_error(ctx, zMsg, -1); 4504 sqlite3_free(zMsg); 4505 va_end(ap); 4506 } 4507 4508 /* 4509 ** If string zIn is quoted, dequote it in place. Otherwise, if the string 4510 ** is not quoted, do nothing. 4511 */ 4512 static void zipfileDequote(char *zIn){ 4513 char q = zIn[0]; 4514 if( q=='"' || q=='\'' || q=='`' || q=='[' ){ 4515 int iIn = 1; 4516 int iOut = 0; 4517 if( q=='[' ) q = ']'; 4518 while( ALWAYS(zIn[iIn]) ){ 4519 char c = zIn[iIn++]; 4520 if( c==q && zIn[iIn++]!=q ) break; 4521 zIn[iOut++] = c; 4522 } 4523 zIn[iOut] = '\0'; 4524 } 4525 } 4526 4527 /* 4528 ** Construct a new ZipfileTab virtual table object. 4529 ** 4530 ** argv[0] -> module name ("zipfile") 4531 ** argv[1] -> database name 4532 ** argv[2] -> table name 4533 ** argv[...] -> "column name" and other module argument fields. 4534 */ 4535 static int zipfileConnect( 4536 sqlite3 *db, 4537 void *pAux, 4538 int argc, const char *const*argv, 4539 sqlite3_vtab **ppVtab, 4540 char **pzErr 4541 ){ 4542 int nByte = sizeof(ZipfileTab) + ZIPFILE_BUFFER_SIZE; 4543 int nFile = 0; 4544 const char *zFile = 0; 4545 ZipfileTab *pNew = 0; 4546 int rc; 4547 4548 /* If the table name is not "zipfile", require that the argument be 4549 ** specified. This stops zipfile tables from being created as: 4550 ** 4551 ** CREATE VIRTUAL TABLE zzz USING zipfile(); 4552 ** 4553 ** It does not prevent: 4554 ** 4555 ** CREATE VIRTUAL TABLE zipfile USING zipfile(); 4556 */ 4557 assert( 0==sqlite3_stricmp(argv[0], "zipfile") ); 4558 if( (0!=sqlite3_stricmp(argv[2], "zipfile") && argc<4) || argc>4 ){ 4559 *pzErr = sqlite3_mprintf("zipfile constructor requires one argument"); 4560 return SQLITE_ERROR; 4561 } 4562 4563 if( argc>3 ){ 4564 zFile = argv[3]; 4565 nFile = (int)strlen(zFile)+1; 4566 } 4567 4568 rc = sqlite3_declare_vtab(db, ZIPFILE_SCHEMA); 4569 if( rc==SQLITE_OK ){ 4570 pNew = (ZipfileTab*)sqlite3_malloc64((sqlite3_int64)nByte+nFile); 4571 if( pNew==0 ) return SQLITE_NOMEM; 4572 memset(pNew, 0, nByte+nFile); 4573 pNew->db = db; 4574 pNew->aBuffer = (u8*)&pNew[1]; 4575 if( zFile ){ 4576 pNew->zFile = (char*)&pNew->aBuffer[ZIPFILE_BUFFER_SIZE]; 4577 memcpy(pNew->zFile, zFile, nFile); 4578 zipfileDequote(pNew->zFile); 4579 } 4580 } 4581 *ppVtab = (sqlite3_vtab*)pNew; 4582 return rc; 4583 } 4584 4585 /* 4586 ** Free the ZipfileEntry structure indicated by the only argument. 4587 */ 4588 static void zipfileEntryFree(ZipfileEntry *p){ 4589 if( p ){ 4590 sqlite3_free(p->cds.zFile); 4591 sqlite3_free(p); 4592 } 4593 } 4594 4595 /* 4596 ** Release resources that should be freed at the end of a write 4597 ** transaction. 4598 */ 4599 static void zipfileCleanupTransaction(ZipfileTab *pTab){ 4600 ZipfileEntry *pEntry; 4601 ZipfileEntry *pNext; 4602 4603 if( pTab->pWriteFd ){ 4604 fclose(pTab->pWriteFd); 4605 pTab->pWriteFd = 0; 4606 } 4607 for(pEntry=pTab->pFirstEntry; pEntry; pEntry=pNext){ 4608 pNext = pEntry->pNext; 4609 zipfileEntryFree(pEntry); 4610 } 4611 pTab->pFirstEntry = 0; 4612 pTab->pLastEntry = 0; 4613 pTab->szCurrent = 0; 4614 pTab->szOrig = 0; 4615 } 4616 4617 /* 4618 ** This method is the destructor for zipfile vtab objects. 4619 */ 4620 static int zipfileDisconnect(sqlite3_vtab *pVtab){ 4621 zipfileCleanupTransaction((ZipfileTab*)pVtab); 4622 sqlite3_free(pVtab); 4623 return SQLITE_OK; 4624 } 4625 4626 /* 4627 ** Constructor for a new ZipfileCsr object. 4628 */ 4629 static int zipfileOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCsr){ 4630 ZipfileTab *pTab = (ZipfileTab*)p; 4631 ZipfileCsr *pCsr; 4632 pCsr = sqlite3_malloc(sizeof(*pCsr)); 4633 *ppCsr = (sqlite3_vtab_cursor*)pCsr; 4634 if( pCsr==0 ){ 4635 return SQLITE_NOMEM; 4636 } 4637 memset(pCsr, 0, sizeof(*pCsr)); 4638 pCsr->iId = ++pTab->iNextCsrid; 4639 pCsr->pCsrNext = pTab->pCsrList; 4640 pTab->pCsrList = pCsr; 4641 return SQLITE_OK; 4642 } 4643 4644 /* 4645 ** Reset a cursor back to the state it was in when first returned 4646 ** by zipfileOpen(). 4647 */ 4648 static void zipfileResetCursor(ZipfileCsr *pCsr){ 4649 ZipfileEntry *p; 4650 ZipfileEntry *pNext; 4651 4652 pCsr->bEof = 0; 4653 if( pCsr->pFile ){ 4654 fclose(pCsr->pFile); 4655 pCsr->pFile = 0; 4656 zipfileEntryFree(pCsr->pCurrent); 4657 pCsr->pCurrent = 0; 4658 } 4659 4660 for(p=pCsr->pFreeEntry; p; p=pNext){ 4661 pNext = p->pNext; 4662 zipfileEntryFree(p); 4663 } 4664 } 4665 4666 /* 4667 ** Destructor for an ZipfileCsr. 4668 */ 4669 static int zipfileClose(sqlite3_vtab_cursor *cur){ 4670 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 4671 ZipfileTab *pTab = (ZipfileTab*)(pCsr->base.pVtab); 4672 ZipfileCsr **pp; 4673 zipfileResetCursor(pCsr); 4674 4675 /* Remove this cursor from the ZipfileTab.pCsrList list. */ 4676 for(pp=&pTab->pCsrList; *pp!=pCsr; pp=&((*pp)->pCsrNext)); 4677 *pp = pCsr->pCsrNext; 4678 4679 sqlite3_free(pCsr); 4680 return SQLITE_OK; 4681 } 4682 4683 /* 4684 ** Set the error message for the virtual table associated with cursor 4685 ** pCsr to the results of vprintf(zFmt, ...). 4686 */ 4687 static void zipfileTableErr(ZipfileTab *pTab, const char *zFmt, ...){ 4688 va_list ap; 4689 va_start(ap, zFmt); 4690 sqlite3_free(pTab->base.zErrMsg); 4691 pTab->base.zErrMsg = sqlite3_vmprintf(zFmt, ap); 4692 va_end(ap); 4693 } 4694 static void zipfileCursorErr(ZipfileCsr *pCsr, const char *zFmt, ...){ 4695 va_list ap; 4696 va_start(ap, zFmt); 4697 sqlite3_free(pCsr->base.pVtab->zErrMsg); 4698 pCsr->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap); 4699 va_end(ap); 4700 } 4701 4702 /* 4703 ** Read nRead bytes of data from offset iOff of file pFile into buffer 4704 ** aRead[]. Return SQLITE_OK if successful, or an SQLite error code 4705 ** otherwise. 4706 ** 4707 ** If an error does occur, output variable (*pzErrmsg) may be set to point 4708 ** to an English language error message. It is the responsibility of the 4709 ** caller to eventually free this buffer using 4710 ** sqlite3_free(). 4711 */ 4712 static int zipfileReadData( 4713 FILE *pFile, /* Read from this file */ 4714 u8 *aRead, /* Read into this buffer */ 4715 int nRead, /* Number of bytes to read */ 4716 i64 iOff, /* Offset to read from */ 4717 char **pzErrmsg /* OUT: Error message (from sqlite3_malloc) */ 4718 ){ 4719 size_t n; 4720 fseek(pFile, (long)iOff, SEEK_SET); 4721 n = fread(aRead, 1, nRead, pFile); 4722 if( (int)n!=nRead ){ 4723 *pzErrmsg = sqlite3_mprintf("error in fread()"); 4724 return SQLITE_ERROR; 4725 } 4726 return SQLITE_OK; 4727 } 4728 4729 static int zipfileAppendData( 4730 ZipfileTab *pTab, 4731 const u8 *aWrite, 4732 int nWrite 4733 ){ 4734 size_t n; 4735 fseek(pTab->pWriteFd, (long)pTab->szCurrent, SEEK_SET); 4736 n = fwrite(aWrite, 1, nWrite, pTab->pWriteFd); 4737 if( (int)n!=nWrite ){ 4738 pTab->base.zErrMsg = sqlite3_mprintf("error in fwrite()"); 4739 return SQLITE_ERROR; 4740 } 4741 pTab->szCurrent += nWrite; 4742 return SQLITE_OK; 4743 } 4744 4745 /* 4746 ** Read and return a 16-bit little-endian unsigned integer from buffer aBuf. 4747 */ 4748 static u16 zipfileGetU16(const u8 *aBuf){ 4749 return (aBuf[1] << 8) + aBuf[0]; 4750 } 4751 4752 /* 4753 ** Read and return a 32-bit little-endian unsigned integer from buffer aBuf. 4754 */ 4755 static u32 zipfileGetU32(const u8 *aBuf){ 4756 return ((u32)(aBuf[3]) << 24) 4757 + ((u32)(aBuf[2]) << 16) 4758 + ((u32)(aBuf[1]) << 8) 4759 + ((u32)(aBuf[0]) << 0); 4760 } 4761 4762 /* 4763 ** Write a 16-bit little endiate integer into buffer aBuf. 4764 */ 4765 static void zipfilePutU16(u8 *aBuf, u16 val){ 4766 aBuf[0] = val & 0xFF; 4767 aBuf[1] = (val>>8) & 0xFF; 4768 } 4769 4770 /* 4771 ** Write a 32-bit little endiate integer into buffer aBuf. 4772 */ 4773 static void zipfilePutU32(u8 *aBuf, u32 val){ 4774 aBuf[0] = val & 0xFF; 4775 aBuf[1] = (val>>8) & 0xFF; 4776 aBuf[2] = (val>>16) & 0xFF; 4777 aBuf[3] = (val>>24) & 0xFF; 4778 } 4779 4780 #define zipfileRead32(aBuf) ( aBuf+=4, zipfileGetU32(aBuf-4) ) 4781 #define zipfileRead16(aBuf) ( aBuf+=2, zipfileGetU16(aBuf-2) ) 4782 4783 #define zipfileWrite32(aBuf,val) { zipfilePutU32(aBuf,val); aBuf+=4; } 4784 #define zipfileWrite16(aBuf,val) { zipfilePutU16(aBuf,val); aBuf+=2; } 4785 4786 /* 4787 ** Magic numbers used to read CDS records. 4788 */ 4789 #define ZIPFILE_CDS_NFILE_OFF 28 4790 #define ZIPFILE_CDS_SZCOMPRESSED_OFF 20 4791 4792 /* 4793 ** Decode the CDS record in buffer aBuf into (*pCDS). Return SQLITE_ERROR 4794 ** if the record is not well-formed, or SQLITE_OK otherwise. 4795 */ 4796 static int zipfileReadCDS(u8 *aBuf, ZipfileCDS *pCDS){ 4797 u8 *aRead = aBuf; 4798 u32 sig = zipfileRead32(aRead); 4799 int rc = SQLITE_OK; 4800 if( sig!=ZIPFILE_SIGNATURE_CDS ){ 4801 rc = SQLITE_ERROR; 4802 }else{ 4803 pCDS->iVersionMadeBy = zipfileRead16(aRead); 4804 pCDS->iVersionExtract = zipfileRead16(aRead); 4805 pCDS->flags = zipfileRead16(aRead); 4806 pCDS->iCompression = zipfileRead16(aRead); 4807 pCDS->mTime = zipfileRead16(aRead); 4808 pCDS->mDate = zipfileRead16(aRead); 4809 pCDS->crc32 = zipfileRead32(aRead); 4810 pCDS->szCompressed = zipfileRead32(aRead); 4811 pCDS->szUncompressed = zipfileRead32(aRead); 4812 assert( aRead==&aBuf[ZIPFILE_CDS_NFILE_OFF] ); 4813 pCDS->nFile = zipfileRead16(aRead); 4814 pCDS->nExtra = zipfileRead16(aRead); 4815 pCDS->nComment = zipfileRead16(aRead); 4816 pCDS->iDiskStart = zipfileRead16(aRead); 4817 pCDS->iInternalAttr = zipfileRead16(aRead); 4818 pCDS->iExternalAttr = zipfileRead32(aRead); 4819 pCDS->iOffset = zipfileRead32(aRead); 4820 assert( aRead==&aBuf[ZIPFILE_CDS_FIXED_SZ] ); 4821 } 4822 4823 return rc; 4824 } 4825 4826 /* 4827 ** Decode the LFH record in buffer aBuf into (*pLFH). Return SQLITE_ERROR 4828 ** if the record is not well-formed, or SQLITE_OK otherwise. 4829 */ 4830 static int zipfileReadLFH( 4831 u8 *aBuffer, 4832 ZipfileLFH *pLFH 4833 ){ 4834 u8 *aRead = aBuffer; 4835 int rc = SQLITE_OK; 4836 4837 u32 sig = zipfileRead32(aRead); 4838 if( sig!=ZIPFILE_SIGNATURE_LFH ){ 4839 rc = SQLITE_ERROR; 4840 }else{ 4841 pLFH->iVersionExtract = zipfileRead16(aRead); 4842 pLFH->flags = zipfileRead16(aRead); 4843 pLFH->iCompression = zipfileRead16(aRead); 4844 pLFH->mTime = zipfileRead16(aRead); 4845 pLFH->mDate = zipfileRead16(aRead); 4846 pLFH->crc32 = zipfileRead32(aRead); 4847 pLFH->szCompressed = zipfileRead32(aRead); 4848 pLFH->szUncompressed = zipfileRead32(aRead); 4849 pLFH->nFile = zipfileRead16(aRead); 4850 pLFH->nExtra = zipfileRead16(aRead); 4851 } 4852 return rc; 4853 } 4854 4855 4856 /* 4857 ** Buffer aExtra (size nExtra bytes) contains zip archive "extra" fields. 4858 ** Scan through this buffer to find an "extra-timestamp" field. If one 4859 ** exists, extract the 32-bit modification-timestamp from it and store 4860 ** the value in output parameter *pmTime. 4861 ** 4862 ** Zero is returned if no extra-timestamp record could be found (and so 4863 ** *pmTime is left unchanged), or non-zero otherwise. 4864 ** 4865 ** The general format of an extra field is: 4866 ** 4867 ** Header ID 2 bytes 4868 ** Data Size 2 bytes 4869 ** Data N bytes 4870 */ 4871 static int zipfileScanExtra(u8 *aExtra, int nExtra, u32 *pmTime){ 4872 int ret = 0; 4873 u8 *p = aExtra; 4874 u8 *pEnd = &aExtra[nExtra]; 4875 4876 while( p<pEnd ){ 4877 u16 id = zipfileRead16(p); 4878 u16 nByte = zipfileRead16(p); 4879 4880 switch( id ){ 4881 case ZIPFILE_EXTRA_TIMESTAMP: { 4882 u8 b = p[0]; 4883 if( b & 0x01 ){ /* 0x01 -> modtime is present */ 4884 *pmTime = zipfileGetU32(&p[1]); 4885 ret = 1; 4886 } 4887 break; 4888 } 4889 } 4890 4891 p += nByte; 4892 } 4893 return ret; 4894 } 4895 4896 /* 4897 ** Convert the standard MS-DOS timestamp stored in the mTime and mDate 4898 ** fields of the CDS structure passed as the only argument to a 32-bit 4899 ** UNIX seconds-since-the-epoch timestamp. Return the result. 4900 ** 4901 ** "Standard" MS-DOS time format: 4902 ** 4903 ** File modification time: 4904 ** Bits 00-04: seconds divided by 2 4905 ** Bits 05-10: minute 4906 ** Bits 11-15: hour 4907 ** File modification date: 4908 ** Bits 00-04: day 4909 ** Bits 05-08: month (1-12) 4910 ** Bits 09-15: years from 1980 4911 ** 4912 ** https://msdn.microsoft.com/en-us/library/9kkf9tah.aspx 4913 */ 4914 static u32 zipfileMtime(ZipfileCDS *pCDS){ 4915 int Y = (1980 + ((pCDS->mDate >> 9) & 0x7F)); 4916 int M = ((pCDS->mDate >> 5) & 0x0F); 4917 int D = (pCDS->mDate & 0x1F); 4918 int B = -13; 4919 4920 int sec = (pCDS->mTime & 0x1F)*2; 4921 int min = (pCDS->mTime >> 5) & 0x3F; 4922 int hr = (pCDS->mTime >> 11) & 0x1F; 4923 i64 JD; 4924 4925 /* JD = INT(365.25 * (Y+4716)) + INT(30.6001 * (M+1)) + D + B - 1524.5 */ 4926 4927 /* Calculate the JD in seconds for noon on the day in question */ 4928 if( M<3 ){ 4929 Y = Y-1; 4930 M = M+12; 4931 } 4932 JD = (i64)(24*60*60) * ( 4933 (int)(365.25 * (Y + 4716)) 4934 + (int)(30.6001 * (M + 1)) 4935 + D + B - 1524 4936 ); 4937 4938 /* Correct the JD for the time within the day */ 4939 JD += (hr-12) * 3600 + min * 60 + sec; 4940 4941 /* Convert JD to unix timestamp (the JD epoch is 2440587.5) */ 4942 return (u32)(JD - (i64)(24405875) * 24*60*6); 4943 } 4944 4945 /* 4946 ** The opposite of zipfileMtime(). This function populates the mTime and 4947 ** mDate fields of the CDS structure passed as the first argument according 4948 ** to the UNIX timestamp value passed as the second. 4949 */ 4950 static void zipfileMtimeToDos(ZipfileCDS *pCds, u32 mUnixTime){ 4951 /* Convert unix timestamp to JD (2440588 is noon on 1/1/1970) */ 4952 i64 JD = (i64)2440588 + mUnixTime / (24*60*60); 4953 4954 int A, B, C, D, E; 4955 int yr, mon, day; 4956 int hr, min, sec; 4957 4958 A = (int)((JD - 1867216.25)/36524.25); 4959 A = (int)(JD + 1 + A - (A/4)); 4960 B = A + 1524; 4961 C = (int)((B - 122.1)/365.25); 4962 D = (36525*(C&32767))/100; 4963 E = (int)((B-D)/30.6001); 4964 4965 day = B - D - (int)(30.6001*E); 4966 mon = (E<14 ? E-1 : E-13); 4967 yr = mon>2 ? C-4716 : C-4715; 4968 4969 hr = (mUnixTime % (24*60*60)) / (60*60); 4970 min = (mUnixTime % (60*60)) / 60; 4971 sec = (mUnixTime % 60); 4972 4973 if( yr>=1980 ){ 4974 pCds->mDate = (u16)(day + (mon << 5) + ((yr-1980) << 9)); 4975 pCds->mTime = (u16)(sec/2 + (min<<5) + (hr<<11)); 4976 }else{ 4977 pCds->mDate = pCds->mTime = 0; 4978 } 4979 4980 assert( mUnixTime<315507600 4981 || mUnixTime==zipfileMtime(pCds) 4982 || ((mUnixTime % 2) && mUnixTime-1==zipfileMtime(pCds)) 4983 /* || (mUnixTime % 2) */ 4984 ); 4985 } 4986 4987 /* 4988 ** If aBlob is not NULL, then it is a pointer to a buffer (nBlob bytes in 4989 ** size) containing an entire zip archive image. Or, if aBlob is NULL, 4990 ** then pFile is a file-handle open on a zip file. In either case, this 4991 ** function creates a ZipfileEntry object based on the zip archive entry 4992 ** for which the CDS record is at offset iOff. 4993 ** 4994 ** If successful, SQLITE_OK is returned and (*ppEntry) set to point to 4995 ** the new object. Otherwise, an SQLite error code is returned and the 4996 ** final value of (*ppEntry) undefined. 4997 */ 4998 static int zipfileGetEntry( 4999 ZipfileTab *pTab, /* Store any error message here */ 5000 const u8 *aBlob, /* Pointer to in-memory file image */ 5001 int nBlob, /* Size of aBlob[] in bytes */ 5002 FILE *pFile, /* If aBlob==0, read from this file */ 5003 i64 iOff, /* Offset of CDS record */ 5004 ZipfileEntry **ppEntry /* OUT: Pointer to new object */ 5005 ){ 5006 u8 *aRead; 5007 char **pzErr = &pTab->base.zErrMsg; 5008 int rc = SQLITE_OK; 5009 5010 if( aBlob==0 ){ 5011 aRead = pTab->aBuffer; 5012 rc = zipfileReadData(pFile, aRead, ZIPFILE_CDS_FIXED_SZ, iOff, pzErr); 5013 }else{ 5014 aRead = (u8*)&aBlob[iOff]; 5015 } 5016 5017 if( rc==SQLITE_OK ){ 5018 sqlite3_int64 nAlloc; 5019 ZipfileEntry *pNew; 5020 5021 int nFile = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF]); 5022 int nExtra = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+2]); 5023 nExtra += zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+4]); 5024 5025 nAlloc = sizeof(ZipfileEntry) + nExtra; 5026 if( aBlob ){ 5027 nAlloc += zipfileGetU32(&aRead[ZIPFILE_CDS_SZCOMPRESSED_OFF]); 5028 } 5029 5030 pNew = (ZipfileEntry*)sqlite3_malloc64(nAlloc); 5031 if( pNew==0 ){ 5032 rc = SQLITE_NOMEM; 5033 }else{ 5034 memset(pNew, 0, sizeof(ZipfileEntry)); 5035 rc = zipfileReadCDS(aRead, &pNew->cds); 5036 if( rc!=SQLITE_OK ){ 5037 *pzErr = sqlite3_mprintf("failed to read CDS at offset %lld", iOff); 5038 }else if( aBlob==0 ){ 5039 rc = zipfileReadData( 5040 pFile, aRead, nExtra+nFile, iOff+ZIPFILE_CDS_FIXED_SZ, pzErr 5041 ); 5042 }else{ 5043 aRead = (u8*)&aBlob[iOff + ZIPFILE_CDS_FIXED_SZ]; 5044 } 5045 } 5046 5047 if( rc==SQLITE_OK ){ 5048 u32 *pt = &pNew->mUnixTime; 5049 pNew->cds.zFile = sqlite3_mprintf("%.*s", nFile, aRead); 5050 pNew->aExtra = (u8*)&pNew[1]; 5051 memcpy(pNew->aExtra, &aRead[nFile], nExtra); 5052 if( pNew->cds.zFile==0 ){ 5053 rc = SQLITE_NOMEM; 5054 }else if( 0==zipfileScanExtra(&aRead[nFile], pNew->cds.nExtra, pt) ){ 5055 pNew->mUnixTime = zipfileMtime(&pNew->cds); 5056 } 5057 } 5058 5059 if( rc==SQLITE_OK ){ 5060 static const int szFix = ZIPFILE_LFH_FIXED_SZ; 5061 ZipfileLFH lfh; 5062 if( pFile ){ 5063 rc = zipfileReadData(pFile, aRead, szFix, pNew->cds.iOffset, pzErr); 5064 }else{ 5065 aRead = (u8*)&aBlob[pNew->cds.iOffset]; 5066 } 5067 5068 rc = zipfileReadLFH(aRead, &lfh); 5069 if( rc==SQLITE_OK ){ 5070 pNew->iDataOff = pNew->cds.iOffset + ZIPFILE_LFH_FIXED_SZ; 5071 pNew->iDataOff += lfh.nFile + lfh.nExtra; 5072 if( aBlob && pNew->cds.szCompressed ){ 5073 pNew->aData = &pNew->aExtra[nExtra]; 5074 memcpy(pNew->aData, &aBlob[pNew->iDataOff], pNew->cds.szCompressed); 5075 } 5076 }else{ 5077 *pzErr = sqlite3_mprintf("failed to read LFH at offset %d", 5078 (int)pNew->cds.iOffset 5079 ); 5080 } 5081 } 5082 5083 if( rc!=SQLITE_OK ){ 5084 zipfileEntryFree(pNew); 5085 }else{ 5086 *ppEntry = pNew; 5087 } 5088 } 5089 5090 return rc; 5091 } 5092 5093 /* 5094 ** Advance an ZipfileCsr to its next row of output. 5095 */ 5096 static int zipfileNext(sqlite3_vtab_cursor *cur){ 5097 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5098 int rc = SQLITE_OK; 5099 5100 if( pCsr->pFile ){ 5101 i64 iEof = pCsr->eocd.iOffset + pCsr->eocd.nSize; 5102 zipfileEntryFree(pCsr->pCurrent); 5103 pCsr->pCurrent = 0; 5104 if( pCsr->iNextOff>=iEof ){ 5105 pCsr->bEof = 1; 5106 }else{ 5107 ZipfileEntry *p = 0; 5108 ZipfileTab *pTab = (ZipfileTab*)(cur->pVtab); 5109 rc = zipfileGetEntry(pTab, 0, 0, pCsr->pFile, pCsr->iNextOff, &p); 5110 if( rc==SQLITE_OK ){ 5111 pCsr->iNextOff += ZIPFILE_CDS_FIXED_SZ; 5112 pCsr->iNextOff += (int)p->cds.nExtra + p->cds.nFile + p->cds.nComment; 5113 } 5114 pCsr->pCurrent = p; 5115 } 5116 }else{ 5117 if( !pCsr->bNoop ){ 5118 pCsr->pCurrent = pCsr->pCurrent->pNext; 5119 } 5120 if( pCsr->pCurrent==0 ){ 5121 pCsr->bEof = 1; 5122 } 5123 } 5124 5125 pCsr->bNoop = 0; 5126 return rc; 5127 } 5128 5129 static void zipfileFree(void *p) { 5130 sqlite3_free(p); 5131 } 5132 5133 /* 5134 ** Buffer aIn (size nIn bytes) contains compressed data. Uncompressed, the 5135 ** size is nOut bytes. This function uncompresses the data and sets the 5136 ** return value in context pCtx to the result (a blob). 5137 ** 5138 ** If an error occurs, an error code is left in pCtx instead. 5139 */ 5140 static void zipfileInflate( 5141 sqlite3_context *pCtx, /* Store result here */ 5142 const u8 *aIn, /* Compressed data */ 5143 int nIn, /* Size of buffer aIn[] in bytes */ 5144 int nOut /* Expected output size */ 5145 ){ 5146 u8 *aRes = sqlite3_malloc(nOut); 5147 if( aRes==0 ){ 5148 sqlite3_result_error_nomem(pCtx); 5149 }else{ 5150 int err; 5151 z_stream str; 5152 memset(&str, 0, sizeof(str)); 5153 5154 str.next_in = (Byte*)aIn; 5155 str.avail_in = nIn; 5156 str.next_out = (Byte*)aRes; 5157 str.avail_out = nOut; 5158 5159 err = inflateInit2(&str, -15); 5160 if( err!=Z_OK ){ 5161 zipfileCtxErrorMsg(pCtx, "inflateInit2() failed (%d)", err); 5162 }else{ 5163 err = inflate(&str, Z_NO_FLUSH); 5164 if( err!=Z_STREAM_END ){ 5165 zipfileCtxErrorMsg(pCtx, "inflate() failed (%d)", err); 5166 }else{ 5167 sqlite3_result_blob(pCtx, aRes, nOut, zipfileFree); 5168 aRes = 0; 5169 } 5170 } 5171 sqlite3_free(aRes); 5172 inflateEnd(&str); 5173 } 5174 } 5175 5176 /* 5177 ** Buffer aIn (size nIn bytes) contains uncompressed data. This function 5178 ** compresses it and sets (*ppOut) to point to a buffer containing the 5179 ** compressed data. The caller is responsible for eventually calling 5180 ** sqlite3_free() to release buffer (*ppOut). Before returning, (*pnOut) 5181 ** is set to the size of buffer (*ppOut) in bytes. 5182 ** 5183 ** If no error occurs, SQLITE_OK is returned. Otherwise, an SQLite error 5184 ** code is returned and an error message left in virtual-table handle 5185 ** pTab. The values of (*ppOut) and (*pnOut) are left unchanged in this 5186 ** case. 5187 */ 5188 static int zipfileDeflate( 5189 const u8 *aIn, int nIn, /* Input */ 5190 u8 **ppOut, int *pnOut, /* Output */ 5191 char **pzErr /* OUT: Error message */ 5192 ){ 5193 sqlite3_int64 nAlloc = compressBound(nIn); 5194 u8 *aOut; 5195 int rc = SQLITE_OK; 5196 5197 aOut = (u8*)sqlite3_malloc64(nAlloc); 5198 if( aOut==0 ){ 5199 rc = SQLITE_NOMEM; 5200 }else{ 5201 int res; 5202 z_stream str; 5203 memset(&str, 0, sizeof(str)); 5204 str.next_in = (Bytef*)aIn; 5205 str.avail_in = nIn; 5206 str.next_out = aOut; 5207 str.avail_out = nAlloc; 5208 5209 deflateInit2(&str, 9, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY); 5210 res = deflate(&str, Z_FINISH); 5211 5212 if( res==Z_STREAM_END ){ 5213 *ppOut = aOut; 5214 *pnOut = (int)str.total_out; 5215 }else{ 5216 sqlite3_free(aOut); 5217 *pzErr = sqlite3_mprintf("zipfile: deflate() error"); 5218 rc = SQLITE_ERROR; 5219 } 5220 deflateEnd(&str); 5221 } 5222 5223 return rc; 5224 } 5225 5226 5227 /* 5228 ** Return values of columns for the row at which the series_cursor 5229 ** is currently pointing. 5230 */ 5231 static int zipfileColumn( 5232 sqlite3_vtab_cursor *cur, /* The cursor */ 5233 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 5234 int i /* Which column to return */ 5235 ){ 5236 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5237 ZipfileCDS *pCDS = &pCsr->pCurrent->cds; 5238 int rc = SQLITE_OK; 5239 switch( i ){ 5240 case 0: /* name */ 5241 sqlite3_result_text(ctx, pCDS->zFile, -1, SQLITE_TRANSIENT); 5242 break; 5243 case 1: /* mode */ 5244 /* TODO: Whether or not the following is correct surely depends on 5245 ** the platform on which the archive was created. */ 5246 sqlite3_result_int(ctx, pCDS->iExternalAttr >> 16); 5247 break; 5248 case 2: { /* mtime */ 5249 sqlite3_result_int64(ctx, pCsr->pCurrent->mUnixTime); 5250 break; 5251 } 5252 case 3: { /* sz */ 5253 if( sqlite3_vtab_nochange(ctx)==0 ){ 5254 sqlite3_result_int64(ctx, pCDS->szUncompressed); 5255 } 5256 break; 5257 } 5258 case 4: /* rawdata */ 5259 if( sqlite3_vtab_nochange(ctx) ) break; 5260 case 5: { /* data */ 5261 if( i==4 || pCDS->iCompression==0 || pCDS->iCompression==8 ){ 5262 int sz = pCDS->szCompressed; 5263 int szFinal = pCDS->szUncompressed; 5264 if( szFinal>0 ){ 5265 u8 *aBuf; 5266 u8 *aFree = 0; 5267 if( pCsr->pCurrent->aData ){ 5268 aBuf = pCsr->pCurrent->aData; 5269 }else{ 5270 aBuf = aFree = sqlite3_malloc64(sz); 5271 if( aBuf==0 ){ 5272 rc = SQLITE_NOMEM; 5273 }else{ 5274 FILE *pFile = pCsr->pFile; 5275 if( pFile==0 ){ 5276 pFile = ((ZipfileTab*)(pCsr->base.pVtab))->pWriteFd; 5277 } 5278 rc = zipfileReadData(pFile, aBuf, sz, pCsr->pCurrent->iDataOff, 5279 &pCsr->base.pVtab->zErrMsg 5280 ); 5281 } 5282 } 5283 if( rc==SQLITE_OK ){ 5284 if( i==5 && pCDS->iCompression ){ 5285 zipfileInflate(ctx, aBuf, sz, szFinal); 5286 }else{ 5287 sqlite3_result_blob(ctx, aBuf, sz, SQLITE_TRANSIENT); 5288 } 5289 } 5290 sqlite3_free(aFree); 5291 }else{ 5292 /* Figure out if this is a directory or a zero-sized file. Consider 5293 ** it to be a directory either if the mode suggests so, or if 5294 ** the final character in the name is '/'. */ 5295 u32 mode = pCDS->iExternalAttr >> 16; 5296 if( !(mode & S_IFDIR) && pCDS->zFile[pCDS->nFile-1]!='/' ){ 5297 sqlite3_result_blob(ctx, "", 0, SQLITE_STATIC); 5298 } 5299 } 5300 } 5301 break; 5302 } 5303 case 6: /* method */ 5304 sqlite3_result_int(ctx, pCDS->iCompression); 5305 break; 5306 default: /* z */ 5307 assert( i==7 ); 5308 sqlite3_result_int64(ctx, pCsr->iId); 5309 break; 5310 } 5311 5312 return rc; 5313 } 5314 5315 /* 5316 ** Return TRUE if the cursor is at EOF. 5317 */ 5318 static int zipfileEof(sqlite3_vtab_cursor *cur){ 5319 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5320 return pCsr->bEof; 5321 } 5322 5323 /* 5324 ** If aBlob is not NULL, then it points to a buffer nBlob bytes in size 5325 ** containing an entire zip archive image. Or, if aBlob is NULL, then pFile 5326 ** is guaranteed to be a file-handle open on a zip file. 5327 ** 5328 ** This function attempts to locate the EOCD record within the zip archive 5329 ** and populate *pEOCD with the results of decoding it. SQLITE_OK is 5330 ** returned if successful. Otherwise, an SQLite error code is returned and 5331 ** an English language error message may be left in virtual-table pTab. 5332 */ 5333 static int zipfileReadEOCD( 5334 ZipfileTab *pTab, /* Return errors here */ 5335 const u8 *aBlob, /* Pointer to in-memory file image */ 5336 int nBlob, /* Size of aBlob[] in bytes */ 5337 FILE *pFile, /* Read from this file if aBlob==0 */ 5338 ZipfileEOCD *pEOCD /* Object to populate */ 5339 ){ 5340 u8 *aRead = pTab->aBuffer; /* Temporary buffer */ 5341 int nRead; /* Bytes to read from file */ 5342 int rc = SQLITE_OK; 5343 5344 if( aBlob==0 ){ 5345 i64 iOff; /* Offset to read from */ 5346 i64 szFile; /* Total size of file in bytes */ 5347 fseek(pFile, 0, SEEK_END); 5348 szFile = (i64)ftell(pFile); 5349 if( szFile==0 ){ 5350 memset(pEOCD, 0, sizeof(ZipfileEOCD)); 5351 return SQLITE_OK; 5352 } 5353 nRead = (int)(MIN(szFile, ZIPFILE_BUFFER_SIZE)); 5354 iOff = szFile - nRead; 5355 rc = zipfileReadData(pFile, aRead, nRead, iOff, &pTab->base.zErrMsg); 5356 }else{ 5357 nRead = (int)(MIN(nBlob, ZIPFILE_BUFFER_SIZE)); 5358 aRead = (u8*)&aBlob[nBlob-nRead]; 5359 } 5360 5361 if( rc==SQLITE_OK ){ 5362 int i; 5363 5364 /* Scan backwards looking for the signature bytes */ 5365 for(i=nRead-20; i>=0; i--){ 5366 if( aRead[i]==0x50 && aRead[i+1]==0x4b 5367 && aRead[i+2]==0x05 && aRead[i+3]==0x06 5368 ){ 5369 break; 5370 } 5371 } 5372 if( i<0 ){ 5373 pTab->base.zErrMsg = sqlite3_mprintf( 5374 "cannot find end of central directory record" 5375 ); 5376 return SQLITE_ERROR; 5377 } 5378 5379 aRead += i+4; 5380 pEOCD->iDisk = zipfileRead16(aRead); 5381 pEOCD->iFirstDisk = zipfileRead16(aRead); 5382 pEOCD->nEntry = zipfileRead16(aRead); 5383 pEOCD->nEntryTotal = zipfileRead16(aRead); 5384 pEOCD->nSize = zipfileRead32(aRead); 5385 pEOCD->iOffset = zipfileRead32(aRead); 5386 } 5387 5388 return rc; 5389 } 5390 5391 /* 5392 ** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry 5393 ** and ends with pLastEntry. If argument pBefore is NULL, then pNew is added 5394 ** to the end of the list. Otherwise, it is added to the list immediately 5395 ** before pBefore (which is guaranteed to be a part of said list). 5396 */ 5397 static void zipfileAddEntry( 5398 ZipfileTab *pTab, 5399 ZipfileEntry *pBefore, 5400 ZipfileEntry *pNew 5401 ){ 5402 assert( (pTab->pFirstEntry==0)==(pTab->pLastEntry==0) ); 5403 assert( pNew->pNext==0 ); 5404 if( pBefore==0 ){ 5405 if( pTab->pFirstEntry==0 ){ 5406 pTab->pFirstEntry = pTab->pLastEntry = pNew; 5407 }else{ 5408 assert( pTab->pLastEntry->pNext==0 ); 5409 pTab->pLastEntry->pNext = pNew; 5410 pTab->pLastEntry = pNew; 5411 } 5412 }else{ 5413 ZipfileEntry **pp; 5414 for(pp=&pTab->pFirstEntry; *pp!=pBefore; pp=&((*pp)->pNext)); 5415 pNew->pNext = pBefore; 5416 *pp = pNew; 5417 } 5418 } 5419 5420 static int zipfileLoadDirectory(ZipfileTab *pTab, const u8 *aBlob, int nBlob){ 5421 ZipfileEOCD eocd; 5422 int rc; 5423 int i; 5424 i64 iOff; 5425 5426 rc = zipfileReadEOCD(pTab, aBlob, nBlob, pTab->pWriteFd, &eocd); 5427 iOff = eocd.iOffset; 5428 for(i=0; rc==SQLITE_OK && i<eocd.nEntry; i++){ 5429 ZipfileEntry *pNew = 0; 5430 rc = zipfileGetEntry(pTab, aBlob, nBlob, pTab->pWriteFd, iOff, &pNew); 5431 5432 if( rc==SQLITE_OK ){ 5433 zipfileAddEntry(pTab, 0, pNew); 5434 iOff += ZIPFILE_CDS_FIXED_SZ; 5435 iOff += (int)pNew->cds.nExtra + pNew->cds.nFile + pNew->cds.nComment; 5436 } 5437 } 5438 return rc; 5439 } 5440 5441 /* 5442 ** xFilter callback. 5443 */ 5444 static int zipfileFilter( 5445 sqlite3_vtab_cursor *cur, 5446 int idxNum, const char *idxStr, 5447 int argc, sqlite3_value **argv 5448 ){ 5449 ZipfileTab *pTab = (ZipfileTab*)cur->pVtab; 5450 ZipfileCsr *pCsr = (ZipfileCsr*)cur; 5451 const char *zFile = 0; /* Zip file to scan */ 5452 int rc = SQLITE_OK; /* Return Code */ 5453 int bInMemory = 0; /* True for an in-memory zipfile */ 5454 5455 zipfileResetCursor(pCsr); 5456 5457 if( pTab->zFile ){ 5458 zFile = pTab->zFile; 5459 }else if( idxNum==0 ){ 5460 zipfileCursorErr(pCsr, "zipfile() function requires an argument"); 5461 return SQLITE_ERROR; 5462 }else if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){ 5463 const u8 *aBlob = (const u8*)sqlite3_value_blob(argv[0]); 5464 int nBlob = sqlite3_value_bytes(argv[0]); 5465 assert( pTab->pFirstEntry==0 ); 5466 rc = zipfileLoadDirectory(pTab, aBlob, nBlob); 5467 pCsr->pFreeEntry = pTab->pFirstEntry; 5468 pTab->pFirstEntry = pTab->pLastEntry = 0; 5469 if( rc!=SQLITE_OK ) return rc; 5470 bInMemory = 1; 5471 }else{ 5472 zFile = (const char*)sqlite3_value_text(argv[0]); 5473 } 5474 5475 if( 0==pTab->pWriteFd && 0==bInMemory ){ 5476 pCsr->pFile = fopen(zFile, "rb"); 5477 if( pCsr->pFile==0 ){ 5478 zipfileCursorErr(pCsr, "cannot open file: %s", zFile); 5479 rc = SQLITE_ERROR; 5480 }else{ 5481 rc = zipfileReadEOCD(pTab, 0, 0, pCsr->pFile, &pCsr->eocd); 5482 if( rc==SQLITE_OK ){ 5483 if( pCsr->eocd.nEntry==0 ){ 5484 pCsr->bEof = 1; 5485 }else{ 5486 pCsr->iNextOff = pCsr->eocd.iOffset; 5487 rc = zipfileNext(cur); 5488 } 5489 } 5490 } 5491 }else{ 5492 pCsr->bNoop = 1; 5493 pCsr->pCurrent = pCsr->pFreeEntry ? pCsr->pFreeEntry : pTab->pFirstEntry; 5494 rc = zipfileNext(cur); 5495 } 5496 5497 return rc; 5498 } 5499 5500 /* 5501 ** xBestIndex callback. 5502 */ 5503 static int zipfileBestIndex( 5504 sqlite3_vtab *tab, 5505 sqlite3_index_info *pIdxInfo 5506 ){ 5507 int i; 5508 int idx = -1; 5509 int unusable = 0; 5510 5511 for(i=0; i<pIdxInfo->nConstraint; i++){ 5512 const struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i]; 5513 if( pCons->iColumn!=ZIPFILE_F_COLUMN_IDX ) continue; 5514 if( pCons->usable==0 ){ 5515 unusable = 1; 5516 }else if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 5517 idx = i; 5518 } 5519 } 5520 if( idx>=0 ){ 5521 pIdxInfo->aConstraintUsage[idx].argvIndex = 1; 5522 pIdxInfo->aConstraintUsage[idx].omit = 1; 5523 pIdxInfo->estimatedCost = 1000.0; 5524 pIdxInfo->idxNum = 1; 5525 }else if( unusable ){ 5526 return SQLITE_CONSTRAINT; 5527 } 5528 return SQLITE_OK; 5529 } 5530 5531 static ZipfileEntry *zipfileNewEntry(const char *zPath){ 5532 ZipfileEntry *pNew; 5533 pNew = sqlite3_malloc(sizeof(ZipfileEntry)); 5534 if( pNew ){ 5535 memset(pNew, 0, sizeof(ZipfileEntry)); 5536 pNew->cds.zFile = sqlite3_mprintf("%s", zPath); 5537 if( pNew->cds.zFile==0 ){ 5538 sqlite3_free(pNew); 5539 pNew = 0; 5540 } 5541 } 5542 return pNew; 5543 } 5544 5545 static int zipfileSerializeLFH(ZipfileEntry *pEntry, u8 *aBuf){ 5546 ZipfileCDS *pCds = &pEntry->cds; 5547 u8 *a = aBuf; 5548 5549 pCds->nExtra = 9; 5550 5551 /* Write the LFH itself */ 5552 zipfileWrite32(a, ZIPFILE_SIGNATURE_LFH); 5553 zipfileWrite16(a, pCds->iVersionExtract); 5554 zipfileWrite16(a, pCds->flags); 5555 zipfileWrite16(a, pCds->iCompression); 5556 zipfileWrite16(a, pCds->mTime); 5557 zipfileWrite16(a, pCds->mDate); 5558 zipfileWrite32(a, pCds->crc32); 5559 zipfileWrite32(a, pCds->szCompressed); 5560 zipfileWrite32(a, pCds->szUncompressed); 5561 zipfileWrite16(a, (u16)pCds->nFile); 5562 zipfileWrite16(a, pCds->nExtra); 5563 assert( a==&aBuf[ZIPFILE_LFH_FIXED_SZ] ); 5564 5565 /* Add the file name */ 5566 memcpy(a, pCds->zFile, (int)pCds->nFile); 5567 a += (int)pCds->nFile; 5568 5569 /* The "extra" data */ 5570 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP); 5571 zipfileWrite16(a, 5); 5572 *a++ = 0x01; 5573 zipfileWrite32(a, pEntry->mUnixTime); 5574 5575 return a-aBuf; 5576 } 5577 5578 static int zipfileAppendEntry( 5579 ZipfileTab *pTab, 5580 ZipfileEntry *pEntry, 5581 const u8 *pData, 5582 int nData 5583 ){ 5584 u8 *aBuf = pTab->aBuffer; 5585 int nBuf; 5586 int rc; 5587 5588 nBuf = zipfileSerializeLFH(pEntry, aBuf); 5589 rc = zipfileAppendData(pTab, aBuf, nBuf); 5590 if( rc==SQLITE_OK ){ 5591 pEntry->iDataOff = pTab->szCurrent; 5592 rc = zipfileAppendData(pTab, pData, nData); 5593 } 5594 5595 return rc; 5596 } 5597 5598 static int zipfileGetMode( 5599 sqlite3_value *pVal, 5600 int bIsDir, /* If true, default to directory */ 5601 u32 *pMode, /* OUT: Mode value */ 5602 char **pzErr /* OUT: Error message */ 5603 ){ 5604 const char *z = (const char*)sqlite3_value_text(pVal); 5605 u32 mode = 0; 5606 if( z==0 ){ 5607 mode = (bIsDir ? (S_IFDIR + 0755) : (S_IFREG + 0644)); 5608 }else if( z[0]>='0' && z[0]<='9' ){ 5609 mode = (unsigned int)sqlite3_value_int(pVal); 5610 }else{ 5611 const char zTemplate[11] = "-rwxrwxrwx"; 5612 int i; 5613 if( strlen(z)!=10 ) goto parse_error; 5614 switch( z[0] ){ 5615 case '-': mode |= S_IFREG; break; 5616 case 'd': mode |= S_IFDIR; break; 5617 case 'l': mode |= S_IFLNK; break; 5618 default: goto parse_error; 5619 } 5620 for(i=1; i<10; i++){ 5621 if( z[i]==zTemplate[i] ) mode |= 1 << (9-i); 5622 else if( z[i]!='-' ) goto parse_error; 5623 } 5624 } 5625 if( ((mode & S_IFDIR)==0)==bIsDir ){ 5626 /* The "mode" attribute is a directory, but data has been specified. 5627 ** Or vice-versa - no data but "mode" is a file or symlink. */ 5628 *pzErr = sqlite3_mprintf("zipfile: mode does not match data"); 5629 return SQLITE_CONSTRAINT; 5630 } 5631 *pMode = mode; 5632 return SQLITE_OK; 5633 5634 parse_error: 5635 *pzErr = sqlite3_mprintf("zipfile: parse error in mode: %s", z); 5636 return SQLITE_ERROR; 5637 } 5638 5639 /* 5640 ** Both (const char*) arguments point to nul-terminated strings. Argument 5641 ** nB is the value of strlen(zB). This function returns 0 if the strings are 5642 ** identical, ignoring any trailing '/' character in either path. */ 5643 static int zipfileComparePath(const char *zA, const char *zB, int nB){ 5644 int nA = (int)strlen(zA); 5645 if( zA[nA-1]=='/' ) nA--; 5646 if( zB[nB-1]=='/' ) nB--; 5647 if( nA==nB && memcmp(zA, zB, nA)==0 ) return 0; 5648 return 1; 5649 } 5650 5651 static int zipfileBegin(sqlite3_vtab *pVtab){ 5652 ZipfileTab *pTab = (ZipfileTab*)pVtab; 5653 int rc = SQLITE_OK; 5654 5655 assert( pTab->pWriteFd==0 ); 5656 5657 /* Open a write fd on the file. Also load the entire central directory 5658 ** structure into memory. During the transaction any new file data is 5659 ** appended to the archive file, but the central directory is accumulated 5660 ** in main-memory until the transaction is committed. */ 5661 pTab->pWriteFd = fopen(pTab->zFile, "ab+"); 5662 if( pTab->pWriteFd==0 ){ 5663 pTab->base.zErrMsg = sqlite3_mprintf( 5664 "zipfile: failed to open file %s for writing", pTab->zFile 5665 ); 5666 rc = SQLITE_ERROR; 5667 }else{ 5668 fseek(pTab->pWriteFd, 0, SEEK_END); 5669 pTab->szCurrent = pTab->szOrig = (i64)ftell(pTab->pWriteFd); 5670 rc = zipfileLoadDirectory(pTab, 0, 0); 5671 } 5672 5673 if( rc!=SQLITE_OK ){ 5674 zipfileCleanupTransaction(pTab); 5675 } 5676 5677 return rc; 5678 } 5679 5680 /* 5681 ** Return the current time as a 32-bit timestamp in UNIX epoch format (like 5682 ** time(2)). 5683 */ 5684 static u32 zipfileTime(void){ 5685 sqlite3_vfs *pVfs = sqlite3_vfs_find(0); 5686 u32 ret; 5687 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ 5688 i64 ms; 5689 pVfs->xCurrentTimeInt64(pVfs, &ms); 5690 ret = (u32)((ms/1000) - ((i64)24405875 * 8640)); 5691 }else{ 5692 double day; 5693 pVfs->xCurrentTime(pVfs, &day); 5694 ret = (u32)((day - 2440587.5) * 86400); 5695 } 5696 return ret; 5697 } 5698 5699 /* 5700 ** Return a 32-bit timestamp in UNIX epoch format. 5701 ** 5702 ** If the value passed as the only argument is either NULL or an SQL NULL, 5703 ** return the current time. Otherwise, return the value stored in (*pVal) 5704 ** cast to a 32-bit unsigned integer. 5705 */ 5706 static u32 zipfileGetTime(sqlite3_value *pVal){ 5707 if( pVal==0 || sqlite3_value_type(pVal)==SQLITE_NULL ){ 5708 return zipfileTime(); 5709 } 5710 return (u32)sqlite3_value_int64(pVal); 5711 } 5712 5713 /* 5714 ** Unless it is NULL, entry pOld is currently part of the pTab->pFirstEntry 5715 ** linked list. Remove it from the list and free the object. 5716 */ 5717 static void zipfileRemoveEntryFromList(ZipfileTab *pTab, ZipfileEntry *pOld){ 5718 if( pOld ){ 5719 ZipfileEntry **pp; 5720 for(pp=&pTab->pFirstEntry; (*pp)!=pOld; pp=&((*pp)->pNext)); 5721 *pp = (*pp)->pNext; 5722 zipfileEntryFree(pOld); 5723 } 5724 } 5725 5726 /* 5727 ** xUpdate method. 5728 */ 5729 static int zipfileUpdate( 5730 sqlite3_vtab *pVtab, 5731 int nVal, 5732 sqlite3_value **apVal, 5733 sqlite_int64 *pRowid 5734 ){ 5735 ZipfileTab *pTab = (ZipfileTab*)pVtab; 5736 int rc = SQLITE_OK; /* Return Code */ 5737 ZipfileEntry *pNew = 0; /* New in-memory CDS entry */ 5738 5739 u32 mode = 0; /* Mode for new entry */ 5740 u32 mTime = 0; /* Modification time for new entry */ 5741 i64 sz = 0; /* Uncompressed size */ 5742 const char *zPath = 0; /* Path for new entry */ 5743 int nPath = 0; /* strlen(zPath) */ 5744 const u8 *pData = 0; /* Pointer to buffer containing content */ 5745 int nData = 0; /* Size of pData buffer in bytes */ 5746 int iMethod = 0; /* Compression method for new entry */ 5747 u8 *pFree = 0; /* Free this */ 5748 char *zFree = 0; /* Also free this */ 5749 ZipfileEntry *pOld = 0; 5750 ZipfileEntry *pOld2 = 0; 5751 int bUpdate = 0; /* True for an update that modifies "name" */ 5752 int bIsDir = 0; 5753 u32 iCrc32 = 0; 5754 5755 if( pTab->pWriteFd==0 ){ 5756 rc = zipfileBegin(pVtab); 5757 if( rc!=SQLITE_OK ) return rc; 5758 } 5759 5760 /* If this is a DELETE or UPDATE, find the archive entry to delete. */ 5761 if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){ 5762 const char *zDelete = (const char*)sqlite3_value_text(apVal[0]); 5763 int nDelete = (int)strlen(zDelete); 5764 if( nVal>1 ){ 5765 const char *zUpdate = (const char*)sqlite3_value_text(apVal[1]); 5766 if( zUpdate && zipfileComparePath(zUpdate, zDelete, nDelete)!=0 ){ 5767 bUpdate = 1; 5768 } 5769 } 5770 for(pOld=pTab->pFirstEntry; 1; pOld=pOld->pNext){ 5771 if( zipfileComparePath(pOld->cds.zFile, zDelete, nDelete)==0 ){ 5772 break; 5773 } 5774 assert( pOld->pNext ); 5775 } 5776 } 5777 5778 if( nVal>1 ){ 5779 /* Check that "sz" and "rawdata" are both NULL: */ 5780 if( sqlite3_value_type(apVal[5])!=SQLITE_NULL ){ 5781 zipfileTableErr(pTab, "sz must be NULL"); 5782 rc = SQLITE_CONSTRAINT; 5783 } 5784 if( sqlite3_value_type(apVal[6])!=SQLITE_NULL ){ 5785 zipfileTableErr(pTab, "rawdata must be NULL"); 5786 rc = SQLITE_CONSTRAINT; 5787 } 5788 5789 if( rc==SQLITE_OK ){ 5790 if( sqlite3_value_type(apVal[7])==SQLITE_NULL ){ 5791 /* data=NULL. A directory */ 5792 bIsDir = 1; 5793 }else{ 5794 /* Value specified for "data", and possibly "method". This must be 5795 ** a regular file or a symlink. */ 5796 const u8 *aIn = sqlite3_value_blob(apVal[7]); 5797 int nIn = sqlite3_value_bytes(apVal[7]); 5798 int bAuto = sqlite3_value_type(apVal[8])==SQLITE_NULL; 5799 5800 iMethod = sqlite3_value_int(apVal[8]); 5801 sz = nIn; 5802 pData = aIn; 5803 nData = nIn; 5804 if( iMethod!=0 && iMethod!=8 ){ 5805 zipfileTableErr(pTab, "unknown compression method: %d", iMethod); 5806 rc = SQLITE_CONSTRAINT; 5807 }else{ 5808 if( bAuto || iMethod ){ 5809 int nCmp; 5810 rc = zipfileDeflate(aIn, nIn, &pFree, &nCmp, &pTab->base.zErrMsg); 5811 if( rc==SQLITE_OK ){ 5812 if( iMethod || nCmp<nIn ){ 5813 iMethod = 8; 5814 pData = pFree; 5815 nData = nCmp; 5816 } 5817 } 5818 } 5819 iCrc32 = crc32(0, aIn, nIn); 5820 } 5821 } 5822 } 5823 5824 if( rc==SQLITE_OK ){ 5825 rc = zipfileGetMode(apVal[3], bIsDir, &mode, &pTab->base.zErrMsg); 5826 } 5827 5828 if( rc==SQLITE_OK ){ 5829 zPath = (const char*)sqlite3_value_text(apVal[2]); 5830 nPath = (int)strlen(zPath); 5831 mTime = zipfileGetTime(apVal[4]); 5832 } 5833 5834 if( rc==SQLITE_OK && bIsDir ){ 5835 /* For a directory, check that the last character in the path is a 5836 ** '/'. This appears to be required for compatibility with info-zip 5837 ** (the unzip command on unix). It does not create directories 5838 ** otherwise. */ 5839 if( zPath[nPath-1]!='/' ){ 5840 zFree = sqlite3_mprintf("%s/", zPath); 5841 if( zFree==0 ){ rc = SQLITE_NOMEM; } 5842 zPath = (const char*)zFree; 5843 nPath++; 5844 } 5845 } 5846 5847 /* Check that we're not inserting a duplicate entry -OR- updating an 5848 ** entry with a path, thereby making it into a duplicate. */ 5849 if( (pOld==0 || bUpdate) && rc==SQLITE_OK ){ 5850 ZipfileEntry *p; 5851 for(p=pTab->pFirstEntry; p; p=p->pNext){ 5852 if( zipfileComparePath(p->cds.zFile, zPath, nPath)==0 ){ 5853 switch( sqlite3_vtab_on_conflict(pTab->db) ){ 5854 case SQLITE_IGNORE: { 5855 goto zipfile_update_done; 5856 } 5857 case SQLITE_REPLACE: { 5858 pOld2 = p; 5859 break; 5860 } 5861 default: { 5862 zipfileTableErr(pTab, "duplicate name: \"%s\"", zPath); 5863 rc = SQLITE_CONSTRAINT; 5864 break; 5865 } 5866 } 5867 break; 5868 } 5869 } 5870 } 5871 5872 if( rc==SQLITE_OK ){ 5873 /* Create the new CDS record. */ 5874 pNew = zipfileNewEntry(zPath); 5875 if( pNew==0 ){ 5876 rc = SQLITE_NOMEM; 5877 }else{ 5878 pNew->cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY; 5879 pNew->cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED; 5880 pNew->cds.flags = ZIPFILE_NEWENTRY_FLAGS; 5881 pNew->cds.iCompression = (u16)iMethod; 5882 zipfileMtimeToDos(&pNew->cds, mTime); 5883 pNew->cds.crc32 = iCrc32; 5884 pNew->cds.szCompressed = nData; 5885 pNew->cds.szUncompressed = (u32)sz; 5886 pNew->cds.iExternalAttr = (mode<<16); 5887 pNew->cds.iOffset = (u32)pTab->szCurrent; 5888 pNew->cds.nFile = (u16)nPath; 5889 pNew->mUnixTime = (u32)mTime; 5890 rc = zipfileAppendEntry(pTab, pNew, pData, nData); 5891 zipfileAddEntry(pTab, pOld, pNew); 5892 } 5893 } 5894 } 5895 5896 if( rc==SQLITE_OK && (pOld || pOld2) ){ 5897 ZipfileCsr *pCsr; 5898 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){ 5899 if( pCsr->pCurrent && (pCsr->pCurrent==pOld || pCsr->pCurrent==pOld2) ){ 5900 pCsr->pCurrent = pCsr->pCurrent->pNext; 5901 pCsr->bNoop = 1; 5902 } 5903 } 5904 5905 zipfileRemoveEntryFromList(pTab, pOld); 5906 zipfileRemoveEntryFromList(pTab, pOld2); 5907 } 5908 5909 zipfile_update_done: 5910 sqlite3_free(pFree); 5911 sqlite3_free(zFree); 5912 return rc; 5913 } 5914 5915 static int zipfileSerializeEOCD(ZipfileEOCD *p, u8 *aBuf){ 5916 u8 *a = aBuf; 5917 zipfileWrite32(a, ZIPFILE_SIGNATURE_EOCD); 5918 zipfileWrite16(a, p->iDisk); 5919 zipfileWrite16(a, p->iFirstDisk); 5920 zipfileWrite16(a, p->nEntry); 5921 zipfileWrite16(a, p->nEntryTotal); 5922 zipfileWrite32(a, p->nSize); 5923 zipfileWrite32(a, p->iOffset); 5924 zipfileWrite16(a, 0); /* Size of trailing comment in bytes*/ 5925 5926 return a-aBuf; 5927 } 5928 5929 static int zipfileAppendEOCD(ZipfileTab *pTab, ZipfileEOCD *p){ 5930 int nBuf = zipfileSerializeEOCD(p, pTab->aBuffer); 5931 assert( nBuf==ZIPFILE_EOCD_FIXED_SZ ); 5932 return zipfileAppendData(pTab, pTab->aBuffer, nBuf); 5933 } 5934 5935 /* 5936 ** Serialize the CDS structure into buffer aBuf[]. Return the number 5937 ** of bytes written. 5938 */ 5939 static int zipfileSerializeCDS(ZipfileEntry *pEntry, u8 *aBuf){ 5940 u8 *a = aBuf; 5941 ZipfileCDS *pCDS = &pEntry->cds; 5942 5943 if( pEntry->aExtra==0 ){ 5944 pCDS->nExtra = 9; 5945 } 5946 5947 zipfileWrite32(a, ZIPFILE_SIGNATURE_CDS); 5948 zipfileWrite16(a, pCDS->iVersionMadeBy); 5949 zipfileWrite16(a, pCDS->iVersionExtract); 5950 zipfileWrite16(a, pCDS->flags); 5951 zipfileWrite16(a, pCDS->iCompression); 5952 zipfileWrite16(a, pCDS->mTime); 5953 zipfileWrite16(a, pCDS->mDate); 5954 zipfileWrite32(a, pCDS->crc32); 5955 zipfileWrite32(a, pCDS->szCompressed); 5956 zipfileWrite32(a, pCDS->szUncompressed); 5957 assert( a==&aBuf[ZIPFILE_CDS_NFILE_OFF] ); 5958 zipfileWrite16(a, pCDS->nFile); 5959 zipfileWrite16(a, pCDS->nExtra); 5960 zipfileWrite16(a, pCDS->nComment); 5961 zipfileWrite16(a, pCDS->iDiskStart); 5962 zipfileWrite16(a, pCDS->iInternalAttr); 5963 zipfileWrite32(a, pCDS->iExternalAttr); 5964 zipfileWrite32(a, pCDS->iOffset); 5965 5966 memcpy(a, pCDS->zFile, pCDS->nFile); 5967 a += pCDS->nFile; 5968 5969 if( pEntry->aExtra ){ 5970 int n = (int)pCDS->nExtra + (int)pCDS->nComment; 5971 memcpy(a, pEntry->aExtra, n); 5972 a += n; 5973 }else{ 5974 assert( pCDS->nExtra==9 ); 5975 zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP); 5976 zipfileWrite16(a, 5); 5977 *a++ = 0x01; 5978 zipfileWrite32(a, pEntry->mUnixTime); 5979 } 5980 5981 return a-aBuf; 5982 } 5983 5984 static int zipfileCommit(sqlite3_vtab *pVtab){ 5985 ZipfileTab *pTab = (ZipfileTab*)pVtab; 5986 int rc = SQLITE_OK; 5987 if( pTab->pWriteFd ){ 5988 i64 iOffset = pTab->szCurrent; 5989 ZipfileEntry *p; 5990 ZipfileEOCD eocd; 5991 int nEntry = 0; 5992 5993 /* Write out all entries */ 5994 for(p=pTab->pFirstEntry; rc==SQLITE_OK && p; p=p->pNext){ 5995 int n = zipfileSerializeCDS(p, pTab->aBuffer); 5996 rc = zipfileAppendData(pTab, pTab->aBuffer, n); 5997 nEntry++; 5998 } 5999 6000 /* Write out the EOCD record */ 6001 eocd.iDisk = 0; 6002 eocd.iFirstDisk = 0; 6003 eocd.nEntry = (u16)nEntry; 6004 eocd.nEntryTotal = (u16)nEntry; 6005 eocd.nSize = (u32)(pTab->szCurrent - iOffset); 6006 eocd.iOffset = (u32)iOffset; 6007 rc = zipfileAppendEOCD(pTab, &eocd); 6008 6009 zipfileCleanupTransaction(pTab); 6010 } 6011 return rc; 6012 } 6013 6014 static int zipfileRollback(sqlite3_vtab *pVtab){ 6015 return zipfileCommit(pVtab); 6016 } 6017 6018 static ZipfileCsr *zipfileFindCursor(ZipfileTab *pTab, i64 iId){ 6019 ZipfileCsr *pCsr; 6020 for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){ 6021 if( iId==pCsr->iId ) break; 6022 } 6023 return pCsr; 6024 } 6025 6026 static void zipfileFunctionCds( 6027 sqlite3_context *context, 6028 int argc, 6029 sqlite3_value **argv 6030 ){ 6031 ZipfileCsr *pCsr; 6032 ZipfileTab *pTab = (ZipfileTab*)sqlite3_user_data(context); 6033 assert( argc>0 ); 6034 6035 pCsr = zipfileFindCursor(pTab, sqlite3_value_int64(argv[0])); 6036 if( pCsr ){ 6037 ZipfileCDS *p = &pCsr->pCurrent->cds; 6038 char *zRes = sqlite3_mprintf("{" 6039 "\"version-made-by\" : %u, " 6040 "\"version-to-extract\" : %u, " 6041 "\"flags\" : %u, " 6042 "\"compression\" : %u, " 6043 "\"time\" : %u, " 6044 "\"date\" : %u, " 6045 "\"crc32\" : %u, " 6046 "\"compressed-size\" : %u, " 6047 "\"uncompressed-size\" : %u, " 6048 "\"file-name-length\" : %u, " 6049 "\"extra-field-length\" : %u, " 6050 "\"file-comment-length\" : %u, " 6051 "\"disk-number-start\" : %u, " 6052 "\"internal-attr\" : %u, " 6053 "\"external-attr\" : %u, " 6054 "\"offset\" : %u }", 6055 (u32)p->iVersionMadeBy, (u32)p->iVersionExtract, 6056 (u32)p->flags, (u32)p->iCompression, 6057 (u32)p->mTime, (u32)p->mDate, 6058 (u32)p->crc32, (u32)p->szCompressed, 6059 (u32)p->szUncompressed, (u32)p->nFile, 6060 (u32)p->nExtra, (u32)p->nComment, 6061 (u32)p->iDiskStart, (u32)p->iInternalAttr, 6062 (u32)p->iExternalAttr, (u32)p->iOffset 6063 ); 6064 6065 if( zRes==0 ){ 6066 sqlite3_result_error_nomem(context); 6067 }else{ 6068 sqlite3_result_text(context, zRes, -1, SQLITE_TRANSIENT); 6069 sqlite3_free(zRes); 6070 } 6071 } 6072 } 6073 6074 /* 6075 ** xFindFunction method. 6076 */ 6077 static int zipfileFindFunction( 6078 sqlite3_vtab *pVtab, /* Virtual table handle */ 6079 int nArg, /* Number of SQL function arguments */ 6080 const char *zName, /* Name of SQL function */ 6081 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */ 6082 void **ppArg /* OUT: User data for *pxFunc */ 6083 ){ 6084 if( sqlite3_stricmp("zipfile_cds", zName)==0 ){ 6085 *pxFunc = zipfileFunctionCds; 6086 *ppArg = (void*)pVtab; 6087 return 1; 6088 } 6089 return 0; 6090 } 6091 6092 typedef struct ZipfileBuffer ZipfileBuffer; 6093 struct ZipfileBuffer { 6094 u8 *a; /* Pointer to buffer */ 6095 int n; /* Size of buffer in bytes */ 6096 int nAlloc; /* Byte allocated at a[] */ 6097 }; 6098 6099 typedef struct ZipfileCtx ZipfileCtx; 6100 struct ZipfileCtx { 6101 int nEntry; 6102 ZipfileBuffer body; 6103 ZipfileBuffer cds; 6104 }; 6105 6106 static int zipfileBufferGrow(ZipfileBuffer *pBuf, int nByte){ 6107 if( pBuf->n+nByte>pBuf->nAlloc ){ 6108 u8 *aNew; 6109 sqlite3_int64 nNew = pBuf->n ? pBuf->n*2 : 512; 6110 int nReq = pBuf->n + nByte; 6111 6112 while( nNew<nReq ) nNew = nNew*2; 6113 aNew = sqlite3_realloc64(pBuf->a, nNew); 6114 if( aNew==0 ) return SQLITE_NOMEM; 6115 pBuf->a = aNew; 6116 pBuf->nAlloc = (int)nNew; 6117 } 6118 return SQLITE_OK; 6119 } 6120 6121 /* 6122 ** xStep() callback for the zipfile() aggregate. This can be called in 6123 ** any of the following ways: 6124 ** 6125 ** SELECT zipfile(name,data) ... 6126 ** SELECT zipfile(name,mode,mtime,data) ... 6127 ** SELECT zipfile(name,mode,mtime,data,method) ... 6128 */ 6129 void zipfileStep(sqlite3_context *pCtx, int nVal, sqlite3_value **apVal){ 6130 ZipfileCtx *p; /* Aggregate function context */ 6131 ZipfileEntry e; /* New entry to add to zip archive */ 6132 6133 sqlite3_value *pName = 0; 6134 sqlite3_value *pMode = 0; 6135 sqlite3_value *pMtime = 0; 6136 sqlite3_value *pData = 0; 6137 sqlite3_value *pMethod = 0; 6138 6139 int bIsDir = 0; 6140 u32 mode; 6141 int rc = SQLITE_OK; 6142 char *zErr = 0; 6143 6144 int iMethod = -1; /* Compression method to use (0 or 8) */ 6145 6146 const u8 *aData = 0; /* Possibly compressed data for new entry */ 6147 int nData = 0; /* Size of aData[] in bytes */ 6148 int szUncompressed = 0; /* Size of data before compression */ 6149 u8 *aFree = 0; /* Free this before returning */ 6150 u32 iCrc32 = 0; /* crc32 of uncompressed data */ 6151 6152 char *zName = 0; /* Path (name) of new entry */ 6153 int nName = 0; /* Size of zName in bytes */ 6154 char *zFree = 0; /* Free this before returning */ 6155 int nByte; 6156 6157 memset(&e, 0, sizeof(e)); 6158 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx)); 6159 if( p==0 ) return; 6160 6161 /* Martial the arguments into stack variables */ 6162 if( nVal!=2 && nVal!=4 && nVal!=5 ){ 6163 zErr = sqlite3_mprintf("wrong number of arguments to function zipfile()"); 6164 rc = SQLITE_ERROR; 6165 goto zipfile_step_out; 6166 } 6167 pName = apVal[0]; 6168 if( nVal==2 ){ 6169 pData = apVal[1]; 6170 }else{ 6171 pMode = apVal[1]; 6172 pMtime = apVal[2]; 6173 pData = apVal[3]; 6174 if( nVal==5 ){ 6175 pMethod = apVal[4]; 6176 } 6177 } 6178 6179 /* Check that the 'name' parameter looks ok. */ 6180 zName = (char*)sqlite3_value_text(pName); 6181 nName = sqlite3_value_bytes(pName); 6182 if( zName==0 ){ 6183 zErr = sqlite3_mprintf("first argument to zipfile() must be non-NULL"); 6184 rc = SQLITE_ERROR; 6185 goto zipfile_step_out; 6186 } 6187 6188 /* Inspect the 'method' parameter. This must be either 0 (store), 8 (use 6189 ** deflate compression) or NULL (choose automatically). */ 6190 if( pMethod && SQLITE_NULL!=sqlite3_value_type(pMethod) ){ 6191 iMethod = (int)sqlite3_value_int64(pMethod); 6192 if( iMethod!=0 && iMethod!=8 ){ 6193 zErr = sqlite3_mprintf("illegal method value: %d", iMethod); 6194 rc = SQLITE_ERROR; 6195 goto zipfile_step_out; 6196 } 6197 } 6198 6199 /* Now inspect the data. If this is NULL, then the new entry must be a 6200 ** directory. Otherwise, figure out whether or not the data should 6201 ** be deflated or simply stored in the zip archive. */ 6202 if( sqlite3_value_type(pData)==SQLITE_NULL ){ 6203 bIsDir = 1; 6204 iMethod = 0; 6205 }else{ 6206 aData = sqlite3_value_blob(pData); 6207 szUncompressed = nData = sqlite3_value_bytes(pData); 6208 iCrc32 = crc32(0, aData, nData); 6209 if( iMethod<0 || iMethod==8 ){ 6210 int nOut = 0; 6211 rc = zipfileDeflate(aData, nData, &aFree, &nOut, &zErr); 6212 if( rc!=SQLITE_OK ){ 6213 goto zipfile_step_out; 6214 } 6215 if( iMethod==8 || nOut<nData ){ 6216 aData = aFree; 6217 nData = nOut; 6218 iMethod = 8; 6219 }else{ 6220 iMethod = 0; 6221 } 6222 } 6223 } 6224 6225 /* Decode the "mode" argument. */ 6226 rc = zipfileGetMode(pMode, bIsDir, &mode, &zErr); 6227 if( rc ) goto zipfile_step_out; 6228 6229 /* Decode the "mtime" argument. */ 6230 e.mUnixTime = zipfileGetTime(pMtime); 6231 6232 /* If this is a directory entry, ensure that there is exactly one '/' 6233 ** at the end of the path. Or, if this is not a directory and the path 6234 ** ends in '/' it is an error. */ 6235 if( bIsDir==0 ){ 6236 if( zName[nName-1]=='/' ){ 6237 zErr = sqlite3_mprintf("non-directory name must not end with /"); 6238 rc = SQLITE_ERROR; 6239 goto zipfile_step_out; 6240 } 6241 }else{ 6242 if( zName[nName-1]!='/' ){ 6243 zName = zFree = sqlite3_mprintf("%s/", zName); 6244 nName++; 6245 if( zName==0 ){ 6246 rc = SQLITE_NOMEM; 6247 goto zipfile_step_out; 6248 } 6249 }else{ 6250 while( nName>1 && zName[nName-2]=='/' ) nName--; 6251 } 6252 } 6253 6254 /* Assemble the ZipfileEntry object for the new zip archive entry */ 6255 e.cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY; 6256 e.cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED; 6257 e.cds.flags = ZIPFILE_NEWENTRY_FLAGS; 6258 e.cds.iCompression = (u16)iMethod; 6259 zipfileMtimeToDos(&e.cds, (u32)e.mUnixTime); 6260 e.cds.crc32 = iCrc32; 6261 e.cds.szCompressed = nData; 6262 e.cds.szUncompressed = szUncompressed; 6263 e.cds.iExternalAttr = (mode<<16); 6264 e.cds.iOffset = p->body.n; 6265 e.cds.nFile = (u16)nName; 6266 e.cds.zFile = zName; 6267 6268 /* Append the LFH to the body of the new archive */ 6269 nByte = ZIPFILE_LFH_FIXED_SZ + e.cds.nFile + 9; 6270 if( (rc = zipfileBufferGrow(&p->body, nByte)) ) goto zipfile_step_out; 6271 p->body.n += zipfileSerializeLFH(&e, &p->body.a[p->body.n]); 6272 6273 /* Append the data to the body of the new archive */ 6274 if( nData>0 ){ 6275 if( (rc = zipfileBufferGrow(&p->body, nData)) ) goto zipfile_step_out; 6276 memcpy(&p->body.a[p->body.n], aData, nData); 6277 p->body.n += nData; 6278 } 6279 6280 /* Append the CDS record to the directory of the new archive */ 6281 nByte = ZIPFILE_CDS_FIXED_SZ + e.cds.nFile + 9; 6282 if( (rc = zipfileBufferGrow(&p->cds, nByte)) ) goto zipfile_step_out; 6283 p->cds.n += zipfileSerializeCDS(&e, &p->cds.a[p->cds.n]); 6284 6285 /* Increment the count of entries in the archive */ 6286 p->nEntry++; 6287 6288 zipfile_step_out: 6289 sqlite3_free(aFree); 6290 sqlite3_free(zFree); 6291 if( rc ){ 6292 if( zErr ){ 6293 sqlite3_result_error(pCtx, zErr, -1); 6294 }else{ 6295 sqlite3_result_error_code(pCtx, rc); 6296 } 6297 } 6298 sqlite3_free(zErr); 6299 } 6300 6301 /* 6302 ** xFinalize() callback for zipfile aggregate function. 6303 */ 6304 void zipfileFinal(sqlite3_context *pCtx){ 6305 ZipfileCtx *p; 6306 ZipfileEOCD eocd; 6307 sqlite3_int64 nZip; 6308 u8 *aZip; 6309 6310 p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx)); 6311 if( p==0 ) return; 6312 if( p->nEntry>0 ){ 6313 memset(&eocd, 0, sizeof(eocd)); 6314 eocd.nEntry = (u16)p->nEntry; 6315 eocd.nEntryTotal = (u16)p->nEntry; 6316 eocd.nSize = p->cds.n; 6317 eocd.iOffset = p->body.n; 6318 6319 nZip = p->body.n + p->cds.n + ZIPFILE_EOCD_FIXED_SZ; 6320 aZip = (u8*)sqlite3_malloc64(nZip); 6321 if( aZip==0 ){ 6322 sqlite3_result_error_nomem(pCtx); 6323 }else{ 6324 memcpy(aZip, p->body.a, p->body.n); 6325 memcpy(&aZip[p->body.n], p->cds.a, p->cds.n); 6326 zipfileSerializeEOCD(&eocd, &aZip[p->body.n + p->cds.n]); 6327 sqlite3_result_blob(pCtx, aZip, (int)nZip, zipfileFree); 6328 } 6329 } 6330 6331 sqlite3_free(p->body.a); 6332 sqlite3_free(p->cds.a); 6333 } 6334 6335 6336 /* 6337 ** Register the "zipfile" virtual table. 6338 */ 6339 static int zipfileRegister(sqlite3 *db){ 6340 static sqlite3_module zipfileModule = { 6341 1, /* iVersion */ 6342 zipfileConnect, /* xCreate */ 6343 zipfileConnect, /* xConnect */ 6344 zipfileBestIndex, /* xBestIndex */ 6345 zipfileDisconnect, /* xDisconnect */ 6346 zipfileDisconnect, /* xDestroy */ 6347 zipfileOpen, /* xOpen - open a cursor */ 6348 zipfileClose, /* xClose - close a cursor */ 6349 zipfileFilter, /* xFilter - configure scan constraints */ 6350 zipfileNext, /* xNext - advance a cursor */ 6351 zipfileEof, /* xEof - check for end of scan */ 6352 zipfileColumn, /* xColumn - read data */ 6353 0, /* xRowid - read data */ 6354 zipfileUpdate, /* xUpdate */ 6355 zipfileBegin, /* xBegin */ 6356 0, /* xSync */ 6357 zipfileCommit, /* xCommit */ 6358 zipfileRollback, /* xRollback */ 6359 zipfileFindFunction, /* xFindMethod */ 6360 0, /* xRename */ 6361 }; 6362 6363 int rc = sqlite3_create_module(db, "zipfile" , &zipfileModule, 0); 6364 if( rc==SQLITE_OK ) rc = sqlite3_overload_function(db, "zipfile_cds", -1); 6365 if( rc==SQLITE_OK ){ 6366 rc = sqlite3_create_function(db, "zipfile", -1, SQLITE_UTF8, 0, 0, 6367 zipfileStep, zipfileFinal 6368 ); 6369 } 6370 return rc; 6371 } 6372 #else /* SQLITE_OMIT_VIRTUALTABLE */ 6373 # define zipfileRegister(x) SQLITE_OK 6374 #endif 6375 6376 #ifdef _WIN32 6377 6378 #endif 6379 int sqlite3_zipfile_init( 6380 sqlite3 *db, 6381 char **pzErrMsg, 6382 const sqlite3_api_routines *pApi 6383 ){ 6384 SQLITE_EXTENSION_INIT2(pApi); 6385 (void)pzErrMsg; /* Unused parameter */ 6386 return zipfileRegister(db); 6387 } 6388 6389 /************************* End ../ext/misc/zipfile.c ********************/ 6390 /************************* Begin ../ext/misc/sqlar.c ******************/ 6391 /* 6392 ** 2017-12-17 6393 ** 6394 ** The author disclaims copyright to this source code. In place of 6395 ** a legal notice, here is a blessing: 6396 ** 6397 ** May you do good and not evil. 6398 ** May you find forgiveness for yourself and forgive others. 6399 ** May you share freely, never taking more than you give. 6400 ** 6401 ****************************************************************************** 6402 ** 6403 ** Utility functions sqlar_compress() and sqlar_uncompress(). Useful 6404 ** for working with sqlar archives and used by the shell tool's built-in 6405 ** sqlar support. 6406 */ 6407 /* #include "sqlite3ext.h" */ 6408 SQLITE_EXTENSION_INIT1 6409 #include <zlib.h> 6410 6411 /* 6412 ** Implementation of the "sqlar_compress(X)" SQL function. 6413 ** 6414 ** If the type of X is SQLITE_BLOB, and compressing that blob using 6415 ** zlib utility function compress() yields a smaller blob, return the 6416 ** compressed blob. Otherwise, return a copy of X. 6417 ** 6418 ** SQLar uses the "zlib format" for compressed content. The zlib format 6419 ** contains a two-byte identification header and a four-byte checksum at 6420 ** the end. This is different from ZIP which uses the raw deflate format. 6421 ** 6422 ** Future enhancements to SQLar might add support for new compression formats. 6423 ** If so, those new formats will be identified by alternative headers in the 6424 ** compressed data. 6425 */ 6426 static void sqlarCompressFunc( 6427 sqlite3_context *context, 6428 int argc, 6429 sqlite3_value **argv 6430 ){ 6431 assert( argc==1 ); 6432 if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){ 6433 const Bytef *pData = sqlite3_value_blob(argv[0]); 6434 uLong nData = sqlite3_value_bytes(argv[0]); 6435 uLongf nOut = compressBound(nData); 6436 Bytef *pOut; 6437 6438 pOut = (Bytef*)sqlite3_malloc(nOut); 6439 if( pOut==0 ){ 6440 sqlite3_result_error_nomem(context); 6441 return; 6442 }else{ 6443 if( Z_OK!=compress(pOut, &nOut, pData, nData) ){ 6444 sqlite3_result_error(context, "error in compress()", -1); 6445 }else if( nOut<nData ){ 6446 sqlite3_result_blob(context, pOut, nOut, SQLITE_TRANSIENT); 6447 }else{ 6448 sqlite3_result_value(context, argv[0]); 6449 } 6450 sqlite3_free(pOut); 6451 } 6452 }else{ 6453 sqlite3_result_value(context, argv[0]); 6454 } 6455 } 6456 6457 /* 6458 ** Implementation of the "sqlar_uncompress(X,SZ)" SQL function 6459 ** 6460 ** Parameter SZ is interpreted as an integer. If it is less than or 6461 ** equal to zero, then this function returns a copy of X. Or, if 6462 ** SZ is equal to the size of X when interpreted as a blob, also 6463 ** return a copy of X. Otherwise, decompress blob X using zlib 6464 ** utility function uncompress() and return the results (another 6465 ** blob). 6466 */ 6467 static void sqlarUncompressFunc( 6468 sqlite3_context *context, 6469 int argc, 6470 sqlite3_value **argv 6471 ){ 6472 uLong nData; 6473 uLongf sz; 6474 6475 assert( argc==2 ); 6476 sz = sqlite3_value_int(argv[1]); 6477 6478 if( sz<=0 || sz==(nData = sqlite3_value_bytes(argv[0])) ){ 6479 sqlite3_result_value(context, argv[0]); 6480 }else{ 6481 const Bytef *pData= sqlite3_value_blob(argv[0]); 6482 Bytef *pOut = sqlite3_malloc(sz); 6483 if( Z_OK!=uncompress(pOut, &sz, pData, nData) ){ 6484 sqlite3_result_error(context, "error in uncompress()", -1); 6485 }else{ 6486 sqlite3_result_blob(context, pOut, sz, SQLITE_TRANSIENT); 6487 } 6488 sqlite3_free(pOut); 6489 } 6490 } 6491 6492 6493 #ifdef _WIN32 6494 6495 #endif 6496 int sqlite3_sqlar_init( 6497 sqlite3 *db, 6498 char **pzErrMsg, 6499 const sqlite3_api_routines *pApi 6500 ){ 6501 int rc = SQLITE_OK; 6502 SQLITE_EXTENSION_INIT2(pApi); 6503 (void)pzErrMsg; /* Unused parameter */ 6504 rc = sqlite3_create_function(db, "sqlar_compress", 1, SQLITE_UTF8, 0, 6505 sqlarCompressFunc, 0, 0); 6506 if( rc==SQLITE_OK ){ 6507 rc = sqlite3_create_function(db, "sqlar_uncompress", 2, SQLITE_UTF8, 0, 6508 sqlarUncompressFunc, 0, 0); 6509 } 6510 return rc; 6511 } 6512 6513 /************************* End ../ext/misc/sqlar.c ********************/ 6514 #endif 6515 /************************* Begin ../ext/expert/sqlite3expert.h ******************/ 6516 /* 6517 ** 2017 April 07 6518 ** 6519 ** The author disclaims copyright to this source code. In place of 6520 ** a legal notice, here is a blessing: 6521 ** 6522 ** May you do good and not evil. 6523 ** May you find forgiveness for yourself and forgive others. 6524 ** May you share freely, never taking more than you give. 6525 ** 6526 ************************************************************************* 6527 */ 6528 6529 6530 /* #include "sqlite3.h" */ 6531 6532 typedef struct sqlite3expert sqlite3expert; 6533 6534 /* 6535 ** Create a new sqlite3expert object. 6536 ** 6537 ** If successful, a pointer to the new object is returned and (*pzErr) set 6538 ** to NULL. Or, if an error occurs, NULL is returned and (*pzErr) set to 6539 ** an English-language error message. In this case it is the responsibility 6540 ** of the caller to eventually free the error message buffer using 6541 ** sqlite3_free(). 6542 */ 6543 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErr); 6544 6545 /* 6546 ** Configure an sqlite3expert object. 6547 ** 6548 ** EXPERT_CONFIG_SAMPLE: 6549 ** By default, sqlite3_expert_analyze() generates sqlite_stat1 data for 6550 ** each candidate index. This involves scanning and sorting the entire 6551 ** contents of each user database table once for each candidate index 6552 ** associated with the table. For large databases, this can be 6553 ** prohibitively slow. This option allows the sqlite3expert object to 6554 ** be configured so that sqlite_stat1 data is instead generated based on a 6555 ** subset of each table, or so that no sqlite_stat1 data is used at all. 6556 ** 6557 ** A single integer argument is passed to this option. If the value is less 6558 ** than or equal to zero, then no sqlite_stat1 data is generated or used by 6559 ** the analysis - indexes are recommended based on the database schema only. 6560 ** Or, if the value is 100 or greater, complete sqlite_stat1 data is 6561 ** generated for each candidate index (this is the default). Finally, if the 6562 ** value falls between 0 and 100, then it represents the percentage of user 6563 ** table rows that should be considered when generating sqlite_stat1 data. 6564 ** 6565 ** Examples: 6566 ** 6567 ** // Do not generate any sqlite_stat1 data 6568 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 0); 6569 ** 6570 ** // Generate sqlite_stat1 data based on 10% of the rows in each table. 6571 ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 10); 6572 */ 6573 int sqlite3_expert_config(sqlite3expert *p, int op, ...); 6574 6575 #define EXPERT_CONFIG_SAMPLE 1 /* int */ 6576 6577 /* 6578 ** Specify zero or more SQL statements to be included in the analysis. 6579 ** 6580 ** Buffer zSql must contain zero or more complete SQL statements. This 6581 ** function parses all statements contained in the buffer and adds them 6582 ** to the internal list of statements to analyze. If successful, SQLITE_OK 6583 ** is returned and (*pzErr) set to NULL. Or, if an error occurs - for example 6584 ** due to a error in the SQL - an SQLite error code is returned and (*pzErr) 6585 ** may be set to point to an English language error message. In this case 6586 ** the caller is responsible for eventually freeing the error message buffer 6587 ** using sqlite3_free(). 6588 ** 6589 ** If an error does occur while processing one of the statements in the 6590 ** buffer passed as the second argument, none of the statements in the 6591 ** buffer are added to the analysis. 6592 ** 6593 ** This function must be called before sqlite3_expert_analyze(). If a call 6594 ** to this function is made on an sqlite3expert object that has already 6595 ** been passed to sqlite3_expert_analyze() SQLITE_MISUSE is returned 6596 ** immediately and no statements are added to the analysis. 6597 */ 6598 int sqlite3_expert_sql( 6599 sqlite3expert *p, /* From a successful sqlite3_expert_new() */ 6600 const char *zSql, /* SQL statement(s) to add */ 6601 char **pzErr /* OUT: Error message (if any) */ 6602 ); 6603 6604 6605 /* 6606 ** This function is called after the sqlite3expert object has been configured 6607 ** with all SQL statements using sqlite3_expert_sql() to actually perform 6608 ** the analysis. Once this function has been called, it is not possible to 6609 ** add further SQL statements to the analysis. 6610 ** 6611 ** If successful, SQLITE_OK is returned and (*pzErr) is set to NULL. Or, if 6612 ** an error occurs, an SQLite error code is returned and (*pzErr) set to 6613 ** point to a buffer containing an English language error message. In this 6614 ** case it is the responsibility of the caller to eventually free the buffer 6615 ** using sqlite3_free(). 6616 ** 6617 ** If an error does occur within this function, the sqlite3expert object 6618 ** is no longer useful for any purpose. At that point it is no longer 6619 ** possible to add further SQL statements to the object or to re-attempt 6620 ** the analysis. The sqlite3expert object must still be freed using a call 6621 ** sqlite3_expert_destroy(). 6622 */ 6623 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr); 6624 6625 /* 6626 ** Return the total number of statements loaded using sqlite3_expert_sql(). 6627 ** The total number of SQL statements may be different from the total number 6628 ** to calls to sqlite3_expert_sql(). 6629 */ 6630 int sqlite3_expert_count(sqlite3expert*); 6631 6632 /* 6633 ** Return a component of the report. 6634 ** 6635 ** This function is called after sqlite3_expert_analyze() to extract the 6636 ** results of the analysis. Each call to this function returns either a 6637 ** NULL pointer or a pointer to a buffer containing a nul-terminated string. 6638 ** The value passed as the third argument must be one of the EXPERT_REPORT_* 6639 ** #define constants defined below. 6640 ** 6641 ** For some EXPERT_REPORT_* parameters, the buffer returned contains 6642 ** information relating to a specific SQL statement. In these cases that 6643 ** SQL statement is identified by the value passed as the second argument. 6644 ** SQL statements are numbered from 0 in the order in which they are parsed. 6645 ** If an out-of-range value (less than zero or equal to or greater than the 6646 ** value returned by sqlite3_expert_count()) is passed as the second argument 6647 ** along with such an EXPERT_REPORT_* parameter, NULL is always returned. 6648 ** 6649 ** EXPERT_REPORT_SQL: 6650 ** Return the text of SQL statement iStmt. 6651 ** 6652 ** EXPERT_REPORT_INDEXES: 6653 ** Return a buffer containing the CREATE INDEX statements for all recommended 6654 ** indexes for statement iStmt. If there are no new recommeded indexes, NULL 6655 ** is returned. 6656 ** 6657 ** EXPERT_REPORT_PLAN: 6658 ** Return a buffer containing the EXPLAIN QUERY PLAN output for SQL query 6659 ** iStmt after the proposed indexes have been added to the database schema. 6660 ** 6661 ** EXPERT_REPORT_CANDIDATES: 6662 ** Return a pointer to a buffer containing the CREATE INDEX statements 6663 ** for all indexes that were tested (for all SQL statements). The iStmt 6664 ** parameter is ignored for EXPERT_REPORT_CANDIDATES calls. 6665 */ 6666 const char *sqlite3_expert_report(sqlite3expert*, int iStmt, int eReport); 6667 6668 /* 6669 ** Values for the third argument passed to sqlite3_expert_report(). 6670 */ 6671 #define EXPERT_REPORT_SQL 1 6672 #define EXPERT_REPORT_INDEXES 2 6673 #define EXPERT_REPORT_PLAN 3 6674 #define EXPERT_REPORT_CANDIDATES 4 6675 6676 /* 6677 ** Free an (sqlite3expert*) handle and all associated resources. There 6678 ** should be one call to this function for each successful call to 6679 ** sqlite3-expert_new(). 6680 */ 6681 void sqlite3_expert_destroy(sqlite3expert*); 6682 6683 6684 6685 /************************* End ../ext/expert/sqlite3expert.h ********************/ 6686 /************************* Begin ../ext/expert/sqlite3expert.c ******************/ 6687 /* 6688 ** 2017 April 09 6689 ** 6690 ** The author disclaims copyright to this source code. In place of 6691 ** a legal notice, here is a blessing: 6692 ** 6693 ** May you do good and not evil. 6694 ** May you find forgiveness for yourself and forgive others. 6695 ** May you share freely, never taking more than you give. 6696 ** 6697 ************************************************************************* 6698 */ 6699 /* #include "sqlite3expert.h" */ 6700 #include <assert.h> 6701 #include <string.h> 6702 #include <stdio.h> 6703 6704 #ifndef SQLITE_OMIT_VIRTUALTABLE 6705 6706 /* typedef sqlite3_int64 i64; */ 6707 /* typedef sqlite3_uint64 u64; */ 6708 6709 typedef struct IdxColumn IdxColumn; 6710 typedef struct IdxConstraint IdxConstraint; 6711 typedef struct IdxScan IdxScan; 6712 typedef struct IdxStatement IdxStatement; 6713 typedef struct IdxTable IdxTable; 6714 typedef struct IdxWrite IdxWrite; 6715 6716 #define STRLEN (int)strlen 6717 6718 /* 6719 ** A temp table name that we assume no user database will actually use. 6720 ** If this assumption proves incorrect triggers on the table with the 6721 ** conflicting name will be ignored. 6722 */ 6723 #define UNIQUE_TABLE_NAME "t592690916721053953805701627921227776" 6724 6725 /* 6726 ** A single constraint. Equivalent to either "col = ?" or "col < ?" (or 6727 ** any other type of single-ended range constraint on a column). 6728 ** 6729 ** pLink: 6730 ** Used to temporarily link IdxConstraint objects into lists while 6731 ** creating candidate indexes. 6732 */ 6733 struct IdxConstraint { 6734 char *zColl; /* Collation sequence */ 6735 int bRange; /* True for range, false for eq */ 6736 int iCol; /* Constrained table column */ 6737 int bFlag; /* Used by idxFindCompatible() */ 6738 int bDesc; /* True if ORDER BY <expr> DESC */ 6739 IdxConstraint *pNext; /* Next constraint in pEq or pRange list */ 6740 IdxConstraint *pLink; /* See above */ 6741 }; 6742 6743 /* 6744 ** A single scan of a single table. 6745 */ 6746 struct IdxScan { 6747 IdxTable *pTab; /* Associated table object */ 6748 int iDb; /* Database containing table zTable */ 6749 i64 covering; /* Mask of columns required for cov. index */ 6750 IdxConstraint *pOrder; /* ORDER BY columns */ 6751 IdxConstraint *pEq; /* List of == constraints */ 6752 IdxConstraint *pRange; /* List of < constraints */ 6753 IdxScan *pNextScan; /* Next IdxScan object for same analysis */ 6754 }; 6755 6756 /* 6757 ** Information regarding a single database table. Extracted from 6758 ** "PRAGMA table_info" by function idxGetTableInfo(). 6759 */ 6760 struct IdxColumn { 6761 char *zName; 6762 char *zColl; 6763 int iPk; 6764 }; 6765 struct IdxTable { 6766 int nCol; 6767 char *zName; /* Table name */ 6768 IdxColumn *aCol; 6769 IdxTable *pNext; /* Next table in linked list of all tables */ 6770 }; 6771 6772 /* 6773 ** An object of the following type is created for each unique table/write-op 6774 ** seen. The objects are stored in a singly-linked list beginning at 6775 ** sqlite3expert.pWrite. 6776 */ 6777 struct IdxWrite { 6778 IdxTable *pTab; 6779 int eOp; /* SQLITE_UPDATE, DELETE or INSERT */ 6780 IdxWrite *pNext; 6781 }; 6782 6783 /* 6784 ** Each statement being analyzed is represented by an instance of this 6785 ** structure. 6786 */ 6787 struct IdxStatement { 6788 int iId; /* Statement number */ 6789 char *zSql; /* SQL statement */ 6790 char *zIdx; /* Indexes */ 6791 char *zEQP; /* Plan */ 6792 IdxStatement *pNext; 6793 }; 6794 6795 6796 /* 6797 ** A hash table for storing strings. With space for a payload string 6798 ** with each entry. Methods are: 6799 ** 6800 ** idxHashInit() 6801 ** idxHashClear() 6802 ** idxHashAdd() 6803 ** idxHashSearch() 6804 */ 6805 #define IDX_HASH_SIZE 1023 6806 typedef struct IdxHashEntry IdxHashEntry; 6807 typedef struct IdxHash IdxHash; 6808 struct IdxHashEntry { 6809 char *zKey; /* nul-terminated key */ 6810 char *zVal; /* nul-terminated value string */ 6811 char *zVal2; /* nul-terminated value string 2 */ 6812 IdxHashEntry *pHashNext; /* Next entry in same hash bucket */ 6813 IdxHashEntry *pNext; /* Next entry in hash */ 6814 }; 6815 struct IdxHash { 6816 IdxHashEntry *pFirst; 6817 IdxHashEntry *aHash[IDX_HASH_SIZE]; 6818 }; 6819 6820 /* 6821 ** sqlite3expert object. 6822 */ 6823 struct sqlite3expert { 6824 int iSample; /* Percentage of tables to sample for stat1 */ 6825 sqlite3 *db; /* User database */ 6826 sqlite3 *dbm; /* In-memory db for this analysis */ 6827 sqlite3 *dbv; /* Vtab schema for this analysis */ 6828 IdxTable *pTable; /* List of all IdxTable objects */ 6829 IdxScan *pScan; /* List of scan objects */ 6830 IdxWrite *pWrite; /* List of write objects */ 6831 IdxStatement *pStatement; /* List of IdxStatement objects */ 6832 int bRun; /* True once analysis has run */ 6833 char **pzErrmsg; 6834 int rc; /* Error code from whereinfo hook */ 6835 IdxHash hIdx; /* Hash containing all candidate indexes */ 6836 char *zCandidates; /* For EXPERT_REPORT_CANDIDATES */ 6837 }; 6838 6839 6840 /* 6841 ** Allocate and return nByte bytes of zeroed memory using sqlite3_malloc(). 6842 ** If the allocation fails, set *pRc to SQLITE_NOMEM and return NULL. 6843 */ 6844 static void *idxMalloc(int *pRc, int nByte){ 6845 void *pRet; 6846 assert( *pRc==SQLITE_OK ); 6847 assert( nByte>0 ); 6848 pRet = sqlite3_malloc(nByte); 6849 if( pRet ){ 6850 memset(pRet, 0, nByte); 6851 }else{ 6852 *pRc = SQLITE_NOMEM; 6853 } 6854 return pRet; 6855 } 6856 6857 /* 6858 ** Initialize an IdxHash hash table. 6859 */ 6860 static void idxHashInit(IdxHash *pHash){ 6861 memset(pHash, 0, sizeof(IdxHash)); 6862 } 6863 6864 /* 6865 ** Reset an IdxHash hash table. 6866 */ 6867 static void idxHashClear(IdxHash *pHash){ 6868 int i; 6869 for(i=0; i<IDX_HASH_SIZE; i++){ 6870 IdxHashEntry *pEntry; 6871 IdxHashEntry *pNext; 6872 for(pEntry=pHash->aHash[i]; pEntry; pEntry=pNext){ 6873 pNext = pEntry->pHashNext; 6874 sqlite3_free(pEntry->zVal2); 6875 sqlite3_free(pEntry); 6876 } 6877 } 6878 memset(pHash, 0, sizeof(IdxHash)); 6879 } 6880 6881 /* 6882 ** Return the index of the hash bucket that the string specified by the 6883 ** arguments to this function belongs. 6884 */ 6885 static int idxHashString(const char *z, int n){ 6886 unsigned int ret = 0; 6887 int i; 6888 for(i=0; i<n; i++){ 6889 ret += (ret<<3) + (unsigned char)(z[i]); 6890 } 6891 return (int)(ret % IDX_HASH_SIZE); 6892 } 6893 6894 /* 6895 ** If zKey is already present in the hash table, return non-zero and do 6896 ** nothing. Otherwise, add an entry with key zKey and payload string zVal to 6897 ** the hash table passed as the second argument. 6898 */ 6899 static int idxHashAdd( 6900 int *pRc, 6901 IdxHash *pHash, 6902 const char *zKey, 6903 const char *zVal 6904 ){ 6905 int nKey = STRLEN(zKey); 6906 int iHash = idxHashString(zKey, nKey); 6907 int nVal = (zVal ? STRLEN(zVal) : 0); 6908 IdxHashEntry *pEntry; 6909 assert( iHash>=0 ); 6910 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){ 6911 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){ 6912 return 1; 6913 } 6914 } 6915 pEntry = idxMalloc(pRc, sizeof(IdxHashEntry) + nKey+1 + nVal+1); 6916 if( pEntry ){ 6917 pEntry->zKey = (char*)&pEntry[1]; 6918 memcpy(pEntry->zKey, zKey, nKey); 6919 if( zVal ){ 6920 pEntry->zVal = &pEntry->zKey[nKey+1]; 6921 memcpy(pEntry->zVal, zVal, nVal); 6922 } 6923 pEntry->pHashNext = pHash->aHash[iHash]; 6924 pHash->aHash[iHash] = pEntry; 6925 6926 pEntry->pNext = pHash->pFirst; 6927 pHash->pFirst = pEntry; 6928 } 6929 return 0; 6930 } 6931 6932 /* 6933 ** If zKey/nKey is present in the hash table, return a pointer to the 6934 ** hash-entry object. 6935 */ 6936 static IdxHashEntry *idxHashFind(IdxHash *pHash, const char *zKey, int nKey){ 6937 int iHash; 6938 IdxHashEntry *pEntry; 6939 if( nKey<0 ) nKey = STRLEN(zKey); 6940 iHash = idxHashString(zKey, nKey); 6941 assert( iHash>=0 ); 6942 for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){ 6943 if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){ 6944 return pEntry; 6945 } 6946 } 6947 return 0; 6948 } 6949 6950 /* 6951 ** If the hash table contains an entry with a key equal to the string 6952 ** passed as the final two arguments to this function, return a pointer 6953 ** to the payload string. Otherwise, if zKey/nKey is not present in the 6954 ** hash table, return NULL. 6955 */ 6956 static const char *idxHashSearch(IdxHash *pHash, const char *zKey, int nKey){ 6957 IdxHashEntry *pEntry = idxHashFind(pHash, zKey, nKey); 6958 if( pEntry ) return pEntry->zVal; 6959 return 0; 6960 } 6961 6962 /* 6963 ** Allocate and return a new IdxConstraint object. Set the IdxConstraint.zColl 6964 ** variable to point to a copy of nul-terminated string zColl. 6965 */ 6966 static IdxConstraint *idxNewConstraint(int *pRc, const char *zColl){ 6967 IdxConstraint *pNew; 6968 int nColl = STRLEN(zColl); 6969 6970 assert( *pRc==SQLITE_OK ); 6971 pNew = (IdxConstraint*)idxMalloc(pRc, sizeof(IdxConstraint) * nColl + 1); 6972 if( pNew ){ 6973 pNew->zColl = (char*)&pNew[1]; 6974 memcpy(pNew->zColl, zColl, nColl+1); 6975 } 6976 return pNew; 6977 } 6978 6979 /* 6980 ** An error associated with database handle db has just occurred. Pass 6981 ** the error message to callback function xOut. 6982 */ 6983 static void idxDatabaseError( 6984 sqlite3 *db, /* Database handle */ 6985 char **pzErrmsg /* Write error here */ 6986 ){ 6987 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); 6988 } 6989 6990 /* 6991 ** Prepare an SQL statement. 6992 */ 6993 static int idxPrepareStmt( 6994 sqlite3 *db, /* Database handle to compile against */ 6995 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */ 6996 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */ 6997 const char *zSql /* SQL statement to compile */ 6998 ){ 6999 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); 7000 if( rc!=SQLITE_OK ){ 7001 *ppStmt = 0; 7002 idxDatabaseError(db, pzErrmsg); 7003 } 7004 return rc; 7005 } 7006 7007 /* 7008 ** Prepare an SQL statement using the results of a printf() formatting. 7009 */ 7010 static int idxPrintfPrepareStmt( 7011 sqlite3 *db, /* Database handle to compile against */ 7012 sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */ 7013 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */ 7014 const char *zFmt, /* printf() format of SQL statement */ 7015 ... /* Trailing printf() arguments */ 7016 ){ 7017 va_list ap; 7018 int rc; 7019 char *zSql; 7020 va_start(ap, zFmt); 7021 zSql = sqlite3_vmprintf(zFmt, ap); 7022 if( zSql==0 ){ 7023 rc = SQLITE_NOMEM; 7024 }else{ 7025 rc = idxPrepareStmt(db, ppStmt, pzErrmsg, zSql); 7026 sqlite3_free(zSql); 7027 } 7028 va_end(ap); 7029 return rc; 7030 } 7031 7032 7033 /************************************************************************* 7034 ** Beginning of virtual table implementation. 7035 */ 7036 typedef struct ExpertVtab ExpertVtab; 7037 struct ExpertVtab { 7038 sqlite3_vtab base; 7039 IdxTable *pTab; 7040 sqlite3expert *pExpert; 7041 }; 7042 7043 typedef struct ExpertCsr ExpertCsr; 7044 struct ExpertCsr { 7045 sqlite3_vtab_cursor base; 7046 sqlite3_stmt *pData; 7047 }; 7048 7049 static char *expertDequote(const char *zIn){ 7050 int n = STRLEN(zIn); 7051 char *zRet = sqlite3_malloc(n); 7052 7053 assert( zIn[0]=='\'' ); 7054 assert( zIn[n-1]=='\'' ); 7055 7056 if( zRet ){ 7057 int iOut = 0; 7058 int iIn = 0; 7059 for(iIn=1; iIn<(n-1); iIn++){ 7060 if( zIn[iIn]=='\'' ){ 7061 assert( zIn[iIn+1]=='\'' ); 7062 iIn++; 7063 } 7064 zRet[iOut++] = zIn[iIn]; 7065 } 7066 zRet[iOut] = '\0'; 7067 } 7068 7069 return zRet; 7070 } 7071 7072 /* 7073 ** This function is the implementation of both the xConnect and xCreate 7074 ** methods of the r-tree virtual table. 7075 ** 7076 ** argv[0] -> module name 7077 ** argv[1] -> database name 7078 ** argv[2] -> table name 7079 ** argv[...] -> column names... 7080 */ 7081 static int expertConnect( 7082 sqlite3 *db, 7083 void *pAux, 7084 int argc, const char *const*argv, 7085 sqlite3_vtab **ppVtab, 7086 char **pzErr 7087 ){ 7088 sqlite3expert *pExpert = (sqlite3expert*)pAux; 7089 ExpertVtab *p = 0; 7090 int rc; 7091 7092 if( argc!=4 ){ 7093 *pzErr = sqlite3_mprintf("internal error!"); 7094 rc = SQLITE_ERROR; 7095 }else{ 7096 char *zCreateTable = expertDequote(argv[3]); 7097 if( zCreateTable ){ 7098 rc = sqlite3_declare_vtab(db, zCreateTable); 7099 if( rc==SQLITE_OK ){ 7100 p = idxMalloc(&rc, sizeof(ExpertVtab)); 7101 } 7102 if( rc==SQLITE_OK ){ 7103 p->pExpert = pExpert; 7104 p->pTab = pExpert->pTable; 7105 assert( sqlite3_stricmp(p->pTab->zName, argv[2])==0 ); 7106 } 7107 sqlite3_free(zCreateTable); 7108 }else{ 7109 rc = SQLITE_NOMEM; 7110 } 7111 } 7112 7113 *ppVtab = (sqlite3_vtab*)p; 7114 return rc; 7115 } 7116 7117 static int expertDisconnect(sqlite3_vtab *pVtab){ 7118 ExpertVtab *p = (ExpertVtab*)pVtab; 7119 sqlite3_free(p); 7120 return SQLITE_OK; 7121 } 7122 7123 static int expertBestIndex(sqlite3_vtab *pVtab, sqlite3_index_info *pIdxInfo){ 7124 ExpertVtab *p = (ExpertVtab*)pVtab; 7125 int rc = SQLITE_OK; 7126 int n = 0; 7127 IdxScan *pScan; 7128 const int opmask = 7129 SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_GT | 7130 SQLITE_INDEX_CONSTRAINT_LT | SQLITE_INDEX_CONSTRAINT_GE | 7131 SQLITE_INDEX_CONSTRAINT_LE; 7132 7133 pScan = idxMalloc(&rc, sizeof(IdxScan)); 7134 if( pScan ){ 7135 int i; 7136 7137 /* Link the new scan object into the list */ 7138 pScan->pTab = p->pTab; 7139 pScan->pNextScan = p->pExpert->pScan; 7140 p->pExpert->pScan = pScan; 7141 7142 /* Add the constraints to the IdxScan object */ 7143 for(i=0; i<pIdxInfo->nConstraint; i++){ 7144 struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i]; 7145 if( pCons->usable 7146 && pCons->iColumn>=0 7147 && p->pTab->aCol[pCons->iColumn].iPk==0 7148 && (pCons->op & opmask) 7149 ){ 7150 IdxConstraint *pNew; 7151 const char *zColl = sqlite3_vtab_collation(pIdxInfo, i); 7152 pNew = idxNewConstraint(&rc, zColl); 7153 if( pNew ){ 7154 pNew->iCol = pCons->iColumn; 7155 if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 7156 pNew->pNext = pScan->pEq; 7157 pScan->pEq = pNew; 7158 }else{ 7159 pNew->bRange = 1; 7160 pNew->pNext = pScan->pRange; 7161 pScan->pRange = pNew; 7162 } 7163 } 7164 n++; 7165 pIdxInfo->aConstraintUsage[i].argvIndex = n; 7166 } 7167 } 7168 7169 /* Add the ORDER BY to the IdxScan object */ 7170 for(i=pIdxInfo->nOrderBy-1; i>=0; i--){ 7171 int iCol = pIdxInfo->aOrderBy[i].iColumn; 7172 if( iCol>=0 ){ 7173 IdxConstraint *pNew = idxNewConstraint(&rc, p->pTab->aCol[iCol].zColl); 7174 if( pNew ){ 7175 pNew->iCol = iCol; 7176 pNew->bDesc = pIdxInfo->aOrderBy[i].desc; 7177 pNew->pNext = pScan->pOrder; 7178 pNew->pLink = pScan->pOrder; 7179 pScan->pOrder = pNew; 7180 n++; 7181 } 7182 } 7183 } 7184 } 7185 7186 pIdxInfo->estimatedCost = 1000000.0 / (n+1); 7187 return rc; 7188 } 7189 7190 static int expertUpdate( 7191 sqlite3_vtab *pVtab, 7192 int nData, 7193 sqlite3_value **azData, 7194 sqlite_int64 *pRowid 7195 ){ 7196 (void)pVtab; 7197 (void)nData; 7198 (void)azData; 7199 (void)pRowid; 7200 return SQLITE_OK; 7201 } 7202 7203 /* 7204 ** Virtual table module xOpen method. 7205 */ 7206 static int expertOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ 7207 int rc = SQLITE_OK; 7208 ExpertCsr *pCsr; 7209 (void)pVTab; 7210 pCsr = idxMalloc(&rc, sizeof(ExpertCsr)); 7211 *ppCursor = (sqlite3_vtab_cursor*)pCsr; 7212 return rc; 7213 } 7214 7215 /* 7216 ** Virtual table module xClose method. 7217 */ 7218 static int expertClose(sqlite3_vtab_cursor *cur){ 7219 ExpertCsr *pCsr = (ExpertCsr*)cur; 7220 sqlite3_finalize(pCsr->pData); 7221 sqlite3_free(pCsr); 7222 return SQLITE_OK; 7223 } 7224 7225 /* 7226 ** Virtual table module xEof method. 7227 ** 7228 ** Return non-zero if the cursor does not currently point to a valid 7229 ** record (i.e if the scan has finished), or zero otherwise. 7230 */ 7231 static int expertEof(sqlite3_vtab_cursor *cur){ 7232 ExpertCsr *pCsr = (ExpertCsr*)cur; 7233 return pCsr->pData==0; 7234 } 7235 7236 /* 7237 ** Virtual table module xNext method. 7238 */ 7239 static int expertNext(sqlite3_vtab_cursor *cur){ 7240 ExpertCsr *pCsr = (ExpertCsr*)cur; 7241 int rc = SQLITE_OK; 7242 7243 assert( pCsr->pData ); 7244 rc = sqlite3_step(pCsr->pData); 7245 if( rc!=SQLITE_ROW ){ 7246 rc = sqlite3_finalize(pCsr->pData); 7247 pCsr->pData = 0; 7248 }else{ 7249 rc = SQLITE_OK; 7250 } 7251 7252 return rc; 7253 } 7254 7255 /* 7256 ** Virtual table module xRowid method. 7257 */ 7258 static int expertRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 7259 (void)cur; 7260 *pRowid = 0; 7261 return SQLITE_OK; 7262 } 7263 7264 /* 7265 ** Virtual table module xColumn method. 7266 */ 7267 static int expertColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ 7268 ExpertCsr *pCsr = (ExpertCsr*)cur; 7269 sqlite3_value *pVal; 7270 pVal = sqlite3_column_value(pCsr->pData, i); 7271 if( pVal ){ 7272 sqlite3_result_value(ctx, pVal); 7273 } 7274 return SQLITE_OK; 7275 } 7276 7277 /* 7278 ** Virtual table module xFilter method. 7279 */ 7280 static int expertFilter( 7281 sqlite3_vtab_cursor *cur, 7282 int idxNum, const char *idxStr, 7283 int argc, sqlite3_value **argv 7284 ){ 7285 ExpertCsr *pCsr = (ExpertCsr*)cur; 7286 ExpertVtab *pVtab = (ExpertVtab*)(cur->pVtab); 7287 sqlite3expert *pExpert = pVtab->pExpert; 7288 int rc; 7289 7290 (void)idxNum; 7291 (void)idxStr; 7292 (void)argc; 7293 (void)argv; 7294 rc = sqlite3_finalize(pCsr->pData); 7295 pCsr->pData = 0; 7296 if( rc==SQLITE_OK ){ 7297 rc = idxPrintfPrepareStmt(pExpert->db, &pCsr->pData, &pVtab->base.zErrMsg, 7298 "SELECT * FROM main.%Q WHERE sample()", pVtab->pTab->zName 7299 ); 7300 } 7301 7302 if( rc==SQLITE_OK ){ 7303 rc = expertNext(cur); 7304 } 7305 return rc; 7306 } 7307 7308 static int idxRegisterVtab(sqlite3expert *p){ 7309 static sqlite3_module expertModule = { 7310 2, /* iVersion */ 7311 expertConnect, /* xCreate - create a table */ 7312 expertConnect, /* xConnect - connect to an existing table */ 7313 expertBestIndex, /* xBestIndex - Determine search strategy */ 7314 expertDisconnect, /* xDisconnect - Disconnect from a table */ 7315 expertDisconnect, /* xDestroy - Drop a table */ 7316 expertOpen, /* xOpen - open a cursor */ 7317 expertClose, /* xClose - close a cursor */ 7318 expertFilter, /* xFilter - configure scan constraints */ 7319 expertNext, /* xNext - advance a cursor */ 7320 expertEof, /* xEof */ 7321 expertColumn, /* xColumn - read data */ 7322 expertRowid, /* xRowid - read data */ 7323 expertUpdate, /* xUpdate - write data */ 7324 0, /* xBegin - begin transaction */ 7325 0, /* xSync - sync transaction */ 7326 0, /* xCommit - commit transaction */ 7327 0, /* xRollback - rollback transaction */ 7328 0, /* xFindFunction - function overloading */ 7329 0, /* xRename - rename the table */ 7330 0, /* xSavepoint */ 7331 0, /* xRelease */ 7332 0, /* xRollbackTo */ 7333 0, /* xShadowName */ 7334 }; 7335 7336 return sqlite3_create_module(p->dbv, "expert", &expertModule, (void*)p); 7337 } 7338 /* 7339 ** End of virtual table implementation. 7340 *************************************************************************/ 7341 /* 7342 ** Finalize SQL statement pStmt. If (*pRc) is SQLITE_OK when this function 7343 ** is called, set it to the return value of sqlite3_finalize() before 7344 ** returning. Otherwise, discard the sqlite3_finalize() return value. 7345 */ 7346 static void idxFinalize(int *pRc, sqlite3_stmt *pStmt){ 7347 int rc = sqlite3_finalize(pStmt); 7348 if( *pRc==SQLITE_OK ) *pRc = rc; 7349 } 7350 7351 /* 7352 ** Attempt to allocate an IdxTable structure corresponding to table zTab 7353 ** in the main database of connection db. If successful, set (*ppOut) to 7354 ** point to the new object and return SQLITE_OK. Otherwise, return an 7355 ** SQLite error code and set (*ppOut) to NULL. In this case *pzErrmsg may be 7356 ** set to point to an error string. 7357 ** 7358 ** It is the responsibility of the caller to eventually free either the 7359 ** IdxTable object or error message using sqlite3_free(). 7360 */ 7361 static int idxGetTableInfo( 7362 sqlite3 *db, /* Database connection to read details from */ 7363 const char *zTab, /* Table name */ 7364 IdxTable **ppOut, /* OUT: New object (if successful) */ 7365 char **pzErrmsg /* OUT: Error message (if not) */ 7366 ){ 7367 sqlite3_stmt *p1 = 0; 7368 int nCol = 0; 7369 int nTab = STRLEN(zTab); 7370 int nByte = sizeof(IdxTable) + nTab + 1; 7371 IdxTable *pNew = 0; 7372 int rc, rc2; 7373 char *pCsr = 0; 7374 7375 rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_info=%Q", zTab); 7376 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){ 7377 const char *zCol = (const char*)sqlite3_column_text(p1, 1); 7378 nByte += 1 + STRLEN(zCol); 7379 rc = sqlite3_table_column_metadata( 7380 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0 7381 ); 7382 nByte += 1 + STRLEN(zCol); 7383 nCol++; 7384 } 7385 rc2 = sqlite3_reset(p1); 7386 if( rc==SQLITE_OK ) rc = rc2; 7387 7388 nByte += sizeof(IdxColumn) * nCol; 7389 if( rc==SQLITE_OK ){ 7390 pNew = idxMalloc(&rc, nByte); 7391 } 7392 if( rc==SQLITE_OK ){ 7393 pNew->aCol = (IdxColumn*)&pNew[1]; 7394 pNew->nCol = nCol; 7395 pCsr = (char*)&pNew->aCol[nCol]; 7396 } 7397 7398 nCol = 0; 7399 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){ 7400 const char *zCol = (const char*)sqlite3_column_text(p1, 1); 7401 int nCopy = STRLEN(zCol) + 1; 7402 pNew->aCol[nCol].zName = pCsr; 7403 pNew->aCol[nCol].iPk = sqlite3_column_int(p1, 5); 7404 memcpy(pCsr, zCol, nCopy); 7405 pCsr += nCopy; 7406 7407 rc = sqlite3_table_column_metadata( 7408 db, "main", zTab, zCol, 0, &zCol, 0, 0, 0 7409 ); 7410 if( rc==SQLITE_OK ){ 7411 nCopy = STRLEN(zCol) + 1; 7412 pNew->aCol[nCol].zColl = pCsr; 7413 memcpy(pCsr, zCol, nCopy); 7414 pCsr += nCopy; 7415 } 7416 7417 nCol++; 7418 } 7419 idxFinalize(&rc, p1); 7420 7421 if( rc!=SQLITE_OK ){ 7422 sqlite3_free(pNew); 7423 pNew = 0; 7424 }else{ 7425 pNew->zName = pCsr; 7426 memcpy(pNew->zName, zTab, nTab+1); 7427 } 7428 7429 *ppOut = pNew; 7430 return rc; 7431 } 7432 7433 /* 7434 ** This function is a no-op if *pRc is set to anything other than 7435 ** SQLITE_OK when it is called. 7436 ** 7437 ** If *pRc is initially set to SQLITE_OK, then the text specified by 7438 ** the printf() style arguments is appended to zIn and the result returned 7439 ** in a buffer allocated by sqlite3_malloc(). sqlite3_free() is called on 7440 ** zIn before returning. 7441 */ 7442 static char *idxAppendText(int *pRc, char *zIn, const char *zFmt, ...){ 7443 va_list ap; 7444 char *zAppend = 0; 7445 char *zRet = 0; 7446 int nIn = zIn ? STRLEN(zIn) : 0; 7447 int nAppend = 0; 7448 va_start(ap, zFmt); 7449 if( *pRc==SQLITE_OK ){ 7450 zAppend = sqlite3_vmprintf(zFmt, ap); 7451 if( zAppend ){ 7452 nAppend = STRLEN(zAppend); 7453 zRet = (char*)sqlite3_malloc(nIn + nAppend + 1); 7454 } 7455 if( zAppend && zRet ){ 7456 if( nIn ) memcpy(zRet, zIn, nIn); 7457 memcpy(&zRet[nIn], zAppend, nAppend+1); 7458 }else{ 7459 sqlite3_free(zRet); 7460 zRet = 0; 7461 *pRc = SQLITE_NOMEM; 7462 } 7463 sqlite3_free(zAppend); 7464 sqlite3_free(zIn); 7465 } 7466 va_end(ap); 7467 return zRet; 7468 } 7469 7470 /* 7471 ** Return true if zId must be quoted in order to use it as an SQL 7472 ** identifier, or false otherwise. 7473 */ 7474 static int idxIdentifierRequiresQuotes(const char *zId){ 7475 int i; 7476 for(i=0; zId[i]; i++){ 7477 if( !(zId[i]=='_') 7478 && !(zId[i]>='0' && zId[i]<='9') 7479 && !(zId[i]>='a' && zId[i]<='z') 7480 && !(zId[i]>='A' && zId[i]<='Z') 7481 ){ 7482 return 1; 7483 } 7484 } 7485 return 0; 7486 } 7487 7488 /* 7489 ** This function appends an index column definition suitable for constraint 7490 ** pCons to the string passed as zIn and returns the result. 7491 */ 7492 static char *idxAppendColDefn( 7493 int *pRc, /* IN/OUT: Error code */ 7494 char *zIn, /* Column defn accumulated so far */ 7495 IdxTable *pTab, /* Table index will be created on */ 7496 IdxConstraint *pCons 7497 ){ 7498 char *zRet = zIn; 7499 IdxColumn *p = &pTab->aCol[pCons->iCol]; 7500 if( zRet ) zRet = idxAppendText(pRc, zRet, ", "); 7501 7502 if( idxIdentifierRequiresQuotes(p->zName) ){ 7503 zRet = idxAppendText(pRc, zRet, "%Q", p->zName); 7504 }else{ 7505 zRet = idxAppendText(pRc, zRet, "%s", p->zName); 7506 } 7507 7508 if( sqlite3_stricmp(p->zColl, pCons->zColl) ){ 7509 if( idxIdentifierRequiresQuotes(pCons->zColl) ){ 7510 zRet = idxAppendText(pRc, zRet, " COLLATE %Q", pCons->zColl); 7511 }else{ 7512 zRet = idxAppendText(pRc, zRet, " COLLATE %s", pCons->zColl); 7513 } 7514 } 7515 7516 if( pCons->bDesc ){ 7517 zRet = idxAppendText(pRc, zRet, " DESC"); 7518 } 7519 return zRet; 7520 } 7521 7522 /* 7523 ** Search database dbm for an index compatible with the one idxCreateFromCons() 7524 ** would create from arguments pScan, pEq and pTail. If no error occurs and 7525 ** such an index is found, return non-zero. Or, if no such index is found, 7526 ** return zero. 7527 ** 7528 ** If an error occurs, set *pRc to an SQLite error code and return zero. 7529 */ 7530 static int idxFindCompatible( 7531 int *pRc, /* OUT: Error code */ 7532 sqlite3* dbm, /* Database to search */ 7533 IdxScan *pScan, /* Scan for table to search for index on */ 7534 IdxConstraint *pEq, /* List of == constraints */ 7535 IdxConstraint *pTail /* List of range constraints */ 7536 ){ 7537 const char *zTbl = pScan->pTab->zName; 7538 sqlite3_stmt *pIdxList = 0; 7539 IdxConstraint *pIter; 7540 int nEq = 0; /* Number of elements in pEq */ 7541 int rc; 7542 7543 /* Count the elements in list pEq */ 7544 for(pIter=pEq; pIter; pIter=pIter->pLink) nEq++; 7545 7546 rc = idxPrintfPrepareStmt(dbm, &pIdxList, 0, "PRAGMA index_list=%Q", zTbl); 7547 while( rc==SQLITE_OK && sqlite3_step(pIdxList)==SQLITE_ROW ){ 7548 int bMatch = 1; 7549 IdxConstraint *pT = pTail; 7550 sqlite3_stmt *pInfo = 0; 7551 const char *zIdx = (const char*)sqlite3_column_text(pIdxList, 1); 7552 7553 /* Zero the IdxConstraint.bFlag values in the pEq list */ 7554 for(pIter=pEq; pIter; pIter=pIter->pLink) pIter->bFlag = 0; 7555 7556 rc = idxPrintfPrepareStmt(dbm, &pInfo, 0, "PRAGMA index_xInfo=%Q", zIdx); 7557 while( rc==SQLITE_OK && sqlite3_step(pInfo)==SQLITE_ROW ){ 7558 int iIdx = sqlite3_column_int(pInfo, 0); 7559 int iCol = sqlite3_column_int(pInfo, 1); 7560 const char *zColl = (const char*)sqlite3_column_text(pInfo, 4); 7561 7562 if( iIdx<nEq ){ 7563 for(pIter=pEq; pIter; pIter=pIter->pLink){ 7564 if( pIter->bFlag ) continue; 7565 if( pIter->iCol!=iCol ) continue; 7566 if( sqlite3_stricmp(pIter->zColl, zColl) ) continue; 7567 pIter->bFlag = 1; 7568 break; 7569 } 7570 if( pIter==0 ){ 7571 bMatch = 0; 7572 break; 7573 } 7574 }else{ 7575 if( pT ){ 7576 if( pT->iCol!=iCol || sqlite3_stricmp(pT->zColl, zColl) ){ 7577 bMatch = 0; 7578 break; 7579 } 7580 pT = pT->pLink; 7581 } 7582 } 7583 } 7584 idxFinalize(&rc, pInfo); 7585 7586 if( rc==SQLITE_OK && bMatch ){ 7587 sqlite3_finalize(pIdxList); 7588 return 1; 7589 } 7590 } 7591 idxFinalize(&rc, pIdxList); 7592 7593 *pRc = rc; 7594 return 0; 7595 } 7596 7597 static int idxCreateFromCons( 7598 sqlite3expert *p, 7599 IdxScan *pScan, 7600 IdxConstraint *pEq, 7601 IdxConstraint *pTail 7602 ){ 7603 sqlite3 *dbm = p->dbm; 7604 int rc = SQLITE_OK; 7605 if( (pEq || pTail) && 0==idxFindCompatible(&rc, dbm, pScan, pEq, pTail) ){ 7606 IdxTable *pTab = pScan->pTab; 7607 char *zCols = 0; 7608 char *zIdx = 0; 7609 IdxConstraint *pCons; 7610 unsigned int h = 0; 7611 const char *zFmt; 7612 7613 for(pCons=pEq; pCons; pCons=pCons->pLink){ 7614 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons); 7615 } 7616 for(pCons=pTail; pCons; pCons=pCons->pLink){ 7617 zCols = idxAppendColDefn(&rc, zCols, pTab, pCons); 7618 } 7619 7620 if( rc==SQLITE_OK ){ 7621 /* Hash the list of columns to come up with a name for the index */ 7622 const char *zTable = pScan->pTab->zName; 7623 char *zName; /* Index name */ 7624 int i; 7625 for(i=0; zCols[i]; i++){ 7626 h += ((h<<3) + zCols[i]); 7627 } 7628 zName = sqlite3_mprintf("%s_idx_%08x", zTable, h); 7629 if( zName==0 ){ 7630 rc = SQLITE_NOMEM; 7631 }else{ 7632 if( idxIdentifierRequiresQuotes(zTable) ){ 7633 zFmt = "CREATE INDEX '%q' ON %Q(%s)"; 7634 }else{ 7635 zFmt = "CREATE INDEX %s ON %s(%s)"; 7636 } 7637 zIdx = sqlite3_mprintf(zFmt, zName, zTable, zCols); 7638 if( !zIdx ){ 7639 rc = SQLITE_NOMEM; 7640 }else{ 7641 rc = sqlite3_exec(dbm, zIdx, 0, 0, p->pzErrmsg); 7642 idxHashAdd(&rc, &p->hIdx, zName, zIdx); 7643 } 7644 sqlite3_free(zName); 7645 sqlite3_free(zIdx); 7646 } 7647 } 7648 7649 sqlite3_free(zCols); 7650 } 7651 return rc; 7652 } 7653 7654 /* 7655 ** Return true if list pList (linked by IdxConstraint.pLink) contains 7656 ** a constraint compatible with *p. Otherwise return false. 7657 */ 7658 static int idxFindConstraint(IdxConstraint *pList, IdxConstraint *p){ 7659 IdxConstraint *pCmp; 7660 for(pCmp=pList; pCmp; pCmp=pCmp->pLink){ 7661 if( p->iCol==pCmp->iCol ) return 1; 7662 } 7663 return 0; 7664 } 7665 7666 static int idxCreateFromWhere( 7667 sqlite3expert *p, 7668 IdxScan *pScan, /* Create indexes for this scan */ 7669 IdxConstraint *pTail /* range/ORDER BY constraints for inclusion */ 7670 ){ 7671 IdxConstraint *p1 = 0; 7672 IdxConstraint *pCon; 7673 int rc; 7674 7675 /* Gather up all the == constraints. */ 7676 for(pCon=pScan->pEq; pCon; pCon=pCon->pNext){ 7677 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){ 7678 pCon->pLink = p1; 7679 p1 = pCon; 7680 } 7681 } 7682 7683 /* Create an index using the == constraints collected above. And the 7684 ** range constraint/ORDER BY terms passed in by the caller, if any. */ 7685 rc = idxCreateFromCons(p, pScan, p1, pTail); 7686 7687 /* If no range/ORDER BY passed by the caller, create a version of the 7688 ** index for each range constraint. */ 7689 if( pTail==0 ){ 7690 for(pCon=pScan->pRange; rc==SQLITE_OK && pCon; pCon=pCon->pNext){ 7691 assert( pCon->pLink==0 ); 7692 if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){ 7693 rc = idxCreateFromCons(p, pScan, p1, pCon); 7694 } 7695 } 7696 } 7697 7698 return rc; 7699 } 7700 7701 /* 7702 ** Create candidate indexes in database [dbm] based on the data in 7703 ** linked-list pScan. 7704 */ 7705 static int idxCreateCandidates(sqlite3expert *p){ 7706 int rc = SQLITE_OK; 7707 IdxScan *pIter; 7708 7709 for(pIter=p->pScan; pIter && rc==SQLITE_OK; pIter=pIter->pNextScan){ 7710 rc = idxCreateFromWhere(p, pIter, 0); 7711 if( rc==SQLITE_OK && pIter->pOrder ){ 7712 rc = idxCreateFromWhere(p, pIter, pIter->pOrder); 7713 } 7714 } 7715 7716 return rc; 7717 } 7718 7719 /* 7720 ** Free all elements of the linked list starting at pConstraint. 7721 */ 7722 static void idxConstraintFree(IdxConstraint *pConstraint){ 7723 IdxConstraint *pNext; 7724 IdxConstraint *p; 7725 7726 for(p=pConstraint; p; p=pNext){ 7727 pNext = p->pNext; 7728 sqlite3_free(p); 7729 } 7730 } 7731 7732 /* 7733 ** Free all elements of the linked list starting from pScan up until pLast 7734 ** (pLast is not freed). 7735 */ 7736 static void idxScanFree(IdxScan *pScan, IdxScan *pLast){ 7737 IdxScan *p; 7738 IdxScan *pNext; 7739 for(p=pScan; p!=pLast; p=pNext){ 7740 pNext = p->pNextScan; 7741 idxConstraintFree(p->pOrder); 7742 idxConstraintFree(p->pEq); 7743 idxConstraintFree(p->pRange); 7744 sqlite3_free(p); 7745 } 7746 } 7747 7748 /* 7749 ** Free all elements of the linked list starting from pStatement up 7750 ** until pLast (pLast is not freed). 7751 */ 7752 static void idxStatementFree(IdxStatement *pStatement, IdxStatement *pLast){ 7753 IdxStatement *p; 7754 IdxStatement *pNext; 7755 for(p=pStatement; p!=pLast; p=pNext){ 7756 pNext = p->pNext; 7757 sqlite3_free(p->zEQP); 7758 sqlite3_free(p->zIdx); 7759 sqlite3_free(p); 7760 } 7761 } 7762 7763 /* 7764 ** Free the linked list of IdxTable objects starting at pTab. 7765 */ 7766 static void idxTableFree(IdxTable *pTab){ 7767 IdxTable *pIter; 7768 IdxTable *pNext; 7769 for(pIter=pTab; pIter; pIter=pNext){ 7770 pNext = pIter->pNext; 7771 sqlite3_free(pIter); 7772 } 7773 } 7774 7775 /* 7776 ** Free the linked list of IdxWrite objects starting at pTab. 7777 */ 7778 static void idxWriteFree(IdxWrite *pTab){ 7779 IdxWrite *pIter; 7780 IdxWrite *pNext; 7781 for(pIter=pTab; pIter; pIter=pNext){ 7782 pNext = pIter->pNext; 7783 sqlite3_free(pIter); 7784 } 7785 } 7786 7787 7788 7789 /* 7790 ** This function is called after candidate indexes have been created. It 7791 ** runs all the queries to see which indexes they prefer, and populates 7792 ** IdxStatement.zIdx and IdxStatement.zEQP with the results. 7793 */ 7794 int idxFindIndexes( 7795 sqlite3expert *p, 7796 char **pzErr /* OUT: Error message (sqlite3_malloc) */ 7797 ){ 7798 IdxStatement *pStmt; 7799 sqlite3 *dbm = p->dbm; 7800 int rc = SQLITE_OK; 7801 7802 IdxHash hIdx; 7803 idxHashInit(&hIdx); 7804 7805 for(pStmt=p->pStatement; rc==SQLITE_OK && pStmt; pStmt=pStmt->pNext){ 7806 IdxHashEntry *pEntry; 7807 sqlite3_stmt *pExplain = 0; 7808 idxHashClear(&hIdx); 7809 rc = idxPrintfPrepareStmt(dbm, &pExplain, pzErr, 7810 "EXPLAIN QUERY PLAN %s", pStmt->zSql 7811 ); 7812 while( rc==SQLITE_OK && sqlite3_step(pExplain)==SQLITE_ROW ){ 7813 /* int iId = sqlite3_column_int(pExplain, 0); */ 7814 /* int iParent = sqlite3_column_int(pExplain, 1); */ 7815 /* int iNotUsed = sqlite3_column_int(pExplain, 2); */ 7816 const char *zDetail = (const char*)sqlite3_column_text(pExplain, 3); 7817 int nDetail = STRLEN(zDetail); 7818 int i; 7819 7820 for(i=0; i<nDetail; i++){ 7821 const char *zIdx = 0; 7822 if( memcmp(&zDetail[i], " USING INDEX ", 13)==0 ){ 7823 zIdx = &zDetail[i+13]; 7824 }else if( memcmp(&zDetail[i], " USING COVERING INDEX ", 22)==0 ){ 7825 zIdx = &zDetail[i+22]; 7826 } 7827 if( zIdx ){ 7828 const char *zSql; 7829 int nIdx = 0; 7830 while( zIdx[nIdx]!='\0' && (zIdx[nIdx]!=' ' || zIdx[nIdx+1]!='(') ){ 7831 nIdx++; 7832 } 7833 zSql = idxHashSearch(&p->hIdx, zIdx, nIdx); 7834 if( zSql ){ 7835 idxHashAdd(&rc, &hIdx, zSql, 0); 7836 if( rc ) goto find_indexes_out; 7837 } 7838 break; 7839 } 7840 } 7841 7842 if( zDetail[0]!='-' ){ 7843 pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail); 7844 } 7845 } 7846 7847 for(pEntry=hIdx.pFirst; pEntry; pEntry=pEntry->pNext){ 7848 pStmt->zIdx = idxAppendText(&rc, pStmt->zIdx, "%s;\n", pEntry->zKey); 7849 } 7850 7851 idxFinalize(&rc, pExplain); 7852 } 7853 7854 find_indexes_out: 7855 idxHashClear(&hIdx); 7856 return rc; 7857 } 7858 7859 static int idxAuthCallback( 7860 void *pCtx, 7861 int eOp, 7862 const char *z3, 7863 const char *z4, 7864 const char *zDb, 7865 const char *zTrigger 7866 ){ 7867 int rc = SQLITE_OK; 7868 (void)z4; 7869 (void)zTrigger; 7870 if( eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE || eOp==SQLITE_DELETE ){ 7871 if( sqlite3_stricmp(zDb, "main")==0 ){ 7872 sqlite3expert *p = (sqlite3expert*)pCtx; 7873 IdxTable *pTab; 7874 for(pTab=p->pTable; pTab; pTab=pTab->pNext){ 7875 if( 0==sqlite3_stricmp(z3, pTab->zName) ) break; 7876 } 7877 if( pTab ){ 7878 IdxWrite *pWrite; 7879 for(pWrite=p->pWrite; pWrite; pWrite=pWrite->pNext){ 7880 if( pWrite->pTab==pTab && pWrite->eOp==eOp ) break; 7881 } 7882 if( pWrite==0 ){ 7883 pWrite = idxMalloc(&rc, sizeof(IdxWrite)); 7884 if( rc==SQLITE_OK ){ 7885 pWrite->pTab = pTab; 7886 pWrite->eOp = eOp; 7887 pWrite->pNext = p->pWrite; 7888 p->pWrite = pWrite; 7889 } 7890 } 7891 } 7892 } 7893 } 7894 return rc; 7895 } 7896 7897 static int idxProcessOneTrigger( 7898 sqlite3expert *p, 7899 IdxWrite *pWrite, 7900 char **pzErr 7901 ){ 7902 static const char *zInt = UNIQUE_TABLE_NAME; 7903 static const char *zDrop = "DROP TABLE " UNIQUE_TABLE_NAME; 7904 IdxTable *pTab = pWrite->pTab; 7905 const char *zTab = pTab->zName; 7906 const char *zSql = 7907 "SELECT 'CREATE TEMP' || substr(sql, 7) FROM sqlite_master " 7908 "WHERE tbl_name = %Q AND type IN ('table', 'trigger') " 7909 "ORDER BY type;"; 7910 sqlite3_stmt *pSelect = 0; 7911 int rc = SQLITE_OK; 7912 char *zWrite = 0; 7913 7914 /* Create the table and its triggers in the temp schema */ 7915 rc = idxPrintfPrepareStmt(p->db, &pSelect, pzErr, zSql, zTab, zTab); 7916 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSelect) ){ 7917 const char *zCreate = (const char*)sqlite3_column_text(pSelect, 0); 7918 rc = sqlite3_exec(p->dbv, zCreate, 0, 0, pzErr); 7919 } 7920 idxFinalize(&rc, pSelect); 7921 7922 /* Rename the table in the temp schema to zInt */ 7923 if( rc==SQLITE_OK ){ 7924 char *z = sqlite3_mprintf("ALTER TABLE temp.%Q RENAME TO %Q", zTab, zInt); 7925 if( z==0 ){ 7926 rc = SQLITE_NOMEM; 7927 }else{ 7928 rc = sqlite3_exec(p->dbv, z, 0, 0, pzErr); 7929 sqlite3_free(z); 7930 } 7931 } 7932 7933 switch( pWrite->eOp ){ 7934 case SQLITE_INSERT: { 7935 int i; 7936 zWrite = idxAppendText(&rc, zWrite, "INSERT INTO %Q VALUES(", zInt); 7937 for(i=0; i<pTab->nCol; i++){ 7938 zWrite = idxAppendText(&rc, zWrite, "%s?", i==0 ? "" : ", "); 7939 } 7940 zWrite = idxAppendText(&rc, zWrite, ")"); 7941 break; 7942 } 7943 case SQLITE_UPDATE: { 7944 int i; 7945 zWrite = idxAppendText(&rc, zWrite, "UPDATE %Q SET ", zInt); 7946 for(i=0; i<pTab->nCol; i++){ 7947 zWrite = idxAppendText(&rc, zWrite, "%s%Q=?", i==0 ? "" : ", ", 7948 pTab->aCol[i].zName 7949 ); 7950 } 7951 break; 7952 } 7953 default: { 7954 assert( pWrite->eOp==SQLITE_DELETE ); 7955 if( rc==SQLITE_OK ){ 7956 zWrite = sqlite3_mprintf("DELETE FROM %Q", zInt); 7957 if( zWrite==0 ) rc = SQLITE_NOMEM; 7958 } 7959 } 7960 } 7961 7962 if( rc==SQLITE_OK ){ 7963 sqlite3_stmt *pX = 0; 7964 rc = sqlite3_prepare_v2(p->dbv, zWrite, -1, &pX, 0); 7965 idxFinalize(&rc, pX); 7966 if( rc!=SQLITE_OK ){ 7967 idxDatabaseError(p->dbv, pzErr); 7968 } 7969 } 7970 sqlite3_free(zWrite); 7971 7972 if( rc==SQLITE_OK ){ 7973 rc = sqlite3_exec(p->dbv, zDrop, 0, 0, pzErr); 7974 } 7975 7976 return rc; 7977 } 7978 7979 static int idxProcessTriggers(sqlite3expert *p, char **pzErr){ 7980 int rc = SQLITE_OK; 7981 IdxWrite *pEnd = 0; 7982 IdxWrite *pFirst = p->pWrite; 7983 7984 while( rc==SQLITE_OK && pFirst!=pEnd ){ 7985 IdxWrite *pIter; 7986 for(pIter=pFirst; rc==SQLITE_OK && pIter!=pEnd; pIter=pIter->pNext){ 7987 rc = idxProcessOneTrigger(p, pIter, pzErr); 7988 } 7989 pEnd = pFirst; 7990 pFirst = p->pWrite; 7991 } 7992 7993 return rc; 7994 } 7995 7996 7997 static int idxCreateVtabSchema(sqlite3expert *p, char **pzErrmsg){ 7998 int rc = idxRegisterVtab(p); 7999 sqlite3_stmt *pSchema = 0; 8000 8001 /* For each table in the main db schema: 8002 ** 8003 ** 1) Add an entry to the p->pTable list, and 8004 ** 2) Create the equivalent virtual table in dbv. 8005 */ 8006 rc = idxPrepareStmt(p->db, &pSchema, pzErrmsg, 8007 "SELECT type, name, sql, 1 FROM sqlite_master " 8008 "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%%' " 8009 " UNION ALL " 8010 "SELECT type, name, sql, 2 FROM sqlite_master " 8011 "WHERE type = 'trigger'" 8012 " AND tbl_name IN(SELECT name FROM sqlite_master WHERE type = 'view') " 8013 "ORDER BY 4, 1" 8014 ); 8015 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSchema) ){ 8016 const char *zType = (const char*)sqlite3_column_text(pSchema, 0); 8017 const char *zName = (const char*)sqlite3_column_text(pSchema, 1); 8018 const char *zSql = (const char*)sqlite3_column_text(pSchema, 2); 8019 8020 if( zType[0]=='v' || zType[1]=='r' ){ 8021 rc = sqlite3_exec(p->dbv, zSql, 0, 0, pzErrmsg); 8022 }else{ 8023 IdxTable *pTab; 8024 rc = idxGetTableInfo(p->db, zName, &pTab, pzErrmsg); 8025 if( rc==SQLITE_OK ){ 8026 int i; 8027 char *zInner = 0; 8028 char *zOuter = 0; 8029 pTab->pNext = p->pTable; 8030 p->pTable = pTab; 8031 8032 /* The statement the vtab will pass to sqlite3_declare_vtab() */ 8033 zInner = idxAppendText(&rc, 0, "CREATE TABLE x("); 8034 for(i=0; i<pTab->nCol; i++){ 8035 zInner = idxAppendText(&rc, zInner, "%s%Q COLLATE %s", 8036 (i==0 ? "" : ", "), pTab->aCol[i].zName, pTab->aCol[i].zColl 8037 ); 8038 } 8039 zInner = idxAppendText(&rc, zInner, ")"); 8040 8041 /* The CVT statement to create the vtab */ 8042 zOuter = idxAppendText(&rc, 0, 8043 "CREATE VIRTUAL TABLE %Q USING expert(%Q)", zName, zInner 8044 ); 8045 if( rc==SQLITE_OK ){ 8046 rc = sqlite3_exec(p->dbv, zOuter, 0, 0, pzErrmsg); 8047 } 8048 sqlite3_free(zInner); 8049 sqlite3_free(zOuter); 8050 } 8051 } 8052 } 8053 idxFinalize(&rc, pSchema); 8054 return rc; 8055 } 8056 8057 struct IdxSampleCtx { 8058 int iTarget; 8059 double target; /* Target nRet/nRow value */ 8060 double nRow; /* Number of rows seen */ 8061 double nRet; /* Number of rows returned */ 8062 }; 8063 8064 static void idxSampleFunc( 8065 sqlite3_context *pCtx, 8066 int argc, 8067 sqlite3_value **argv 8068 ){ 8069 struct IdxSampleCtx *p = (struct IdxSampleCtx*)sqlite3_user_data(pCtx); 8070 int bRet; 8071 8072 (void)argv; 8073 assert( argc==0 ); 8074 if( p->nRow==0.0 ){ 8075 bRet = 1; 8076 }else{ 8077 bRet = (p->nRet / p->nRow) <= p->target; 8078 if( bRet==0 ){ 8079 unsigned short rnd; 8080 sqlite3_randomness(2, (void*)&rnd); 8081 bRet = ((int)rnd % 100) <= p->iTarget; 8082 } 8083 } 8084 8085 sqlite3_result_int(pCtx, bRet); 8086 p->nRow += 1.0; 8087 p->nRet += (double)bRet; 8088 } 8089 8090 struct IdxRemCtx { 8091 int nSlot; 8092 struct IdxRemSlot { 8093 int eType; /* SQLITE_NULL, INTEGER, REAL, TEXT, BLOB */ 8094 i64 iVal; /* SQLITE_INTEGER value */ 8095 double rVal; /* SQLITE_FLOAT value */ 8096 int nByte; /* Bytes of space allocated at z */ 8097 int n; /* Size of buffer z */ 8098 char *z; /* SQLITE_TEXT/BLOB value */ 8099 } aSlot[1]; 8100 }; 8101 8102 /* 8103 ** Implementation of scalar function rem(). 8104 */ 8105 static void idxRemFunc( 8106 sqlite3_context *pCtx, 8107 int argc, 8108 sqlite3_value **argv 8109 ){ 8110 struct IdxRemCtx *p = (struct IdxRemCtx*)sqlite3_user_data(pCtx); 8111 struct IdxRemSlot *pSlot; 8112 int iSlot; 8113 assert( argc==2 ); 8114 8115 iSlot = sqlite3_value_int(argv[0]); 8116 assert( iSlot<=p->nSlot ); 8117 pSlot = &p->aSlot[iSlot]; 8118 8119 switch( pSlot->eType ){ 8120 case SQLITE_NULL: 8121 /* no-op */ 8122 break; 8123 8124 case SQLITE_INTEGER: 8125 sqlite3_result_int64(pCtx, pSlot->iVal); 8126 break; 8127 8128 case SQLITE_FLOAT: 8129 sqlite3_result_double(pCtx, pSlot->rVal); 8130 break; 8131 8132 case SQLITE_BLOB: 8133 sqlite3_result_blob(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT); 8134 break; 8135 8136 case SQLITE_TEXT: 8137 sqlite3_result_text(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT); 8138 break; 8139 } 8140 8141 pSlot->eType = sqlite3_value_type(argv[1]); 8142 switch( pSlot->eType ){ 8143 case SQLITE_NULL: 8144 /* no-op */ 8145 break; 8146 8147 case SQLITE_INTEGER: 8148 pSlot->iVal = sqlite3_value_int64(argv[1]); 8149 break; 8150 8151 case SQLITE_FLOAT: 8152 pSlot->rVal = sqlite3_value_double(argv[1]); 8153 break; 8154 8155 case SQLITE_BLOB: 8156 case SQLITE_TEXT: { 8157 int nByte = sqlite3_value_bytes(argv[1]); 8158 if( nByte>pSlot->nByte ){ 8159 char *zNew = (char*)sqlite3_realloc(pSlot->z, nByte*2); 8160 if( zNew==0 ){ 8161 sqlite3_result_error_nomem(pCtx); 8162 return; 8163 } 8164 pSlot->nByte = nByte*2; 8165 pSlot->z = zNew; 8166 } 8167 pSlot->n = nByte; 8168 if( pSlot->eType==SQLITE_BLOB ){ 8169 memcpy(pSlot->z, sqlite3_value_blob(argv[1]), nByte); 8170 }else{ 8171 memcpy(pSlot->z, sqlite3_value_text(argv[1]), nByte); 8172 } 8173 break; 8174 } 8175 } 8176 } 8177 8178 static int idxLargestIndex(sqlite3 *db, int *pnMax, char **pzErr){ 8179 int rc = SQLITE_OK; 8180 const char *zMax = 8181 "SELECT max(i.seqno) FROM " 8182 " sqlite_master AS s, " 8183 " pragma_index_list(s.name) AS l, " 8184 " pragma_index_info(l.name) AS i " 8185 "WHERE s.type = 'table'"; 8186 sqlite3_stmt *pMax = 0; 8187 8188 *pnMax = 0; 8189 rc = idxPrepareStmt(db, &pMax, pzErr, zMax); 8190 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ 8191 *pnMax = sqlite3_column_int(pMax, 0) + 1; 8192 } 8193 idxFinalize(&rc, pMax); 8194 8195 return rc; 8196 } 8197 8198 static int idxPopulateOneStat1( 8199 sqlite3expert *p, 8200 sqlite3_stmt *pIndexXInfo, 8201 sqlite3_stmt *pWriteStat, 8202 const char *zTab, 8203 const char *zIdx, 8204 char **pzErr 8205 ){ 8206 char *zCols = 0; 8207 char *zOrder = 0; 8208 char *zQuery = 0; 8209 int nCol = 0; 8210 int i; 8211 sqlite3_stmt *pQuery = 0; 8212 int *aStat = 0; 8213 int rc = SQLITE_OK; 8214 8215 assert( p->iSample>0 ); 8216 8217 /* Formulate the query text */ 8218 sqlite3_bind_text(pIndexXInfo, 1, zIdx, -1, SQLITE_STATIC); 8219 while( SQLITE_OK==rc && SQLITE_ROW==sqlite3_step(pIndexXInfo) ){ 8220 const char *zComma = zCols==0 ? "" : ", "; 8221 const char *zName = (const char*)sqlite3_column_text(pIndexXInfo, 0); 8222 const char *zColl = (const char*)sqlite3_column_text(pIndexXInfo, 1); 8223 zCols = idxAppendText(&rc, zCols, 8224 "%sx.%Q IS rem(%d, x.%Q) COLLATE %s", zComma, zName, nCol, zName, zColl 8225 ); 8226 zOrder = idxAppendText(&rc, zOrder, "%s%d", zComma, ++nCol); 8227 } 8228 sqlite3_reset(pIndexXInfo); 8229 if( rc==SQLITE_OK ){ 8230 if( p->iSample==100 ){ 8231 zQuery = sqlite3_mprintf( 8232 "SELECT %s FROM %Q x ORDER BY %s", zCols, zTab, zOrder 8233 ); 8234 }else{ 8235 zQuery = sqlite3_mprintf( 8236 "SELECT %s FROM temp."UNIQUE_TABLE_NAME" x ORDER BY %s", zCols, zOrder 8237 ); 8238 } 8239 } 8240 sqlite3_free(zCols); 8241 sqlite3_free(zOrder); 8242 8243 /* Formulate the query text */ 8244 if( rc==SQLITE_OK ){ 8245 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv); 8246 rc = idxPrepareStmt(dbrem, &pQuery, pzErr, zQuery); 8247 } 8248 sqlite3_free(zQuery); 8249 8250 if( rc==SQLITE_OK ){ 8251 aStat = (int*)idxMalloc(&rc, sizeof(int)*(nCol+1)); 8252 } 8253 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){ 8254 IdxHashEntry *pEntry; 8255 char *zStat = 0; 8256 for(i=0; i<=nCol; i++) aStat[i] = 1; 8257 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){ 8258 aStat[0]++; 8259 for(i=0; i<nCol; i++){ 8260 if( sqlite3_column_int(pQuery, i)==0 ) break; 8261 } 8262 for(/*no-op*/; i<nCol; i++){ 8263 aStat[i+1]++; 8264 } 8265 } 8266 8267 if( rc==SQLITE_OK ){ 8268 int s0 = aStat[0]; 8269 zStat = sqlite3_mprintf("%d", s0); 8270 if( zStat==0 ) rc = SQLITE_NOMEM; 8271 for(i=1; rc==SQLITE_OK && i<=nCol; i++){ 8272 zStat = idxAppendText(&rc, zStat, " %d", (s0+aStat[i]/2) / aStat[i]); 8273 } 8274 } 8275 8276 if( rc==SQLITE_OK ){ 8277 sqlite3_bind_text(pWriteStat, 1, zTab, -1, SQLITE_STATIC); 8278 sqlite3_bind_text(pWriteStat, 2, zIdx, -1, SQLITE_STATIC); 8279 sqlite3_bind_text(pWriteStat, 3, zStat, -1, SQLITE_STATIC); 8280 sqlite3_step(pWriteStat); 8281 rc = sqlite3_reset(pWriteStat); 8282 } 8283 8284 pEntry = idxHashFind(&p->hIdx, zIdx, STRLEN(zIdx)); 8285 if( pEntry ){ 8286 assert( pEntry->zVal2==0 ); 8287 pEntry->zVal2 = zStat; 8288 }else{ 8289 sqlite3_free(zStat); 8290 } 8291 } 8292 sqlite3_free(aStat); 8293 idxFinalize(&rc, pQuery); 8294 8295 return rc; 8296 } 8297 8298 static int idxBuildSampleTable(sqlite3expert *p, const char *zTab){ 8299 int rc; 8300 char *zSql; 8301 8302 rc = sqlite3_exec(p->dbv,"DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0); 8303 if( rc!=SQLITE_OK ) return rc; 8304 8305 zSql = sqlite3_mprintf( 8306 "CREATE TABLE temp." UNIQUE_TABLE_NAME " AS SELECT * FROM %Q", zTab 8307 ); 8308 if( zSql==0 ) return SQLITE_NOMEM; 8309 rc = sqlite3_exec(p->dbv, zSql, 0, 0, 0); 8310 sqlite3_free(zSql); 8311 8312 return rc; 8313 } 8314 8315 /* 8316 ** This function is called as part of sqlite3_expert_analyze(). Candidate 8317 ** indexes have already been created in database sqlite3expert.dbm, this 8318 ** function populates sqlite_stat1 table in the same database. 8319 ** 8320 ** The stat1 data is generated by querying the 8321 */ 8322 static int idxPopulateStat1(sqlite3expert *p, char **pzErr){ 8323 int rc = SQLITE_OK; 8324 int nMax =0; 8325 struct IdxRemCtx *pCtx = 0; 8326 struct IdxSampleCtx samplectx; 8327 int i; 8328 i64 iPrev = -100000; 8329 sqlite3_stmt *pAllIndex = 0; 8330 sqlite3_stmt *pIndexXInfo = 0; 8331 sqlite3_stmt *pWrite = 0; 8332 8333 const char *zAllIndex = 8334 "SELECT s.rowid, s.name, l.name FROM " 8335 " sqlite_master AS s, " 8336 " pragma_index_list(s.name) AS l " 8337 "WHERE s.type = 'table'"; 8338 const char *zIndexXInfo = 8339 "SELECT name, coll FROM pragma_index_xinfo(?) WHERE key"; 8340 const char *zWrite = "INSERT INTO sqlite_stat1 VALUES(?, ?, ?)"; 8341 8342 /* If iSample==0, no sqlite_stat1 data is required. */ 8343 if( p->iSample==0 ) return SQLITE_OK; 8344 8345 rc = idxLargestIndex(p->dbm, &nMax, pzErr); 8346 if( nMax<=0 || rc!=SQLITE_OK ) return rc; 8347 8348 rc = sqlite3_exec(p->dbm, "ANALYZE; PRAGMA writable_schema=1", 0, 0, 0); 8349 8350 if( rc==SQLITE_OK ){ 8351 int nByte = sizeof(struct IdxRemCtx) + (sizeof(struct IdxRemSlot) * nMax); 8352 pCtx = (struct IdxRemCtx*)idxMalloc(&rc, nByte); 8353 } 8354 8355 if( rc==SQLITE_OK ){ 8356 sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv); 8357 rc = sqlite3_create_function( 8358 dbrem, "rem", 2, SQLITE_UTF8, (void*)pCtx, idxRemFunc, 0, 0 8359 ); 8360 } 8361 if( rc==SQLITE_OK ){ 8362 rc = sqlite3_create_function( 8363 p->db, "sample", 0, SQLITE_UTF8, (void*)&samplectx, idxSampleFunc, 0, 0 8364 ); 8365 } 8366 8367 if( rc==SQLITE_OK ){ 8368 pCtx->nSlot = nMax+1; 8369 rc = idxPrepareStmt(p->dbm, &pAllIndex, pzErr, zAllIndex); 8370 } 8371 if( rc==SQLITE_OK ){ 8372 rc = idxPrepareStmt(p->dbm, &pIndexXInfo, pzErr, zIndexXInfo); 8373 } 8374 if( rc==SQLITE_OK ){ 8375 rc = idxPrepareStmt(p->dbm, &pWrite, pzErr, zWrite); 8376 } 8377 8378 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pAllIndex) ){ 8379 i64 iRowid = sqlite3_column_int64(pAllIndex, 0); 8380 const char *zTab = (const char*)sqlite3_column_text(pAllIndex, 1); 8381 const char *zIdx = (const char*)sqlite3_column_text(pAllIndex, 2); 8382 if( p->iSample<100 && iPrev!=iRowid ){ 8383 samplectx.target = (double)p->iSample / 100.0; 8384 samplectx.iTarget = p->iSample; 8385 samplectx.nRow = 0.0; 8386 samplectx.nRet = 0.0; 8387 rc = idxBuildSampleTable(p, zTab); 8388 if( rc!=SQLITE_OK ) break; 8389 } 8390 rc = idxPopulateOneStat1(p, pIndexXInfo, pWrite, zTab, zIdx, pzErr); 8391 iPrev = iRowid; 8392 } 8393 if( rc==SQLITE_OK && p->iSample<100 ){ 8394 rc = sqlite3_exec(p->dbv, 8395 "DROP TABLE IF EXISTS temp." UNIQUE_TABLE_NAME, 0,0,0 8396 ); 8397 } 8398 8399 idxFinalize(&rc, pAllIndex); 8400 idxFinalize(&rc, pIndexXInfo); 8401 idxFinalize(&rc, pWrite); 8402 8403 for(i=0; i<pCtx->nSlot; i++){ 8404 sqlite3_free(pCtx->aSlot[i].z); 8405 } 8406 sqlite3_free(pCtx); 8407 8408 if( rc==SQLITE_OK ){ 8409 rc = sqlite3_exec(p->dbm, "ANALYZE sqlite_master", 0, 0, 0); 8410 } 8411 8412 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0); 8413 return rc; 8414 } 8415 8416 /* 8417 ** Allocate a new sqlite3expert object. 8418 */ 8419 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErrmsg){ 8420 int rc = SQLITE_OK; 8421 sqlite3expert *pNew; 8422 8423 pNew = (sqlite3expert*)idxMalloc(&rc, sizeof(sqlite3expert)); 8424 8425 /* Open two in-memory databases to work with. The "vtab database" (dbv) 8426 ** will contain a virtual table corresponding to each real table in 8427 ** the user database schema, and a copy of each view. It is used to 8428 ** collect information regarding the WHERE, ORDER BY and other clauses 8429 ** of the user's query. 8430 */ 8431 if( rc==SQLITE_OK ){ 8432 pNew->db = db; 8433 pNew->iSample = 100; 8434 rc = sqlite3_open(":memory:", &pNew->dbv); 8435 } 8436 if( rc==SQLITE_OK ){ 8437 rc = sqlite3_open(":memory:", &pNew->dbm); 8438 if( rc==SQLITE_OK ){ 8439 sqlite3_db_config(pNew->dbm, SQLITE_DBCONFIG_TRIGGER_EQP, 1, (int*)0); 8440 } 8441 } 8442 8443 8444 /* Copy the entire schema of database [db] into [dbm]. */ 8445 if( rc==SQLITE_OK ){ 8446 sqlite3_stmt *pSql; 8447 rc = idxPrintfPrepareStmt(pNew->db, &pSql, pzErrmsg, 8448 "SELECT sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%%'" 8449 " AND sql NOT LIKE 'CREATE VIRTUAL %%'" 8450 ); 8451 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 8452 const char *zSql = (const char*)sqlite3_column_text(pSql, 0); 8453 rc = sqlite3_exec(pNew->dbm, zSql, 0, 0, pzErrmsg); 8454 } 8455 idxFinalize(&rc, pSql); 8456 } 8457 8458 /* Create the vtab schema */ 8459 if( rc==SQLITE_OK ){ 8460 rc = idxCreateVtabSchema(pNew, pzErrmsg); 8461 } 8462 8463 /* Register the auth callback with dbv */ 8464 if( rc==SQLITE_OK ){ 8465 sqlite3_set_authorizer(pNew->dbv, idxAuthCallback, (void*)pNew); 8466 } 8467 8468 /* If an error has occurred, free the new object and reutrn NULL. Otherwise, 8469 ** return the new sqlite3expert handle. */ 8470 if( rc!=SQLITE_OK ){ 8471 sqlite3_expert_destroy(pNew); 8472 pNew = 0; 8473 } 8474 return pNew; 8475 } 8476 8477 /* 8478 ** Configure an sqlite3expert object. 8479 */ 8480 int sqlite3_expert_config(sqlite3expert *p, int op, ...){ 8481 int rc = SQLITE_OK; 8482 va_list ap; 8483 va_start(ap, op); 8484 switch( op ){ 8485 case EXPERT_CONFIG_SAMPLE: { 8486 int iVal = va_arg(ap, int); 8487 if( iVal<0 ) iVal = 0; 8488 if( iVal>100 ) iVal = 100; 8489 p->iSample = iVal; 8490 break; 8491 } 8492 default: 8493 rc = SQLITE_NOTFOUND; 8494 break; 8495 } 8496 8497 va_end(ap); 8498 return rc; 8499 } 8500 8501 /* 8502 ** Add an SQL statement to the analysis. 8503 */ 8504 int sqlite3_expert_sql( 8505 sqlite3expert *p, /* From sqlite3_expert_new() */ 8506 const char *zSql, /* SQL statement to add */ 8507 char **pzErr /* OUT: Error message (if any) */ 8508 ){ 8509 IdxScan *pScanOrig = p->pScan; 8510 IdxStatement *pStmtOrig = p->pStatement; 8511 int rc = SQLITE_OK; 8512 const char *zStmt = zSql; 8513 8514 if( p->bRun ) return SQLITE_MISUSE; 8515 8516 while( rc==SQLITE_OK && zStmt && zStmt[0] ){ 8517 sqlite3_stmt *pStmt = 0; 8518 rc = sqlite3_prepare_v2(p->dbv, zStmt, -1, &pStmt, &zStmt); 8519 if( rc==SQLITE_OK ){ 8520 if( pStmt ){ 8521 IdxStatement *pNew; 8522 const char *z = sqlite3_sql(pStmt); 8523 int n = STRLEN(z); 8524 pNew = (IdxStatement*)idxMalloc(&rc, sizeof(IdxStatement) + n+1); 8525 if( rc==SQLITE_OK ){ 8526 pNew->zSql = (char*)&pNew[1]; 8527 memcpy(pNew->zSql, z, n+1); 8528 pNew->pNext = p->pStatement; 8529 if( p->pStatement ) pNew->iId = p->pStatement->iId+1; 8530 p->pStatement = pNew; 8531 } 8532 sqlite3_finalize(pStmt); 8533 } 8534 }else{ 8535 idxDatabaseError(p->dbv, pzErr); 8536 } 8537 } 8538 8539 if( rc!=SQLITE_OK ){ 8540 idxScanFree(p->pScan, pScanOrig); 8541 idxStatementFree(p->pStatement, pStmtOrig); 8542 p->pScan = pScanOrig; 8543 p->pStatement = pStmtOrig; 8544 } 8545 8546 return rc; 8547 } 8548 8549 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr){ 8550 int rc; 8551 IdxHashEntry *pEntry; 8552 8553 /* Do trigger processing to collect any extra IdxScan structures */ 8554 rc = idxProcessTriggers(p, pzErr); 8555 8556 /* Create candidate indexes within the in-memory database file */ 8557 if( rc==SQLITE_OK ){ 8558 rc = idxCreateCandidates(p); 8559 } 8560 8561 /* Generate the stat1 data */ 8562 if( rc==SQLITE_OK ){ 8563 rc = idxPopulateStat1(p, pzErr); 8564 } 8565 8566 /* Formulate the EXPERT_REPORT_CANDIDATES text */ 8567 for(pEntry=p->hIdx.pFirst; pEntry; pEntry=pEntry->pNext){ 8568 p->zCandidates = idxAppendText(&rc, p->zCandidates, 8569 "%s;%s%s\n", pEntry->zVal, 8570 pEntry->zVal2 ? " -- stat1: " : "", pEntry->zVal2 8571 ); 8572 } 8573 8574 /* Figure out which of the candidate indexes are preferred by the query 8575 ** planner and report the results to the user. */ 8576 if( rc==SQLITE_OK ){ 8577 rc = idxFindIndexes(p, pzErr); 8578 } 8579 8580 if( rc==SQLITE_OK ){ 8581 p->bRun = 1; 8582 } 8583 return rc; 8584 } 8585 8586 /* 8587 ** Return the total number of statements that have been added to this 8588 ** sqlite3expert using sqlite3_expert_sql(). 8589 */ 8590 int sqlite3_expert_count(sqlite3expert *p){ 8591 int nRet = 0; 8592 if( p->pStatement ) nRet = p->pStatement->iId+1; 8593 return nRet; 8594 } 8595 8596 /* 8597 ** Return a component of the report. 8598 */ 8599 const char *sqlite3_expert_report(sqlite3expert *p, int iStmt, int eReport){ 8600 const char *zRet = 0; 8601 IdxStatement *pStmt; 8602 8603 if( p->bRun==0 ) return 0; 8604 for(pStmt=p->pStatement; pStmt && pStmt->iId!=iStmt; pStmt=pStmt->pNext); 8605 switch( eReport ){ 8606 case EXPERT_REPORT_SQL: 8607 if( pStmt ) zRet = pStmt->zSql; 8608 break; 8609 case EXPERT_REPORT_INDEXES: 8610 if( pStmt ) zRet = pStmt->zIdx; 8611 break; 8612 case EXPERT_REPORT_PLAN: 8613 if( pStmt ) zRet = pStmt->zEQP; 8614 break; 8615 case EXPERT_REPORT_CANDIDATES: 8616 zRet = p->zCandidates; 8617 break; 8618 } 8619 return zRet; 8620 } 8621 8622 /* 8623 ** Free an sqlite3expert object. 8624 */ 8625 void sqlite3_expert_destroy(sqlite3expert *p){ 8626 if( p ){ 8627 sqlite3_close(p->dbm); 8628 sqlite3_close(p->dbv); 8629 idxScanFree(p->pScan, 0); 8630 idxStatementFree(p->pStatement, 0); 8631 idxTableFree(p->pTable); 8632 idxWriteFree(p->pWrite); 8633 idxHashClear(&p->hIdx); 8634 sqlite3_free(p->zCandidates); 8635 sqlite3_free(p); 8636 } 8637 } 8638 8639 #endif /* ifndef SQLITE_OMIT_VIRTUAL_TABLE */ 8640 8641 /************************* End ../ext/expert/sqlite3expert.c ********************/ 8642 8643 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 8644 /************************* Begin ../ext/misc/dbdata.c ******************/ 8645 /* 8646 ** 2019-04-17 8647 ** 8648 ** The author disclaims copyright to this source code. In place of 8649 ** a legal notice, here is a blessing: 8650 ** 8651 ** May you do good and not evil. 8652 ** May you find forgiveness for yourself and forgive others. 8653 ** May you share freely, never taking more than you give. 8654 ** 8655 ****************************************************************************** 8656 ** 8657 ** This file contains an implementation of two eponymous virtual tables, 8658 ** "sqlite_dbdata" and "sqlite_dbptr". Both modules require that the 8659 ** "sqlite_dbpage" eponymous virtual table be available. 8660 ** 8661 ** SQLITE_DBDATA: 8662 ** sqlite_dbdata is used to extract data directly from a database b-tree 8663 ** page and its associated overflow pages, bypassing the b-tree layer. 8664 ** The table schema is equivalent to: 8665 ** 8666 ** CREATE TABLE sqlite_dbdata( 8667 ** pgno INTEGER, 8668 ** cell INTEGER, 8669 ** field INTEGER, 8670 ** value ANY, 8671 ** schema TEXT HIDDEN 8672 ** ); 8673 ** 8674 ** IMPORTANT: THE VIRTUAL TABLE SCHEMA ABOVE IS SUBJECT TO CHANGE. IN THE 8675 ** FUTURE NEW NON-HIDDEN COLUMNS MAY BE ADDED BETWEEN "value" AND 8676 ** "schema". 8677 ** 8678 ** Each page of the database is inspected. If it cannot be interpreted as 8679 ** a b-tree page, or if it is a b-tree page containing 0 entries, the 8680 ** sqlite_dbdata table contains no rows for that page. Otherwise, the 8681 ** table contains one row for each field in the record associated with 8682 ** each cell on the page. For intkey b-trees, the key value is stored in 8683 ** field -1. 8684 ** 8685 ** For example, for the database: 8686 ** 8687 ** CREATE TABLE t1(a, b); -- root page is page 2 8688 ** INSERT INTO t1(rowid, a, b) VALUES(5, 'v', 'five'); 8689 ** INSERT INTO t1(rowid, a, b) VALUES(10, 'x', 'ten'); 8690 ** 8691 ** the sqlite_dbdata table contains, as well as from entries related to 8692 ** page 1, content equivalent to: 8693 ** 8694 ** INSERT INTO sqlite_dbdata(pgno, cell, field, value) VALUES 8695 ** (2, 0, -1, 5 ), 8696 ** (2, 0, 0, 'v' ), 8697 ** (2, 0, 1, 'five'), 8698 ** (2, 1, -1, 10 ), 8699 ** (2, 1, 0, 'x' ), 8700 ** (2, 1, 1, 'ten' ); 8701 ** 8702 ** If database corruption is encountered, this module does not report an 8703 ** error. Instead, it attempts to extract as much data as possible and 8704 ** ignores the corruption. 8705 ** 8706 ** SQLITE_DBPTR: 8707 ** The sqlite_dbptr table has the following schema: 8708 ** 8709 ** CREATE TABLE sqlite_dbptr( 8710 ** pgno INTEGER, 8711 ** child INTEGER, 8712 ** schema TEXT HIDDEN 8713 ** ); 8714 ** 8715 ** It contains one entry for each b-tree pointer between a parent and 8716 ** child page in the database. 8717 */ 8718 #if !defined(SQLITEINT_H) 8719 /* #include "sqlite3ext.h" */ 8720 8721 /* typedef unsigned char u8; */ 8722 8723 #endif 8724 SQLITE_EXTENSION_INIT1 8725 #include <string.h> 8726 #include <assert.h> 8727 8728 #define DBDATA_PADDING_BYTES 100 8729 8730 typedef struct DbdataTable DbdataTable; 8731 typedef struct DbdataCursor DbdataCursor; 8732 8733 /* Cursor object */ 8734 struct DbdataCursor { 8735 sqlite3_vtab_cursor base; /* Base class. Must be first */ 8736 sqlite3_stmt *pStmt; /* For fetching database pages */ 8737 8738 int iPgno; /* Current page number */ 8739 u8 *aPage; /* Buffer containing page */ 8740 int nPage; /* Size of aPage[] in bytes */ 8741 int nCell; /* Number of cells on aPage[] */ 8742 int iCell; /* Current cell number */ 8743 int bOnePage; /* True to stop after one page */ 8744 int szDb; 8745 sqlite3_int64 iRowid; 8746 8747 /* Only for the sqlite_dbdata table */ 8748 u8 *pRec; /* Buffer containing current record */ 8749 int nRec; /* Size of pRec[] in bytes */ 8750 int nHdr; /* Size of header in bytes */ 8751 int iField; /* Current field number */ 8752 u8 *pHdrPtr; 8753 u8 *pPtr; 8754 8755 sqlite3_int64 iIntkey; /* Integer key value */ 8756 }; 8757 8758 /* Table object */ 8759 struct DbdataTable { 8760 sqlite3_vtab base; /* Base class. Must be first */ 8761 sqlite3 *db; /* The database connection */ 8762 sqlite3_stmt *pStmt; /* For fetching database pages */ 8763 int bPtr; /* True for sqlite3_dbptr table */ 8764 }; 8765 8766 /* Column and schema definitions for sqlite_dbdata */ 8767 #define DBDATA_COLUMN_PGNO 0 8768 #define DBDATA_COLUMN_CELL 1 8769 #define DBDATA_COLUMN_FIELD 2 8770 #define DBDATA_COLUMN_VALUE 3 8771 #define DBDATA_COLUMN_SCHEMA 4 8772 #define DBDATA_SCHEMA \ 8773 "CREATE TABLE x(" \ 8774 " pgno INTEGER," \ 8775 " cell INTEGER," \ 8776 " field INTEGER," \ 8777 " value ANY," \ 8778 " schema TEXT HIDDEN" \ 8779 ")" 8780 8781 /* Column and schema definitions for sqlite_dbptr */ 8782 #define DBPTR_COLUMN_PGNO 0 8783 #define DBPTR_COLUMN_CHILD 1 8784 #define DBPTR_COLUMN_SCHEMA 2 8785 #define DBPTR_SCHEMA \ 8786 "CREATE TABLE x(" \ 8787 " pgno INTEGER," \ 8788 " child INTEGER," \ 8789 " schema TEXT HIDDEN" \ 8790 ")" 8791 8792 /* 8793 ** Connect to an sqlite_dbdata (pAux==0) or sqlite_dbptr (pAux!=0) virtual 8794 ** table. 8795 */ 8796 static int dbdataConnect( 8797 sqlite3 *db, 8798 void *pAux, 8799 int argc, const char *const*argv, 8800 sqlite3_vtab **ppVtab, 8801 char **pzErr 8802 ){ 8803 DbdataTable *pTab = 0; 8804 int rc = sqlite3_declare_vtab(db, pAux ? DBPTR_SCHEMA : DBDATA_SCHEMA); 8805 8806 if( rc==SQLITE_OK ){ 8807 pTab = (DbdataTable*)sqlite3_malloc64(sizeof(DbdataTable)); 8808 if( pTab==0 ){ 8809 rc = SQLITE_NOMEM; 8810 }else{ 8811 memset(pTab, 0, sizeof(DbdataTable)); 8812 pTab->db = db; 8813 pTab->bPtr = (pAux!=0); 8814 } 8815 } 8816 8817 *ppVtab = (sqlite3_vtab*)pTab; 8818 return rc; 8819 } 8820 8821 /* 8822 ** Disconnect from or destroy a sqlite_dbdata or sqlite_dbptr virtual table. 8823 */ 8824 static int dbdataDisconnect(sqlite3_vtab *pVtab){ 8825 DbdataTable *pTab = (DbdataTable*)pVtab; 8826 if( pTab ){ 8827 sqlite3_finalize(pTab->pStmt); 8828 sqlite3_free(pVtab); 8829 } 8830 return SQLITE_OK; 8831 } 8832 8833 /* 8834 ** This function interprets two types of constraints: 8835 ** 8836 ** schema=? 8837 ** pgno=? 8838 ** 8839 ** If neither are present, idxNum is set to 0. If schema=? is present, 8840 ** the 0x01 bit in idxNum is set. If pgno=? is present, the 0x02 bit 8841 ** in idxNum is set. 8842 ** 8843 ** If both parameters are present, schema is in position 0 and pgno in 8844 ** position 1. 8845 */ 8846 static int dbdataBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdx){ 8847 DbdataTable *pTab = (DbdataTable*)tab; 8848 int i; 8849 int iSchema = -1; 8850 int iPgno = -1; 8851 int colSchema = (pTab->bPtr ? DBPTR_COLUMN_SCHEMA : DBDATA_COLUMN_SCHEMA); 8852 8853 for(i=0; i<pIdx->nConstraint; i++){ 8854 struct sqlite3_index_constraint *p = &pIdx->aConstraint[i]; 8855 if( p->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 8856 if( p->iColumn==colSchema ){ 8857 if( p->usable==0 ) return SQLITE_CONSTRAINT; 8858 iSchema = i; 8859 } 8860 if( p->iColumn==DBDATA_COLUMN_PGNO && p->usable ){ 8861 iPgno = i; 8862 } 8863 } 8864 } 8865 8866 if( iSchema>=0 ){ 8867 pIdx->aConstraintUsage[iSchema].argvIndex = 1; 8868 pIdx->aConstraintUsage[iSchema].omit = 1; 8869 } 8870 if( iPgno>=0 ){ 8871 pIdx->aConstraintUsage[iPgno].argvIndex = 1 + (iSchema>=0); 8872 pIdx->aConstraintUsage[iPgno].omit = 1; 8873 pIdx->estimatedCost = 100; 8874 pIdx->estimatedRows = 50; 8875 8876 if( pTab->bPtr==0 && pIdx->nOrderBy && pIdx->aOrderBy[0].desc==0 ){ 8877 int iCol = pIdx->aOrderBy[0].iColumn; 8878 if( pIdx->nOrderBy==1 ){ 8879 pIdx->orderByConsumed = (iCol==0 || iCol==1); 8880 }else if( pIdx->nOrderBy==2 && pIdx->aOrderBy[1].desc==0 && iCol==0 ){ 8881 pIdx->orderByConsumed = (pIdx->aOrderBy[1].iColumn==1); 8882 } 8883 } 8884 8885 }else{ 8886 pIdx->estimatedCost = 100000000; 8887 pIdx->estimatedRows = 1000000000; 8888 } 8889 pIdx->idxNum = (iSchema>=0 ? 0x01 : 0x00) | (iPgno>=0 ? 0x02 : 0x00); 8890 return SQLITE_OK; 8891 } 8892 8893 /* 8894 ** Open a new sqlite_dbdata or sqlite_dbptr cursor. 8895 */ 8896 static int dbdataOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ 8897 DbdataCursor *pCsr; 8898 8899 pCsr = (DbdataCursor*)sqlite3_malloc64(sizeof(DbdataCursor)); 8900 if( pCsr==0 ){ 8901 return SQLITE_NOMEM; 8902 }else{ 8903 memset(pCsr, 0, sizeof(DbdataCursor)); 8904 pCsr->base.pVtab = pVTab; 8905 } 8906 8907 *ppCursor = (sqlite3_vtab_cursor *)pCsr; 8908 return SQLITE_OK; 8909 } 8910 8911 /* 8912 ** Restore a cursor object to the state it was in when first allocated 8913 ** by dbdataOpen(). 8914 */ 8915 static void dbdataResetCursor(DbdataCursor *pCsr){ 8916 DbdataTable *pTab = (DbdataTable*)(pCsr->base.pVtab); 8917 if( pTab->pStmt==0 ){ 8918 pTab->pStmt = pCsr->pStmt; 8919 }else{ 8920 sqlite3_finalize(pCsr->pStmt); 8921 } 8922 pCsr->pStmt = 0; 8923 pCsr->iPgno = 1; 8924 pCsr->iCell = 0; 8925 pCsr->iField = 0; 8926 pCsr->bOnePage = 0; 8927 sqlite3_free(pCsr->aPage); 8928 sqlite3_free(pCsr->pRec); 8929 pCsr->pRec = 0; 8930 pCsr->aPage = 0; 8931 } 8932 8933 /* 8934 ** Close an sqlite_dbdata or sqlite_dbptr cursor. 8935 */ 8936 static int dbdataClose(sqlite3_vtab_cursor *pCursor){ 8937 DbdataCursor *pCsr = (DbdataCursor*)pCursor; 8938 dbdataResetCursor(pCsr); 8939 sqlite3_free(pCsr); 8940 return SQLITE_OK; 8941 } 8942 8943 /* 8944 ** Utility methods to decode 16 and 32-bit big-endian unsigned integers. 8945 */ 8946 static unsigned int get_uint16(unsigned char *a){ 8947 return (a[0]<<8)|a[1]; 8948 } 8949 static unsigned int get_uint32(unsigned char *a){ 8950 return ((unsigned int)a[0]<<24) 8951 | ((unsigned int)a[1]<<16) 8952 | ((unsigned int)a[2]<<8) 8953 | ((unsigned int)a[3]); 8954 } 8955 8956 /* 8957 ** Load page pgno from the database via the sqlite_dbpage virtual table. 8958 ** If successful, set (*ppPage) to point to a buffer containing the page 8959 ** data, (*pnPage) to the size of that buffer in bytes and return 8960 ** SQLITE_OK. In this case it is the responsibility of the caller to 8961 ** eventually free the buffer using sqlite3_free(). 8962 ** 8963 ** Or, if an error occurs, set both (*ppPage) and (*pnPage) to 0 and 8964 ** return an SQLite error code. 8965 */ 8966 static int dbdataLoadPage( 8967 DbdataCursor *pCsr, /* Cursor object */ 8968 unsigned int pgno, /* Page number of page to load */ 8969 u8 **ppPage, /* OUT: pointer to page buffer */ 8970 int *pnPage /* OUT: Size of (*ppPage) in bytes */ 8971 ){ 8972 int rc2; 8973 int rc = SQLITE_OK; 8974 sqlite3_stmt *pStmt = pCsr->pStmt; 8975 8976 *ppPage = 0; 8977 *pnPage = 0; 8978 sqlite3_bind_int64(pStmt, 2, pgno); 8979 if( SQLITE_ROW==sqlite3_step(pStmt) ){ 8980 int nCopy = sqlite3_column_bytes(pStmt, 0); 8981 if( nCopy>0 ){ 8982 u8 *pPage; 8983 pPage = (u8*)sqlite3_malloc64(nCopy + DBDATA_PADDING_BYTES); 8984 if( pPage==0 ){ 8985 rc = SQLITE_NOMEM; 8986 }else{ 8987 const u8 *pCopy = sqlite3_column_blob(pStmt, 0); 8988 memcpy(pPage, pCopy, nCopy); 8989 memset(&pPage[nCopy], 0, DBDATA_PADDING_BYTES); 8990 } 8991 *ppPage = pPage; 8992 *pnPage = nCopy; 8993 } 8994 } 8995 rc2 = sqlite3_reset(pStmt); 8996 if( rc==SQLITE_OK ) rc = rc2; 8997 8998 return rc; 8999 } 9000 9001 /* 9002 ** Read a varint. Put the value in *pVal and return the number of bytes. 9003 */ 9004 static int dbdataGetVarint(const u8 *z, sqlite3_int64 *pVal){ 9005 sqlite3_int64 v = 0; 9006 int i; 9007 for(i=0; i<8; i++){ 9008 v = (v<<7) + (z[i]&0x7f); 9009 if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; } 9010 } 9011 v = (v<<8) + (z[i]&0xff); 9012 *pVal = v; 9013 return 9; 9014 } 9015 9016 /* 9017 ** Return the number of bytes of space used by an SQLite value of type 9018 ** eType. 9019 */ 9020 static int dbdataValueBytes(int eType){ 9021 switch( eType ){ 9022 case 0: case 8: case 9: 9023 case 10: case 11: 9024 return 0; 9025 case 1: 9026 return 1; 9027 case 2: 9028 return 2; 9029 case 3: 9030 return 3; 9031 case 4: 9032 return 4; 9033 case 5: 9034 return 6; 9035 case 6: 9036 case 7: 9037 return 8; 9038 default: 9039 if( eType>0 ){ 9040 return ((eType-12) / 2); 9041 } 9042 return 0; 9043 } 9044 } 9045 9046 /* 9047 ** Load a value of type eType from buffer pData and use it to set the 9048 ** result of context object pCtx. 9049 */ 9050 static void dbdataValue( 9051 sqlite3_context *pCtx, 9052 int eType, 9053 u8 *pData, 9054 int nData 9055 ){ 9056 if( eType>=0 && dbdataValueBytes(eType)<=nData ){ 9057 switch( eType ){ 9058 case 0: 9059 case 10: 9060 case 11: 9061 sqlite3_result_null(pCtx); 9062 break; 9063 9064 case 8: 9065 sqlite3_result_int(pCtx, 0); 9066 break; 9067 case 9: 9068 sqlite3_result_int(pCtx, 1); 9069 break; 9070 9071 case 1: case 2: case 3: case 4: case 5: case 6: case 7: { 9072 sqlite3_uint64 v = (signed char)pData[0]; 9073 pData++; 9074 switch( eType ){ 9075 case 7: 9076 case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; 9077 case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; 9078 case 4: v = (v<<8) + pData[0]; pData++; 9079 case 3: v = (v<<8) + pData[0]; pData++; 9080 case 2: v = (v<<8) + pData[0]; pData++; 9081 } 9082 9083 if( eType==7 ){ 9084 double r; 9085 memcpy(&r, &v, sizeof(r)); 9086 sqlite3_result_double(pCtx, r); 9087 }else{ 9088 sqlite3_result_int64(pCtx, (sqlite3_int64)v); 9089 } 9090 break; 9091 } 9092 9093 default: { 9094 int n = ((eType-12) / 2); 9095 if( eType % 2 ){ 9096 sqlite3_result_text(pCtx, (const char*)pData, n, SQLITE_TRANSIENT); 9097 }else{ 9098 sqlite3_result_blob(pCtx, pData, n, SQLITE_TRANSIENT); 9099 } 9100 } 9101 } 9102 } 9103 } 9104 9105 /* 9106 ** Move an sqlite_dbdata or sqlite_dbptr cursor to the next entry. 9107 */ 9108 static int dbdataNext(sqlite3_vtab_cursor *pCursor){ 9109 DbdataCursor *pCsr = (DbdataCursor*)pCursor; 9110 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab; 9111 9112 pCsr->iRowid++; 9113 while( 1 ){ 9114 int rc; 9115 int iOff = (pCsr->iPgno==1 ? 100 : 0); 9116 int bNextPage = 0; 9117 9118 if( pCsr->aPage==0 ){ 9119 while( 1 ){ 9120 if( pCsr->bOnePage==0 && pCsr->iPgno>pCsr->szDb ) return SQLITE_OK; 9121 rc = dbdataLoadPage(pCsr, pCsr->iPgno, &pCsr->aPage, &pCsr->nPage); 9122 if( rc!=SQLITE_OK ) return rc; 9123 if( pCsr->aPage ) break; 9124 pCsr->iPgno++; 9125 } 9126 pCsr->iCell = pTab->bPtr ? -2 : 0; 9127 pCsr->nCell = get_uint16(&pCsr->aPage[iOff+3]); 9128 } 9129 9130 if( pTab->bPtr ){ 9131 if( pCsr->aPage[iOff]!=0x02 && pCsr->aPage[iOff]!=0x05 ){ 9132 pCsr->iCell = pCsr->nCell; 9133 } 9134 pCsr->iCell++; 9135 if( pCsr->iCell>=pCsr->nCell ){ 9136 sqlite3_free(pCsr->aPage); 9137 pCsr->aPage = 0; 9138 if( pCsr->bOnePage ) return SQLITE_OK; 9139 pCsr->iPgno++; 9140 }else{ 9141 return SQLITE_OK; 9142 } 9143 }else{ 9144 /* If there is no record loaded, load it now. */ 9145 if( pCsr->pRec==0 ){ 9146 int bHasRowid = 0; 9147 int nPointer = 0; 9148 sqlite3_int64 nPayload = 0; 9149 sqlite3_int64 nHdr = 0; 9150 int iHdr; 9151 int U, X; 9152 int nLocal; 9153 9154 switch( pCsr->aPage[iOff] ){ 9155 case 0x02: 9156 nPointer = 4; 9157 break; 9158 case 0x0a: 9159 break; 9160 case 0x0d: 9161 bHasRowid = 1; 9162 break; 9163 default: 9164 /* This is not a b-tree page with records on it. Continue. */ 9165 pCsr->iCell = pCsr->nCell; 9166 break; 9167 } 9168 9169 if( pCsr->iCell>=pCsr->nCell ){ 9170 bNextPage = 1; 9171 }else{ 9172 9173 iOff += 8 + nPointer + pCsr->iCell*2; 9174 if( iOff>pCsr->nPage ){ 9175 bNextPage = 1; 9176 }else{ 9177 iOff = get_uint16(&pCsr->aPage[iOff]); 9178 } 9179 9180 /* For an interior node cell, skip past the child-page number */ 9181 iOff += nPointer; 9182 9183 /* Load the "byte of payload including overflow" field */ 9184 if( bNextPage || iOff>pCsr->nPage ){ 9185 bNextPage = 1; 9186 }else{ 9187 iOff += dbdataGetVarint(&pCsr->aPage[iOff], &nPayload); 9188 } 9189 9190 /* If this is a leaf intkey cell, load the rowid */ 9191 if( bHasRowid && !bNextPage && iOff<pCsr->nPage ){ 9192 iOff += dbdataGetVarint(&pCsr->aPage[iOff], &pCsr->iIntkey); 9193 } 9194 9195 /* Figure out how much data to read from the local page */ 9196 U = pCsr->nPage; 9197 if( bHasRowid ){ 9198 X = U-35; 9199 }else{ 9200 X = ((U-12)*64/255)-23; 9201 } 9202 if( nPayload<=X ){ 9203 nLocal = nPayload; 9204 }else{ 9205 int M, K; 9206 M = ((U-12)*32/255)-23; 9207 K = M+((nPayload-M)%(U-4)); 9208 if( K<=X ){ 9209 nLocal = K; 9210 }else{ 9211 nLocal = M; 9212 } 9213 } 9214 9215 if( bNextPage || nLocal+iOff>pCsr->nPage ){ 9216 bNextPage = 1; 9217 }else{ 9218 9219 /* Allocate space for payload. And a bit more to catch small buffer 9220 ** overruns caused by attempting to read a varint or similar from 9221 ** near the end of a corrupt record. */ 9222 pCsr->pRec = (u8*)sqlite3_malloc64(nPayload+DBDATA_PADDING_BYTES); 9223 if( pCsr->pRec==0 ) return SQLITE_NOMEM; 9224 memset(pCsr->pRec, 0, nPayload+DBDATA_PADDING_BYTES); 9225 pCsr->nRec = nPayload; 9226 9227 /* Load the nLocal bytes of payload */ 9228 memcpy(pCsr->pRec, &pCsr->aPage[iOff], nLocal); 9229 iOff += nLocal; 9230 9231 /* Load content from overflow pages */ 9232 if( nPayload>nLocal ){ 9233 sqlite3_int64 nRem = nPayload - nLocal; 9234 unsigned int pgnoOvfl = get_uint32(&pCsr->aPage[iOff]); 9235 while( nRem>0 ){ 9236 u8 *aOvfl = 0; 9237 int nOvfl = 0; 9238 int nCopy; 9239 rc = dbdataLoadPage(pCsr, pgnoOvfl, &aOvfl, &nOvfl); 9240 assert( rc!=SQLITE_OK || aOvfl==0 || nOvfl==pCsr->nPage ); 9241 if( rc!=SQLITE_OK ) return rc; 9242 if( aOvfl==0 ) break; 9243 9244 nCopy = U-4; 9245 if( nCopy>nRem ) nCopy = nRem; 9246 memcpy(&pCsr->pRec[nPayload-nRem], &aOvfl[4], nCopy); 9247 nRem -= nCopy; 9248 9249 pgnoOvfl = get_uint32(aOvfl); 9250 sqlite3_free(aOvfl); 9251 } 9252 } 9253 9254 iHdr = dbdataGetVarint(pCsr->pRec, &nHdr); 9255 pCsr->nHdr = nHdr; 9256 pCsr->pHdrPtr = &pCsr->pRec[iHdr]; 9257 pCsr->pPtr = &pCsr->pRec[pCsr->nHdr]; 9258 pCsr->iField = (bHasRowid ? -1 : 0); 9259 } 9260 } 9261 }else{ 9262 pCsr->iField++; 9263 if( pCsr->iField>0 ){ 9264 sqlite3_int64 iType; 9265 if( pCsr->pHdrPtr>&pCsr->pRec[pCsr->nRec] ){ 9266 bNextPage = 1; 9267 }else{ 9268 pCsr->pHdrPtr += dbdataGetVarint(pCsr->pHdrPtr, &iType); 9269 pCsr->pPtr += dbdataValueBytes(iType); 9270 } 9271 } 9272 } 9273 9274 if( bNextPage ){ 9275 sqlite3_free(pCsr->aPage); 9276 sqlite3_free(pCsr->pRec); 9277 pCsr->aPage = 0; 9278 pCsr->pRec = 0; 9279 if( pCsr->bOnePage ) return SQLITE_OK; 9280 pCsr->iPgno++; 9281 }else{ 9282 if( pCsr->iField<0 || pCsr->pHdrPtr<&pCsr->pRec[pCsr->nHdr] ){ 9283 return SQLITE_OK; 9284 } 9285 9286 /* Advance to the next cell. The next iteration of the loop will load 9287 ** the record and so on. */ 9288 sqlite3_free(pCsr->pRec); 9289 pCsr->pRec = 0; 9290 pCsr->iCell++; 9291 } 9292 } 9293 } 9294 9295 assert( !"can't get here" ); 9296 return SQLITE_OK; 9297 } 9298 9299 /* 9300 ** Return true if the cursor is at EOF. 9301 */ 9302 static int dbdataEof(sqlite3_vtab_cursor *pCursor){ 9303 DbdataCursor *pCsr = (DbdataCursor*)pCursor; 9304 return pCsr->aPage==0; 9305 } 9306 9307 /* 9308 ** Determine the size in pages of database zSchema (where zSchema is 9309 ** "main", "temp" or the name of an attached database) and set 9310 ** pCsr->szDb accordingly. If successful, return SQLITE_OK. Otherwise, 9311 ** an SQLite error code. 9312 */ 9313 static int dbdataDbsize(DbdataCursor *pCsr, const char *zSchema){ 9314 DbdataTable *pTab = (DbdataTable*)pCsr->base.pVtab; 9315 char *zSql = 0; 9316 int rc, rc2; 9317 sqlite3_stmt *pStmt = 0; 9318 9319 zSql = sqlite3_mprintf("PRAGMA %Q.page_count", zSchema); 9320 if( zSql==0 ) return SQLITE_NOMEM; 9321 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0); 9322 sqlite3_free(zSql); 9323 if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ 9324 pCsr->szDb = sqlite3_column_int(pStmt, 0); 9325 } 9326 rc2 = sqlite3_finalize(pStmt); 9327 if( rc==SQLITE_OK ) rc = rc2; 9328 return rc; 9329 } 9330 9331 /* 9332 ** xFilter method for sqlite_dbdata and sqlite_dbptr. 9333 */ 9334 static int dbdataFilter( 9335 sqlite3_vtab_cursor *pCursor, 9336 int idxNum, const char *idxStr, 9337 int argc, sqlite3_value **argv 9338 ){ 9339 DbdataCursor *pCsr = (DbdataCursor*)pCursor; 9340 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab; 9341 int rc = SQLITE_OK; 9342 const char *zSchema = "main"; 9343 9344 dbdataResetCursor(pCsr); 9345 assert( pCsr->iPgno==1 ); 9346 if( idxNum & 0x01 ){ 9347 zSchema = (const char*)sqlite3_value_text(argv[0]); 9348 } 9349 if( idxNum & 0x02 ){ 9350 pCsr->iPgno = sqlite3_value_int(argv[(idxNum & 0x01)]); 9351 pCsr->bOnePage = 1; 9352 }else{ 9353 pCsr->nPage = dbdataDbsize(pCsr, zSchema); 9354 rc = dbdataDbsize(pCsr, zSchema); 9355 } 9356 9357 if( rc==SQLITE_OK ){ 9358 if( pTab->pStmt ){ 9359 pCsr->pStmt = pTab->pStmt; 9360 pTab->pStmt = 0; 9361 }else{ 9362 rc = sqlite3_prepare_v2(pTab->db, 9363 "SELECT data FROM sqlite_dbpage(?) WHERE pgno=?", -1, 9364 &pCsr->pStmt, 0 9365 ); 9366 } 9367 } 9368 if( rc==SQLITE_OK ){ 9369 rc = sqlite3_bind_text(pCsr->pStmt, 1, zSchema, -1, SQLITE_TRANSIENT); 9370 }else{ 9371 pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db)); 9372 } 9373 if( rc==SQLITE_OK ){ 9374 rc = dbdataNext(pCursor); 9375 } 9376 return rc; 9377 } 9378 9379 /* 9380 ** Return a column for the sqlite_dbdata or sqlite_dbptr table. 9381 */ 9382 static int dbdataColumn( 9383 sqlite3_vtab_cursor *pCursor, 9384 sqlite3_context *ctx, 9385 int i 9386 ){ 9387 DbdataCursor *pCsr = (DbdataCursor*)pCursor; 9388 DbdataTable *pTab = (DbdataTable*)pCursor->pVtab; 9389 if( pTab->bPtr ){ 9390 switch( i ){ 9391 case DBPTR_COLUMN_PGNO: 9392 sqlite3_result_int64(ctx, pCsr->iPgno); 9393 break; 9394 case DBPTR_COLUMN_CHILD: { 9395 int iOff = pCsr->iPgno==1 ? 100 : 0; 9396 if( pCsr->iCell<0 ){ 9397 iOff += 8; 9398 }else{ 9399 iOff += 12 + pCsr->iCell*2; 9400 if( iOff>pCsr->nPage ) return SQLITE_OK; 9401 iOff = get_uint16(&pCsr->aPage[iOff]); 9402 } 9403 if( iOff<=pCsr->nPage ){ 9404 sqlite3_result_int64(ctx, get_uint32(&pCsr->aPage[iOff])); 9405 } 9406 break; 9407 } 9408 } 9409 }else{ 9410 switch( i ){ 9411 case DBDATA_COLUMN_PGNO: 9412 sqlite3_result_int64(ctx, pCsr->iPgno); 9413 break; 9414 case DBDATA_COLUMN_CELL: 9415 sqlite3_result_int(ctx, pCsr->iCell); 9416 break; 9417 case DBDATA_COLUMN_FIELD: 9418 sqlite3_result_int(ctx, pCsr->iField); 9419 break; 9420 case DBDATA_COLUMN_VALUE: { 9421 if( pCsr->iField<0 ){ 9422 sqlite3_result_int64(ctx, pCsr->iIntkey); 9423 }else{ 9424 sqlite3_int64 iType; 9425 dbdataGetVarint(pCsr->pHdrPtr, &iType); 9426 dbdataValue( 9427 ctx, iType, pCsr->pPtr, &pCsr->pRec[pCsr->nRec] - pCsr->pPtr 9428 ); 9429 } 9430 break; 9431 } 9432 } 9433 } 9434 return SQLITE_OK; 9435 } 9436 9437 /* 9438 ** Return the rowid for an sqlite_dbdata or sqlite_dptr table. 9439 */ 9440 static int dbdataRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){ 9441 DbdataCursor *pCsr = (DbdataCursor*)pCursor; 9442 *pRowid = pCsr->iRowid; 9443 return SQLITE_OK; 9444 } 9445 9446 9447 /* 9448 ** Invoke this routine to register the "sqlite_dbdata" virtual table module 9449 */ 9450 static int sqlite3DbdataRegister(sqlite3 *db){ 9451 static sqlite3_module dbdata_module = { 9452 0, /* iVersion */ 9453 0, /* xCreate */ 9454 dbdataConnect, /* xConnect */ 9455 dbdataBestIndex, /* xBestIndex */ 9456 dbdataDisconnect, /* xDisconnect */ 9457 0, /* xDestroy */ 9458 dbdataOpen, /* xOpen - open a cursor */ 9459 dbdataClose, /* xClose - close a cursor */ 9460 dbdataFilter, /* xFilter - configure scan constraints */ 9461 dbdataNext, /* xNext - advance a cursor */ 9462 dbdataEof, /* xEof - check for end of scan */ 9463 dbdataColumn, /* xColumn - read data */ 9464 dbdataRowid, /* xRowid - read data */ 9465 0, /* xUpdate */ 9466 0, /* xBegin */ 9467 0, /* xSync */ 9468 0, /* xCommit */ 9469 0, /* xRollback */ 9470 0, /* xFindMethod */ 9471 0, /* xRename */ 9472 0, /* xSavepoint */ 9473 0, /* xRelease */ 9474 0, /* xRollbackTo */ 9475 0 /* xShadowName */ 9476 }; 9477 9478 int rc = sqlite3_create_module(db, "sqlite_dbdata", &dbdata_module, 0); 9479 if( rc==SQLITE_OK ){ 9480 rc = sqlite3_create_module(db, "sqlite_dbptr", &dbdata_module, (void*)1); 9481 } 9482 return rc; 9483 } 9484 9485 #ifdef _WIN32 9486 9487 #endif 9488 int sqlite3_dbdata_init( 9489 sqlite3 *db, 9490 char **pzErrMsg, 9491 const sqlite3_api_routines *pApi 9492 ){ 9493 SQLITE_EXTENSION_INIT2(pApi); 9494 return sqlite3DbdataRegister(db); 9495 } 9496 9497 /************************* End ../ext/misc/dbdata.c ********************/ 9498 #endif 9499 9500 #if defined(SQLITE_ENABLE_SESSION) 9501 /* 9502 ** State information for a single open session 9503 */ 9504 typedef struct OpenSession OpenSession; 9505 struct OpenSession { 9506 char *zName; /* Symbolic name for this session */ 9507 int nFilter; /* Number of xFilter rejection GLOB patterns */ 9508 char **azFilter; /* Array of xFilter rejection GLOB patterns */ 9509 sqlite3_session *p; /* The open session */ 9510 }; 9511 #endif 9512 9513 /* 9514 ** Shell output mode information from before ".explain on", 9515 ** saved so that it can be restored by ".explain off" 9516 */ 9517 typedef struct SavedModeInfo SavedModeInfo; 9518 struct SavedModeInfo { 9519 int valid; /* Is there legit data in here? */ 9520 int mode; /* Mode prior to ".explain on" */ 9521 int showHeader; /* The ".header" setting prior to ".explain on" */ 9522 int colWidth[100]; /* Column widths prior to ".explain on" */ 9523 }; 9524 9525 typedef struct ExpertInfo ExpertInfo; 9526 struct ExpertInfo { 9527 sqlite3expert *pExpert; 9528 int bVerbose; 9529 }; 9530 9531 /* A single line in the EQP output */ 9532 typedef struct EQPGraphRow EQPGraphRow; 9533 struct EQPGraphRow { 9534 int iEqpId; /* ID for this row */ 9535 int iParentId; /* ID of the parent row */ 9536 EQPGraphRow *pNext; /* Next row in sequence */ 9537 char zText[1]; /* Text to display for this row */ 9538 }; 9539 9540 /* All EQP output is collected into an instance of the following */ 9541 typedef struct EQPGraph EQPGraph; 9542 struct EQPGraph { 9543 EQPGraphRow *pRow; /* Linked list of all rows of the EQP output */ 9544 EQPGraphRow *pLast; /* Last element of the pRow list */ 9545 char zPrefix[100]; /* Graph prefix */ 9546 }; 9547 9548 /* 9549 ** State information about the database connection is contained in an 9550 ** instance of the following structure. 9551 */ 9552 typedef struct ShellState ShellState; 9553 struct ShellState { 9554 sqlite3 *db; /* The database */ 9555 u8 autoExplain; /* Automatically turn on .explain mode */ 9556 u8 autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */ 9557 u8 autoEQPtest; /* autoEQP is in test mode */ 9558 u8 autoEQPtrace; /* autoEQP is in trace mode */ 9559 u8 statsOn; /* True to display memory stats before each finalize */ 9560 u8 scanstatsOn; /* True to display scan stats before each finalize */ 9561 u8 openMode; /* SHELL_OPEN_NORMAL, _APPENDVFS, or _ZIPFILE */ 9562 u8 doXdgOpen; /* Invoke start/open/xdg-open in output_reset() */ 9563 u8 nEqpLevel; /* Depth of the EQP output graph */ 9564 u8 eTraceType; /* SHELL_TRACE_* value for type of trace */ 9565 unsigned mEqpLines; /* Mask of veritical lines in the EQP output graph */ 9566 int outCount; /* Revert to stdout when reaching zero */ 9567 int cnt; /* Number of records displayed so far */ 9568 int lineno; /* Line number of last line read from in */ 9569 FILE *in; /* Read commands from this stream */ 9570 FILE *out; /* Write results here */ 9571 FILE *traceOut; /* Output for sqlite3_trace() */ 9572 int nErr; /* Number of errors seen */ 9573 int mode; /* An output mode setting */ 9574 int modePrior; /* Saved mode */ 9575 int cMode; /* temporary output mode for the current query */ 9576 int normalMode; /* Output mode before ".explain on" */ 9577 int writableSchema; /* True if PRAGMA writable_schema=ON */ 9578 int showHeader; /* True to show column names in List or Column mode */ 9579 int nCheck; /* Number of ".check" commands run */ 9580 unsigned nProgress; /* Number of progress callbacks encountered */ 9581 unsigned mxProgress; /* Maximum progress callbacks before failing */ 9582 unsigned flgProgress; /* Flags for the progress callback */ 9583 unsigned shellFlgs; /* Various flags */ 9584 sqlite3_int64 szMax; /* --maxsize argument to .open */ 9585 char *zDestTable; /* Name of destination table when MODE_Insert */ 9586 char *zTempFile; /* Temporary file that might need deleting */ 9587 char zTestcase[30]; /* Name of current test case */ 9588 char colSeparator[20]; /* Column separator character for several modes */ 9589 char rowSeparator[20]; /* Row separator character for MODE_Ascii */ 9590 char colSepPrior[20]; /* Saved column separator */ 9591 char rowSepPrior[20]; /* Saved row separator */ 9592 int colWidth[100]; /* Requested width of each column when in column mode*/ 9593 int actualWidth[100]; /* Actual width of each column */ 9594 char nullValue[20]; /* The text to print when a NULL comes back from 9595 ** the database */ 9596 char outfile[FILENAME_MAX]; /* Filename for *out */ 9597 const char *zDbFilename; /* name of the database file */ 9598 char *zFreeOnClose; /* Filename to free when closing */ 9599 const char *zVfs; /* Name of VFS to use */ 9600 sqlite3_stmt *pStmt; /* Current statement if any. */ 9601 FILE *pLog; /* Write log output here */ 9602 int *aiIndent; /* Array of indents used in MODE_Explain */ 9603 int nIndent; /* Size of array aiIndent[] */ 9604 int iIndent; /* Index of current op in aiIndent[] */ 9605 EQPGraph sGraph; /* Information for the graphical EXPLAIN QUERY PLAN */ 9606 #if defined(SQLITE_ENABLE_SESSION) 9607 int nSession; /* Number of active sessions */ 9608 OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */ 9609 #endif 9610 ExpertInfo expert; /* Valid if previous command was ".expert OPT..." */ 9611 }; 9612 9613 9614 /* Allowed values for ShellState.autoEQP 9615 */ 9616 #define AUTOEQP_off 0 /* Automatic EXPLAIN QUERY PLAN is off */ 9617 #define AUTOEQP_on 1 /* Automatic EQP is on */ 9618 #define AUTOEQP_trigger 2 /* On and also show plans for triggers */ 9619 #define AUTOEQP_full 3 /* Show full EXPLAIN */ 9620 9621 /* Allowed values for ShellState.openMode 9622 */ 9623 #define SHELL_OPEN_UNSPEC 0 /* No open-mode specified */ 9624 #define SHELL_OPEN_NORMAL 1 /* Normal database file */ 9625 #define SHELL_OPEN_APPENDVFS 2 /* Use appendvfs */ 9626 #define SHELL_OPEN_ZIPFILE 3 /* Use the zipfile virtual table */ 9627 #define SHELL_OPEN_READONLY 4 /* Open a normal database read-only */ 9628 #define SHELL_OPEN_DESERIALIZE 5 /* Open using sqlite3_deserialize() */ 9629 #define SHELL_OPEN_HEXDB 6 /* Use "dbtotxt" output as data source */ 9630 9631 /* Allowed values for ShellState.eTraceType 9632 */ 9633 #define SHELL_TRACE_PLAIN 0 /* Show input SQL text */ 9634 #define SHELL_TRACE_EXPANDED 1 /* Show expanded SQL text */ 9635 #define SHELL_TRACE_NORMALIZED 2 /* Show normalized SQL text */ 9636 9637 /* Bits in the ShellState.flgProgress variable */ 9638 #define SHELL_PROGRESS_QUIET 0x01 /* Omit announcing every progress callback */ 9639 #define SHELL_PROGRESS_RESET 0x02 /* Reset the count when the progres 9640 ** callback limit is reached, and for each 9641 ** top-level SQL statement */ 9642 #define SHELL_PROGRESS_ONCE 0x04 /* Cancel the --limit after firing once */ 9643 9644 /* 9645 ** These are the allowed shellFlgs values 9646 */ 9647 #define SHFLG_Pagecache 0x00000001 /* The --pagecache option is used */ 9648 #define SHFLG_Lookaside 0x00000002 /* Lookaside memory is used */ 9649 #define SHFLG_Backslash 0x00000004 /* The --backslash option is used */ 9650 #define SHFLG_PreserveRowid 0x00000008 /* .dump preserves rowid values */ 9651 #define SHFLG_Newlines 0x00000010 /* .dump --newline flag */ 9652 #define SHFLG_CountChanges 0x00000020 /* .changes setting */ 9653 #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */ 9654 9655 /* 9656 ** Macros for testing and setting shellFlgs 9657 */ 9658 #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0) 9659 #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X)) 9660 #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X))) 9661 9662 /* 9663 ** These are the allowed modes. 9664 */ 9665 #define MODE_Line 0 /* One column per line. Blank line between records */ 9666 #define MODE_Column 1 /* One record per line in neat columns */ 9667 #define MODE_List 2 /* One record per line with a separator */ 9668 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ 9669 #define MODE_Html 4 /* Generate an XHTML table */ 9670 #define MODE_Insert 5 /* Generate SQL "insert" statements */ 9671 #define MODE_Quote 6 /* Quote values as for SQL */ 9672 #define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */ 9673 #define MODE_Csv 8 /* Quote strings, numbers are plain */ 9674 #define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */ 9675 #define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */ 9676 #define MODE_Pretty 11 /* Pretty-print schemas */ 9677 #define MODE_EQP 12 /* Converts EXPLAIN QUERY PLAN output into a graph */ 9678 9679 static const char *modeDescr[] = { 9680 "line", 9681 "column", 9682 "list", 9683 "semi", 9684 "html", 9685 "insert", 9686 "quote", 9687 "tcl", 9688 "csv", 9689 "explain", 9690 "ascii", 9691 "prettyprint", 9692 "eqp" 9693 }; 9694 9695 /* 9696 ** These are the column/row/line separators used by the various 9697 ** import/export modes. 9698 */ 9699 #define SEP_Column "|" 9700 #define SEP_Row "\n" 9701 #define SEP_Tab "\t" 9702 #define SEP_Space " " 9703 #define SEP_Comma "," 9704 #define SEP_CrLf "\r\n" 9705 #define SEP_Unit "\x1F" 9706 #define SEP_Record "\x1E" 9707 9708 /* 9709 ** A callback for the sqlite3_log() interface. 9710 */ 9711 static void shellLog(void *pArg, int iErrCode, const char *zMsg){ 9712 ShellState *p = (ShellState*)pArg; 9713 if( p->pLog==0 ) return; 9714 utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg); 9715 fflush(p->pLog); 9716 } 9717 9718 /* 9719 ** SQL function: shell_putsnl(X) 9720 ** 9721 ** Write the text X to the screen (or whatever output is being directed) 9722 ** adding a newline at the end, and then return X. 9723 */ 9724 static void shellPutsFunc( 9725 sqlite3_context *pCtx, 9726 int nVal, 9727 sqlite3_value **apVal 9728 ){ 9729 ShellState *p = (ShellState*)sqlite3_user_data(pCtx); 9730 (void)nVal; 9731 utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0])); 9732 sqlite3_result_value(pCtx, apVal[0]); 9733 } 9734 9735 /* 9736 ** SQL function: edit(VALUE) 9737 ** edit(VALUE,EDITOR) 9738 ** 9739 ** These steps: 9740 ** 9741 ** (1) Write VALUE into a temporary file. 9742 ** (2) Run program EDITOR on that temporary file. 9743 ** (3) Read the temporary file back and return its content as the result. 9744 ** (4) Delete the temporary file 9745 ** 9746 ** If the EDITOR argument is omitted, use the value in the VISUAL 9747 ** environment variable. If still there is no EDITOR, through an error. 9748 ** 9749 ** Also throw an error if the EDITOR program returns a non-zero exit code. 9750 */ 9751 #ifndef SQLITE_NOHAVE_SYSTEM 9752 static void editFunc( 9753 sqlite3_context *context, 9754 int argc, 9755 sqlite3_value **argv 9756 ){ 9757 const char *zEditor; 9758 char *zTempFile = 0; 9759 sqlite3 *db; 9760 char *zCmd = 0; 9761 int bBin; 9762 int rc; 9763 int hasCRNL = 0; 9764 FILE *f = 0; 9765 sqlite3_int64 sz; 9766 sqlite3_int64 x; 9767 unsigned char *p = 0; 9768 9769 if( argc==2 ){ 9770 zEditor = (const char*)sqlite3_value_text(argv[1]); 9771 }else{ 9772 zEditor = getenv("VISUAL"); 9773 } 9774 if( zEditor==0 ){ 9775 sqlite3_result_error(context, "no editor for edit()", -1); 9776 return; 9777 } 9778 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 9779 sqlite3_result_error(context, "NULL input to edit()", -1); 9780 return; 9781 } 9782 db = sqlite3_context_db_handle(context); 9783 zTempFile = 0; 9784 sqlite3_file_control(db, 0, SQLITE_FCNTL_TEMPFILENAME, &zTempFile); 9785 if( zTempFile==0 ){ 9786 sqlite3_uint64 r = 0; 9787 sqlite3_randomness(sizeof(r), &r); 9788 zTempFile = sqlite3_mprintf("temp%llx", r); 9789 if( zTempFile==0 ){ 9790 sqlite3_result_error_nomem(context); 9791 return; 9792 } 9793 } 9794 bBin = sqlite3_value_type(argv[0])==SQLITE_BLOB; 9795 /* When writing the file to be edited, do \n to \r\n conversions on systems 9796 ** that want \r\n line endings */ 9797 f = fopen(zTempFile, bBin ? "wb" : "w"); 9798 if( f==0 ){ 9799 sqlite3_result_error(context, "edit() cannot open temp file", -1); 9800 goto edit_func_end; 9801 } 9802 sz = sqlite3_value_bytes(argv[0]); 9803 if( bBin ){ 9804 x = fwrite(sqlite3_value_blob(argv[0]), 1, sz, f); 9805 }else{ 9806 const char *z = (const char*)sqlite3_value_text(argv[0]); 9807 /* Remember whether or not the value originally contained \r\n */ 9808 if( z && strstr(z,"\r\n")!=0 ) hasCRNL = 1; 9809 x = fwrite(sqlite3_value_text(argv[0]), 1, sz, f); 9810 } 9811 fclose(f); 9812 f = 0; 9813 if( x!=sz ){ 9814 sqlite3_result_error(context, "edit() could not write the whole file", -1); 9815 goto edit_func_end; 9816 } 9817 zCmd = sqlite3_mprintf("%s \"%s\"", zEditor, zTempFile); 9818 if( zCmd==0 ){ 9819 sqlite3_result_error_nomem(context); 9820 goto edit_func_end; 9821 } 9822 rc = system(zCmd); 9823 sqlite3_free(zCmd); 9824 if( rc ){ 9825 sqlite3_result_error(context, "EDITOR returned non-zero", -1); 9826 goto edit_func_end; 9827 } 9828 f = fopen(zTempFile, "rb"); 9829 if( f==0 ){ 9830 sqlite3_result_error(context, 9831 "edit() cannot reopen temp file after edit", -1); 9832 goto edit_func_end; 9833 } 9834 fseek(f, 0, SEEK_END); 9835 sz = ftell(f); 9836 rewind(f); 9837 p = sqlite3_malloc64( sz+(bBin==0) ); 9838 if( p==0 ){ 9839 sqlite3_result_error_nomem(context); 9840 goto edit_func_end; 9841 } 9842 x = fread(p, 1, sz, f); 9843 fclose(f); 9844 f = 0; 9845 if( x!=sz ){ 9846 sqlite3_result_error(context, "could not read back the whole file", -1); 9847 goto edit_func_end; 9848 } 9849 if( bBin ){ 9850 sqlite3_result_blob64(context, p, sz, sqlite3_free); 9851 }else{ 9852 sqlite3_int64 i, j; 9853 if( hasCRNL ){ 9854 /* If the original contains \r\n then do no conversions back to \n */ 9855 j = sz; 9856 }else{ 9857 /* If the file did not originally contain \r\n then convert any new 9858 ** \r\n back into \n */ 9859 for(i=j=0; i<sz; i++){ 9860 if( p[i]=='\r' && p[i+1]=='\n' ) i++; 9861 p[j++] = p[i]; 9862 } 9863 sz = j; 9864 p[sz] = 0; 9865 } 9866 sqlite3_result_text64(context, (const char*)p, sz, 9867 sqlite3_free, SQLITE_UTF8); 9868 } 9869 p = 0; 9870 9871 edit_func_end: 9872 if( f ) fclose(f); 9873 unlink(zTempFile); 9874 sqlite3_free(zTempFile); 9875 sqlite3_free(p); 9876 } 9877 #endif /* SQLITE_NOHAVE_SYSTEM */ 9878 9879 /* 9880 ** Save or restore the current output mode 9881 */ 9882 static void outputModePush(ShellState *p){ 9883 p->modePrior = p->mode; 9884 memcpy(p->colSepPrior, p->colSeparator, sizeof(p->colSeparator)); 9885 memcpy(p->rowSepPrior, p->rowSeparator, sizeof(p->rowSeparator)); 9886 } 9887 static void outputModePop(ShellState *p){ 9888 p->mode = p->modePrior; 9889 memcpy(p->colSeparator, p->colSepPrior, sizeof(p->colSeparator)); 9890 memcpy(p->rowSeparator, p->rowSepPrior, sizeof(p->rowSeparator)); 9891 } 9892 9893 /* 9894 ** Output the given string as a hex-encoded blob (eg. X'1234' ) 9895 */ 9896 static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ 9897 int i; 9898 char *zBlob = (char *)pBlob; 9899 raw_printf(out,"X'"); 9900 for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); } 9901 raw_printf(out,"'"); 9902 } 9903 9904 /* 9905 ** Find a string that is not found anywhere in z[]. Return a pointer 9906 ** to that string. 9907 ** 9908 ** Try to use zA and zB first. If both of those are already found in z[] 9909 ** then make up some string and store it in the buffer zBuf. 9910 */ 9911 static const char *unused_string( 9912 const char *z, /* Result must not appear anywhere in z */ 9913 const char *zA, const char *zB, /* Try these first */ 9914 char *zBuf /* Space to store a generated string */ 9915 ){ 9916 unsigned i = 0; 9917 if( strstr(z, zA)==0 ) return zA; 9918 if( strstr(z, zB)==0 ) return zB; 9919 do{ 9920 sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++); 9921 }while( strstr(z,zBuf)!=0 ); 9922 return zBuf; 9923 } 9924 9925 /* 9926 ** Output the given string as a quoted string using SQL quoting conventions. 9927 ** 9928 ** See also: output_quoted_escaped_string() 9929 */ 9930 static void output_quoted_string(FILE *out, const char *z){ 9931 int i; 9932 char c; 9933 setBinaryMode(out, 1); 9934 for(i=0; (c = z[i])!=0 && c!='\''; i++){} 9935 if( c==0 ){ 9936 utf8_printf(out,"'%s'",z); 9937 }else{ 9938 raw_printf(out, "'"); 9939 while( *z ){ 9940 for(i=0; (c = z[i])!=0 && c!='\''; i++){} 9941 if( c=='\'' ) i++; 9942 if( i ){ 9943 utf8_printf(out, "%.*s", i, z); 9944 z += i; 9945 } 9946 if( c=='\'' ){ 9947 raw_printf(out, "'"); 9948 continue; 9949 } 9950 if( c==0 ){ 9951 break; 9952 } 9953 z++; 9954 } 9955 raw_printf(out, "'"); 9956 } 9957 setTextMode(out, 1); 9958 } 9959 9960 /* 9961 ** Output the given string as a quoted string using SQL quoting conventions. 9962 ** Additionallly , escape the "\n" and "\r" characters so that they do not 9963 ** get corrupted by end-of-line translation facilities in some operating 9964 ** systems. 9965 ** 9966 ** This is like output_quoted_string() but with the addition of the \r\n 9967 ** escape mechanism. 9968 */ 9969 static void output_quoted_escaped_string(FILE *out, const char *z){ 9970 int i; 9971 char c; 9972 setBinaryMode(out, 1); 9973 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){} 9974 if( c==0 ){ 9975 utf8_printf(out,"'%s'",z); 9976 }else{ 9977 const char *zNL = 0; 9978 const char *zCR = 0; 9979 int nNL = 0; 9980 int nCR = 0; 9981 char zBuf1[20], zBuf2[20]; 9982 for(i=0; z[i]; i++){ 9983 if( z[i]=='\n' ) nNL++; 9984 if( z[i]=='\r' ) nCR++; 9985 } 9986 if( nNL ){ 9987 raw_printf(out, "replace("); 9988 zNL = unused_string(z, "\\n", "\\012", zBuf1); 9989 } 9990 if( nCR ){ 9991 raw_printf(out, "replace("); 9992 zCR = unused_string(z, "\\r", "\\015", zBuf2); 9993 } 9994 raw_printf(out, "'"); 9995 while( *z ){ 9996 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){} 9997 if( c=='\'' ) i++; 9998 if( i ){ 9999 utf8_printf(out, "%.*s", i, z); 10000 z += i; 10001 } 10002 if( c=='\'' ){ 10003 raw_printf(out, "'"); 10004 continue; 10005 } 10006 if( c==0 ){ 10007 break; 10008 } 10009 z++; 10010 if( c=='\n' ){ 10011 raw_printf(out, "%s", zNL); 10012 continue; 10013 } 10014 raw_printf(out, "%s", zCR); 10015 } 10016 raw_printf(out, "'"); 10017 if( nCR ){ 10018 raw_printf(out, ",'%s',char(13))", zCR); 10019 } 10020 if( nNL ){ 10021 raw_printf(out, ",'%s',char(10))", zNL); 10022 } 10023 } 10024 setTextMode(out, 1); 10025 } 10026 10027 /* 10028 ** Output the given string as a quoted according to C or TCL quoting rules. 10029 */ 10030 static void output_c_string(FILE *out, const char *z){ 10031 unsigned int c; 10032 fputc('"', out); 10033 while( (c = *(z++))!=0 ){ 10034 if( c=='\\' ){ 10035 fputc(c, out); 10036 fputc(c, out); 10037 }else if( c=='"' ){ 10038 fputc('\\', out); 10039 fputc('"', out); 10040 }else if( c=='\t' ){ 10041 fputc('\\', out); 10042 fputc('t', out); 10043 }else if( c=='\n' ){ 10044 fputc('\\', out); 10045 fputc('n', out); 10046 }else if( c=='\r' ){ 10047 fputc('\\', out); 10048 fputc('r', out); 10049 }else if( !isprint(c&0xff) ){ 10050 raw_printf(out, "\\%03o", c&0xff); 10051 }else{ 10052 fputc(c, out); 10053 } 10054 } 10055 fputc('"', out); 10056 } 10057 10058 /* 10059 ** Output the given string with characters that are special to 10060 ** HTML escaped. 10061 */ 10062 static void output_html_string(FILE *out, const char *z){ 10063 int i; 10064 if( z==0 ) z = ""; 10065 while( *z ){ 10066 for(i=0; z[i] 10067 && z[i]!='<' 10068 && z[i]!='&' 10069 && z[i]!='>' 10070 && z[i]!='\"' 10071 && z[i]!='\''; 10072 i++){} 10073 if( i>0 ){ 10074 utf8_printf(out,"%.*s",i,z); 10075 } 10076 if( z[i]=='<' ){ 10077 raw_printf(out,"<"); 10078 }else if( z[i]=='&' ){ 10079 raw_printf(out,"&"); 10080 }else if( z[i]=='>' ){ 10081 raw_printf(out,">"); 10082 }else if( z[i]=='\"' ){ 10083 raw_printf(out,"""); 10084 }else if( z[i]=='\'' ){ 10085 raw_printf(out,"'"); 10086 }else{ 10087 break; 10088 } 10089 z += i + 1; 10090 } 10091 } 10092 10093 /* 10094 ** If a field contains any character identified by a 1 in the following 10095 ** array, then the string must be quoted for CSV. 10096 */ 10097 static const char needCsvQuote[] = { 10098 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10099 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10100 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 10106 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10107 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10109 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10110 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10113 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10114 }; 10115 10116 /* 10117 ** Output a single term of CSV. Actually, p->colSeparator is used for 10118 ** the separator, which may or may not be a comma. p->nullValue is 10119 ** the null value. Strings are quoted if necessary. The separator 10120 ** is only issued if bSep is true. 10121 */ 10122 static void output_csv(ShellState *p, const char *z, int bSep){ 10123 FILE *out = p->out; 10124 if( z==0 ){ 10125 utf8_printf(out,"%s",p->nullValue); 10126 }else{ 10127 int i; 10128 int nSep = strlen30(p->colSeparator); 10129 for(i=0; z[i]; i++){ 10130 if( needCsvQuote[((unsigned char*)z)[i]] 10131 || (z[i]==p->colSeparator[0] && 10132 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){ 10133 i = 0; 10134 break; 10135 } 10136 } 10137 if( i==0 ){ 10138 char *zQuoted = sqlite3_mprintf("\"%w\"", z); 10139 utf8_printf(out, "%s", zQuoted); 10140 sqlite3_free(zQuoted); 10141 }else{ 10142 utf8_printf(out, "%s", z); 10143 } 10144 } 10145 if( bSep ){ 10146 utf8_printf(p->out, "%s", p->colSeparator); 10147 } 10148 } 10149 10150 /* 10151 ** This routine runs when the user presses Ctrl-C 10152 */ 10153 static void interrupt_handler(int NotUsed){ 10154 UNUSED_PARAMETER(NotUsed); 10155 seenInterrupt++; 10156 if( seenInterrupt>2 ) exit(1); 10157 if( globalDb ) sqlite3_interrupt(globalDb); 10158 } 10159 10160 #if (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 10161 /* 10162 ** This routine runs for console events (e.g. Ctrl-C) on Win32 10163 */ 10164 static BOOL WINAPI ConsoleCtrlHandler( 10165 DWORD dwCtrlType /* One of the CTRL_*_EVENT constants */ 10166 ){ 10167 if( dwCtrlType==CTRL_C_EVENT ){ 10168 interrupt_handler(0); 10169 return TRUE; 10170 } 10171 return FALSE; 10172 } 10173 #endif 10174 10175 #ifndef SQLITE_OMIT_AUTHORIZATION 10176 /* 10177 ** When the ".auth ON" is set, the following authorizer callback is 10178 ** invoked. It always returns SQLITE_OK. 10179 */ 10180 static int shellAuth( 10181 void *pClientData, 10182 int op, 10183 const char *zA1, 10184 const char *zA2, 10185 const char *zA3, 10186 const char *zA4 10187 ){ 10188 ShellState *p = (ShellState*)pClientData; 10189 static const char *azAction[] = { 0, 10190 "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX", 10191 "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW", 10192 "CREATE_TRIGGER", "CREATE_VIEW", "DELETE", 10193 "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX", 10194 "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW", 10195 "DROP_TRIGGER", "DROP_VIEW", "INSERT", 10196 "PRAGMA", "READ", "SELECT", 10197 "TRANSACTION", "UPDATE", "ATTACH", 10198 "DETACH", "ALTER_TABLE", "REINDEX", 10199 "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE", 10200 "FUNCTION", "SAVEPOINT", "RECURSIVE" 10201 }; 10202 int i; 10203 const char *az[4]; 10204 az[0] = zA1; 10205 az[1] = zA2; 10206 az[2] = zA3; 10207 az[3] = zA4; 10208 utf8_printf(p->out, "authorizer: %s", azAction[op]); 10209 for(i=0; i<4; i++){ 10210 raw_printf(p->out, " "); 10211 if( az[i] ){ 10212 output_c_string(p->out, az[i]); 10213 }else{ 10214 raw_printf(p->out, "NULL"); 10215 } 10216 } 10217 raw_printf(p->out, "\n"); 10218 return SQLITE_OK; 10219 } 10220 #endif 10221 10222 /* 10223 ** Print a schema statement. Part of MODE_Semi and MODE_Pretty output. 10224 ** 10225 ** This routine converts some CREATE TABLE statements for shadow tables 10226 ** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements. 10227 */ 10228 static void printSchemaLine(FILE *out, const char *z, const char *zTail){ 10229 if( z==0 ) return; 10230 if( zTail==0 ) return; 10231 if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){ 10232 utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail); 10233 }else{ 10234 utf8_printf(out, "%s%s", z, zTail); 10235 } 10236 } 10237 static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){ 10238 char c = z[n]; 10239 z[n] = 0; 10240 printSchemaLine(out, z, zTail); 10241 z[n] = c; 10242 } 10243 10244 /* 10245 ** Return true if string z[] has nothing but whitespace and comments to the 10246 ** end of the first line. 10247 */ 10248 static int wsToEol(const char *z){ 10249 int i; 10250 for(i=0; z[i]; i++){ 10251 if( z[i]=='\n' ) return 1; 10252 if( IsSpace(z[i]) ) continue; 10253 if( z[i]=='-' && z[i+1]=='-' ) return 1; 10254 return 0; 10255 } 10256 return 1; 10257 } 10258 10259 /* 10260 ** Add a new entry to the EXPLAIN QUERY PLAN data 10261 */ 10262 static void eqp_append(ShellState *p, int iEqpId, int p2, const char *zText){ 10263 EQPGraphRow *pNew; 10264 int nText = strlen30(zText); 10265 if( p->autoEQPtest ){ 10266 utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText); 10267 } 10268 pNew = sqlite3_malloc64( sizeof(*pNew) + nText ); 10269 if( pNew==0 ) shell_out_of_memory(); 10270 pNew->iEqpId = iEqpId; 10271 pNew->iParentId = p2; 10272 memcpy(pNew->zText, zText, nText+1); 10273 pNew->pNext = 0; 10274 if( p->sGraph.pLast ){ 10275 p->sGraph.pLast->pNext = pNew; 10276 }else{ 10277 p->sGraph.pRow = pNew; 10278 } 10279 p->sGraph.pLast = pNew; 10280 } 10281 10282 /* 10283 ** Free and reset the EXPLAIN QUERY PLAN data that has been collected 10284 ** in p->sGraph. 10285 */ 10286 static void eqp_reset(ShellState *p){ 10287 EQPGraphRow *pRow, *pNext; 10288 for(pRow = p->sGraph.pRow; pRow; pRow = pNext){ 10289 pNext = pRow->pNext; 10290 sqlite3_free(pRow); 10291 } 10292 memset(&p->sGraph, 0, sizeof(p->sGraph)); 10293 } 10294 10295 /* Return the next EXPLAIN QUERY PLAN line with iEqpId that occurs after 10296 ** pOld, or return the first such line if pOld is NULL 10297 */ 10298 static EQPGraphRow *eqp_next_row(ShellState *p, int iEqpId, EQPGraphRow *pOld){ 10299 EQPGraphRow *pRow = pOld ? pOld->pNext : p->sGraph.pRow; 10300 while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext; 10301 return pRow; 10302 } 10303 10304 /* Render a single level of the graph that has iEqpId as its parent. Called 10305 ** recursively to render sublevels. 10306 */ 10307 static void eqp_render_level(ShellState *p, int iEqpId){ 10308 EQPGraphRow *pRow, *pNext; 10309 int n = strlen30(p->sGraph.zPrefix); 10310 char *z; 10311 for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){ 10312 pNext = eqp_next_row(p, iEqpId, pRow); 10313 z = pRow->zText; 10314 utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix, pNext ? "|--" : "`--", z); 10315 if( n<(int)sizeof(p->sGraph.zPrefix)-7 ){ 10316 memcpy(&p->sGraph.zPrefix[n], pNext ? "| " : " ", 4); 10317 eqp_render_level(p, pRow->iEqpId); 10318 p->sGraph.zPrefix[n] = 0; 10319 } 10320 } 10321 } 10322 10323 /* 10324 ** Display and reset the EXPLAIN QUERY PLAN data 10325 */ 10326 static void eqp_render(ShellState *p){ 10327 EQPGraphRow *pRow = p->sGraph.pRow; 10328 if( pRow ){ 10329 if( pRow->zText[0]=='-' ){ 10330 if( pRow->pNext==0 ){ 10331 eqp_reset(p); 10332 return; 10333 } 10334 utf8_printf(p->out, "%s\n", pRow->zText+3); 10335 p->sGraph.pRow = pRow->pNext; 10336 sqlite3_free(pRow); 10337 }else{ 10338 utf8_printf(p->out, "QUERY PLAN\n"); 10339 } 10340 p->sGraph.zPrefix[0] = 0; 10341 eqp_render_level(p, 0); 10342 eqp_reset(p); 10343 } 10344 } 10345 10346 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 10347 /* 10348 ** Progress handler callback. 10349 */ 10350 static int progress_handler(void *pClientData) { 10351 ShellState *p = (ShellState*)pClientData; 10352 p->nProgress++; 10353 if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){ 10354 raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress); 10355 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 10356 if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0; 10357 return 1; 10358 } 10359 if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){ 10360 raw_printf(p->out, "Progress %u\n", p->nProgress); 10361 } 10362 return 0; 10363 } 10364 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 10365 10366 /* 10367 ** This is the callback routine that the shell 10368 ** invokes for each row of a query result. 10369 */ 10370 static int shell_callback( 10371 void *pArg, 10372 int nArg, /* Number of result columns */ 10373 char **azArg, /* Text of each result column */ 10374 char **azCol, /* Column names */ 10375 int *aiType /* Column types */ 10376 ){ 10377 int i; 10378 ShellState *p = (ShellState*)pArg; 10379 10380 if( azArg==0 ) return 0; 10381 switch( p->cMode ){ 10382 case MODE_Line: { 10383 int w = 5; 10384 if( azArg==0 ) break; 10385 for(i=0; i<nArg; i++){ 10386 int len = strlen30(azCol[i] ? azCol[i] : ""); 10387 if( len>w ) w = len; 10388 } 10389 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator); 10390 for(i=0; i<nArg; i++){ 10391 utf8_printf(p->out,"%*s = %s%s", w, azCol[i], 10392 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator); 10393 } 10394 break; 10395 } 10396 case MODE_Explain: 10397 case MODE_Column: { 10398 static const int aExplainWidths[] = {4, 13, 4, 4, 4, 13, 2, 13}; 10399 const int *colWidth; 10400 int showHdr; 10401 char *rowSep; 10402 if( p->cMode==MODE_Column ){ 10403 colWidth = p->colWidth; 10404 showHdr = p->showHeader; 10405 rowSep = p->rowSeparator; 10406 }else{ 10407 colWidth = aExplainWidths; 10408 showHdr = 1; 10409 rowSep = SEP_Row; 10410 } 10411 if( p->cnt++==0 ){ 10412 for(i=0; i<nArg; i++){ 10413 int w, n; 10414 if( i<ArraySize(p->colWidth) ){ 10415 w = colWidth[i]; 10416 }else{ 10417 w = 0; 10418 } 10419 if( w==0 ){ 10420 w = strlenChar(azCol[i] ? azCol[i] : ""); 10421 if( w<10 ) w = 10; 10422 n = strlenChar(azArg && azArg[i] ? azArg[i] : p->nullValue); 10423 if( w<n ) w = n; 10424 } 10425 if( i<ArraySize(p->actualWidth) ){ 10426 p->actualWidth[i] = w; 10427 } 10428 if( showHdr ){ 10429 utf8_width_print(p->out, w, azCol[i]); 10430 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " "); 10431 } 10432 } 10433 if( showHdr ){ 10434 for(i=0; i<nArg; i++){ 10435 int w; 10436 if( i<ArraySize(p->actualWidth) ){ 10437 w = p->actualWidth[i]; 10438 if( w<0 ) w = -w; 10439 }else{ 10440 w = 10; 10441 } 10442 utf8_printf(p->out,"%-*.*s%s",w,w, 10443 "----------------------------------------------------------" 10444 "----------------------------------------------------------", 10445 i==nArg-1 ? rowSep : " "); 10446 } 10447 } 10448 } 10449 if( azArg==0 ) break; 10450 for(i=0; i<nArg; i++){ 10451 int w; 10452 if( i<ArraySize(p->actualWidth) ){ 10453 w = p->actualWidth[i]; 10454 }else{ 10455 w = 10; 10456 } 10457 if( p->cMode==MODE_Explain && azArg[i] && strlenChar(azArg[i])>w ){ 10458 w = strlenChar(azArg[i]); 10459 } 10460 if( i==1 && p->aiIndent && p->pStmt ){ 10461 if( p->iIndent<p->nIndent ){ 10462 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], ""); 10463 } 10464 p->iIndent++; 10465 } 10466 utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue); 10467 utf8_printf(p->out, "%s", i==nArg-1 ? rowSep : " "); 10468 } 10469 break; 10470 } 10471 case MODE_Semi: { /* .schema and .fullschema output */ 10472 printSchemaLine(p->out, azArg[0], ";\n"); 10473 break; 10474 } 10475 case MODE_Pretty: { /* .schema and .fullschema with --indent */ 10476 char *z; 10477 int j; 10478 int nParen = 0; 10479 char cEnd = 0; 10480 char c; 10481 int nLine = 0; 10482 assert( nArg==1 ); 10483 if( azArg[0]==0 ) break; 10484 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0 10485 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0 10486 ){ 10487 utf8_printf(p->out, "%s;\n", azArg[0]); 10488 break; 10489 } 10490 z = sqlite3_mprintf("%s", azArg[0]); 10491 j = 0; 10492 for(i=0; IsSpace(z[i]); i++){} 10493 for(; (c = z[i])!=0; i++){ 10494 if( IsSpace(c) ){ 10495 if( z[j-1]=='\r' ) z[j-1] = '\n'; 10496 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue; 10497 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){ 10498 j--; 10499 } 10500 z[j++] = c; 10501 } 10502 while( j>0 && IsSpace(z[j-1]) ){ j--; } 10503 z[j] = 0; 10504 if( strlen30(z)>=79 ){ 10505 for(i=j=0; (c = z[i])!=0; i++){ /* Copy changes from z[i] back to z[j] */ 10506 if( c==cEnd ){ 10507 cEnd = 0; 10508 }else if( c=='"' || c=='\'' || c=='`' ){ 10509 cEnd = c; 10510 }else if( c=='[' ){ 10511 cEnd = ']'; 10512 }else if( c=='-' && z[i+1]=='-' ){ 10513 cEnd = '\n'; 10514 }else if( c=='(' ){ 10515 nParen++; 10516 }else if( c==')' ){ 10517 nParen--; 10518 if( nLine>0 && nParen==0 && j>0 ){ 10519 printSchemaLineN(p->out, z, j, "\n"); 10520 j = 0; 10521 } 10522 } 10523 z[j++] = c; 10524 if( nParen==1 && cEnd==0 10525 && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1))) 10526 ){ 10527 if( c=='\n' ) j--; 10528 printSchemaLineN(p->out, z, j, "\n "); 10529 j = 0; 10530 nLine++; 10531 while( IsSpace(z[i+1]) ){ i++; } 10532 } 10533 } 10534 z[j] = 0; 10535 } 10536 printSchemaLine(p->out, z, ";\n"); 10537 sqlite3_free(z); 10538 break; 10539 } 10540 case MODE_List: { 10541 if( p->cnt++==0 && p->showHeader ){ 10542 for(i=0; i<nArg; i++){ 10543 utf8_printf(p->out,"%s%s",azCol[i], 10544 i==nArg-1 ? p->rowSeparator : p->colSeparator); 10545 } 10546 } 10547 if( azArg==0 ) break; 10548 for(i=0; i<nArg; i++){ 10549 char *z = azArg[i]; 10550 if( z==0 ) z = p->nullValue; 10551 utf8_printf(p->out, "%s", z); 10552 if( i<nArg-1 ){ 10553 utf8_printf(p->out, "%s", p->colSeparator); 10554 }else{ 10555 utf8_printf(p->out, "%s", p->rowSeparator); 10556 } 10557 } 10558 break; 10559 } 10560 case MODE_Html: { 10561 if( p->cnt++==0 && p->showHeader ){ 10562 raw_printf(p->out,"<TR>"); 10563 for(i=0; i<nArg; i++){ 10564 raw_printf(p->out,"<TH>"); 10565 output_html_string(p->out, azCol[i]); 10566 raw_printf(p->out,"</TH>\n"); 10567 } 10568 raw_printf(p->out,"</TR>\n"); 10569 } 10570 if( azArg==0 ) break; 10571 raw_printf(p->out,"<TR>"); 10572 for(i=0; i<nArg; i++){ 10573 raw_printf(p->out,"<TD>"); 10574 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 10575 raw_printf(p->out,"</TD>\n"); 10576 } 10577 raw_printf(p->out,"</TR>\n"); 10578 break; 10579 } 10580 case MODE_Tcl: { 10581 if( p->cnt++==0 && p->showHeader ){ 10582 for(i=0; i<nArg; i++){ 10583 output_c_string(p->out,azCol[i] ? azCol[i] : ""); 10584 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 10585 } 10586 utf8_printf(p->out, "%s", p->rowSeparator); 10587 } 10588 if( azArg==0 ) break; 10589 for(i=0; i<nArg; i++){ 10590 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 10591 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 10592 } 10593 utf8_printf(p->out, "%s", p->rowSeparator); 10594 break; 10595 } 10596 case MODE_Csv: { 10597 setBinaryMode(p->out, 1); 10598 if( p->cnt++==0 && p->showHeader ){ 10599 for(i=0; i<nArg; i++){ 10600 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1); 10601 } 10602 utf8_printf(p->out, "%s", p->rowSeparator); 10603 } 10604 if( nArg>0 ){ 10605 for(i=0; i<nArg; i++){ 10606 output_csv(p, azArg[i], i<nArg-1); 10607 } 10608 utf8_printf(p->out, "%s", p->rowSeparator); 10609 } 10610 setTextMode(p->out, 1); 10611 break; 10612 } 10613 case MODE_Insert: { 10614 if( azArg==0 ) break; 10615 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable); 10616 if( p->showHeader ){ 10617 raw_printf(p->out,"("); 10618 for(i=0; i<nArg; i++){ 10619 if( i>0 ) raw_printf(p->out, ","); 10620 if( quoteChar(azCol[i]) ){ 10621 char *z = sqlite3_mprintf("\"%w\"", azCol[i]); 10622 utf8_printf(p->out, "%s", z); 10623 sqlite3_free(z); 10624 }else{ 10625 raw_printf(p->out, "%s", azCol[i]); 10626 } 10627 } 10628 raw_printf(p->out,")"); 10629 } 10630 p->cnt++; 10631 for(i=0; i<nArg; i++){ 10632 raw_printf(p->out, i>0 ? "," : " VALUES("); 10633 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 10634 utf8_printf(p->out,"NULL"); 10635 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 10636 if( ShellHasFlag(p, SHFLG_Newlines) ){ 10637 output_quoted_string(p->out, azArg[i]); 10638 }else{ 10639 output_quoted_escaped_string(p->out, azArg[i]); 10640 } 10641 }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 10642 utf8_printf(p->out,"%s", azArg[i]); 10643 }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 10644 char z[50]; 10645 double r = sqlite3_column_double(p->pStmt, i); 10646 sqlite3_uint64 ur; 10647 memcpy(&ur,&r,sizeof(r)); 10648 if( ur==0x7ff0000000000000LL ){ 10649 raw_printf(p->out, "1e999"); 10650 }else if( ur==0xfff0000000000000LL ){ 10651 raw_printf(p->out, "-1e999"); 10652 }else{ 10653 sqlite3_snprintf(50,z,"%!.20g", r); 10654 raw_printf(p->out, "%s", z); 10655 } 10656 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 10657 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 10658 int nBlob = sqlite3_column_bytes(p->pStmt, i); 10659 output_hex_blob(p->out, pBlob, nBlob); 10660 }else if( isNumber(azArg[i], 0) ){ 10661 utf8_printf(p->out,"%s", azArg[i]); 10662 }else if( ShellHasFlag(p, SHFLG_Newlines) ){ 10663 output_quoted_string(p->out, azArg[i]); 10664 }else{ 10665 output_quoted_escaped_string(p->out, azArg[i]); 10666 } 10667 } 10668 raw_printf(p->out,");\n"); 10669 break; 10670 } 10671 case MODE_Quote: { 10672 if( azArg==0 ) break; 10673 if( p->cnt==0 && p->showHeader ){ 10674 for(i=0; i<nArg; i++){ 10675 if( i>0 ) raw_printf(p->out, ","); 10676 output_quoted_string(p->out, azCol[i]); 10677 } 10678 raw_printf(p->out,"\n"); 10679 } 10680 p->cnt++; 10681 for(i=0; i<nArg; i++){ 10682 if( i>0 ) raw_printf(p->out, ","); 10683 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 10684 utf8_printf(p->out,"NULL"); 10685 }else if( aiType && aiType[i]==SQLITE_TEXT ){ 10686 output_quoted_string(p->out, azArg[i]); 10687 }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 10688 utf8_printf(p->out,"%s", azArg[i]); 10689 }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 10690 char z[50]; 10691 double r = sqlite3_column_double(p->pStmt, i); 10692 sqlite3_snprintf(50,z,"%!.20g", r); 10693 raw_printf(p->out, "%s", z); 10694 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 10695 const void *pBlob = sqlite3_column_blob(p->pStmt, i); 10696 int nBlob = sqlite3_column_bytes(p->pStmt, i); 10697 output_hex_blob(p->out, pBlob, nBlob); 10698 }else if( isNumber(azArg[i], 0) ){ 10699 utf8_printf(p->out,"%s", azArg[i]); 10700 }else{ 10701 output_quoted_string(p->out, azArg[i]); 10702 } 10703 } 10704 raw_printf(p->out,"\n"); 10705 break; 10706 } 10707 case MODE_Ascii: { 10708 if( p->cnt++==0 && p->showHeader ){ 10709 for(i=0; i<nArg; i++){ 10710 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 10711 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : ""); 10712 } 10713 utf8_printf(p->out, "%s", p->rowSeparator); 10714 } 10715 if( azArg==0 ) break; 10716 for(i=0; i<nArg; i++){ 10717 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 10718 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue); 10719 } 10720 utf8_printf(p->out, "%s", p->rowSeparator); 10721 break; 10722 } 10723 case MODE_EQP: { 10724 eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]); 10725 break; 10726 } 10727 } 10728 return 0; 10729 } 10730 10731 /* 10732 ** This is the callback routine that the SQLite library 10733 ** invokes for each row of a query result. 10734 */ 10735 static int callback(void *pArg, int nArg, char **azArg, char **azCol){ 10736 /* since we don't have type info, call the shell_callback with a NULL value */ 10737 return shell_callback(pArg, nArg, azArg, azCol, NULL); 10738 } 10739 10740 /* 10741 ** This is the callback routine from sqlite3_exec() that appends all 10742 ** output onto the end of a ShellText object. 10743 */ 10744 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){ 10745 ShellText *p = (ShellText*)pArg; 10746 int i; 10747 UNUSED_PARAMETER(az); 10748 if( azArg==0 ) return 0; 10749 if( p->n ) appendText(p, "|", 0); 10750 for(i=0; i<nArg; i++){ 10751 if( i ) appendText(p, ",", 0); 10752 if( azArg[i] ) appendText(p, azArg[i], 0); 10753 } 10754 return 0; 10755 } 10756 10757 /* 10758 ** Generate an appropriate SELFTEST table in the main database. 10759 */ 10760 static void createSelftestTable(ShellState *p){ 10761 char *zErrMsg = 0; 10762 sqlite3_exec(p->db, 10763 "SAVEPOINT selftest_init;\n" 10764 "CREATE TABLE IF NOT EXISTS selftest(\n" 10765 " tno INTEGER PRIMARY KEY,\n" /* Test number */ 10766 " op TEXT,\n" /* Operator: memo run */ 10767 " cmd TEXT,\n" /* Command text */ 10768 " ans TEXT\n" /* Desired answer */ 10769 ");" 10770 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n" 10771 "INSERT INTO [_shell$self](rowid,op,cmd)\n" 10772 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n" 10773 " 'memo','Tests generated by --init');\n" 10774 "INSERT INTO [_shell$self]\n" 10775 " SELECT 'run',\n" 10776 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql " 10777 "FROM sqlite_master ORDER BY 2'',224))',\n" 10778 " hex(sha3_query('SELECT type,name,tbl_name,sql " 10779 "FROM sqlite_master ORDER BY 2',224));\n" 10780 "INSERT INTO [_shell$self]\n" 10781 " SELECT 'run'," 10782 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||" 10783 " printf('%w',name) || '\" NOT INDEXED'',224))',\n" 10784 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n" 10785 " FROM (\n" 10786 " SELECT name FROM sqlite_master\n" 10787 " WHERE type='table'\n" 10788 " AND name<>'selftest'\n" 10789 " AND coalesce(rootpage,0)>0\n" 10790 " )\n" 10791 " ORDER BY name;\n" 10792 "INSERT INTO [_shell$self]\n" 10793 " VALUES('run','PRAGMA integrity_check','ok');\n" 10794 "INSERT INTO selftest(tno,op,cmd,ans)" 10795 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n" 10796 "DROP TABLE [_shell$self];" 10797 ,0,0,&zErrMsg); 10798 if( zErrMsg ){ 10799 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg); 10800 sqlite3_free(zErrMsg); 10801 } 10802 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0); 10803 } 10804 10805 10806 /* 10807 ** Set the destination table field of the ShellState structure to 10808 ** the name of the table given. Escape any quote characters in the 10809 ** table name. 10810 */ 10811 static void set_table_name(ShellState *p, const char *zName){ 10812 int i, n; 10813 char cQuote; 10814 char *z; 10815 10816 if( p->zDestTable ){ 10817 free(p->zDestTable); 10818 p->zDestTable = 0; 10819 } 10820 if( zName==0 ) return; 10821 cQuote = quoteChar(zName); 10822 n = strlen30(zName); 10823 if( cQuote ) n += n+2; 10824 z = p->zDestTable = malloc( n+1 ); 10825 if( z==0 ) shell_out_of_memory(); 10826 n = 0; 10827 if( cQuote ) z[n++] = cQuote; 10828 for(i=0; zName[i]; i++){ 10829 z[n++] = zName[i]; 10830 if( zName[i]==cQuote ) z[n++] = cQuote; 10831 } 10832 if( cQuote ) z[n++] = cQuote; 10833 z[n] = 0; 10834 } 10835 10836 10837 /* 10838 ** Execute a query statement that will generate SQL output. Print 10839 ** the result columns, comma-separated, on a line and then add a 10840 ** semicolon terminator to the end of that line. 10841 ** 10842 ** If the number of columns is 1 and that column contains text "--" 10843 ** then write the semicolon on a separate line. That way, if a 10844 ** "--" comment occurs at the end of the statement, the comment 10845 ** won't consume the semicolon terminator. 10846 */ 10847 static int run_table_dump_query( 10848 ShellState *p, /* Query context */ 10849 const char *zSelect, /* SELECT statement to extract content */ 10850 const char *zFirstRow /* Print before first row, if not NULL */ 10851 ){ 10852 sqlite3_stmt *pSelect; 10853 int rc; 10854 int nResult; 10855 int i; 10856 const char *z; 10857 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0); 10858 if( rc!=SQLITE_OK || !pSelect ){ 10859 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 10860 sqlite3_errmsg(p->db)); 10861 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 10862 return rc; 10863 } 10864 rc = sqlite3_step(pSelect); 10865 nResult = sqlite3_column_count(pSelect); 10866 while( rc==SQLITE_ROW ){ 10867 if( zFirstRow ){ 10868 utf8_printf(p->out, "%s", zFirstRow); 10869 zFirstRow = 0; 10870 } 10871 z = (const char*)sqlite3_column_text(pSelect, 0); 10872 utf8_printf(p->out, "%s", z); 10873 for(i=1; i<nResult; i++){ 10874 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i)); 10875 } 10876 if( z==0 ) z = ""; 10877 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++; 10878 if( z[0] ){ 10879 raw_printf(p->out, "\n;\n"); 10880 }else{ 10881 raw_printf(p->out, ";\n"); 10882 } 10883 rc = sqlite3_step(pSelect); 10884 } 10885 rc = sqlite3_finalize(pSelect); 10886 if( rc!=SQLITE_OK ){ 10887 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 10888 sqlite3_errmsg(p->db)); 10889 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 10890 } 10891 return rc; 10892 } 10893 10894 /* 10895 ** Allocate space and save off current error string. 10896 */ 10897 static char *save_err_msg( 10898 sqlite3 *db /* Database to query */ 10899 ){ 10900 int nErrMsg = 1+strlen30(sqlite3_errmsg(db)); 10901 char *zErrMsg = sqlite3_malloc64(nErrMsg); 10902 if( zErrMsg ){ 10903 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg); 10904 } 10905 return zErrMsg; 10906 } 10907 10908 #ifdef __linux__ 10909 /* 10910 ** Attempt to display I/O stats on Linux using /proc/PID/io 10911 */ 10912 static void displayLinuxIoStats(FILE *out){ 10913 FILE *in; 10914 char z[200]; 10915 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid()); 10916 in = fopen(z, "rb"); 10917 if( in==0 ) return; 10918 while( fgets(z, sizeof(z), in)!=0 ){ 10919 static const struct { 10920 const char *zPattern; 10921 const char *zDesc; 10922 } aTrans[] = { 10923 { "rchar: ", "Bytes received by read():" }, 10924 { "wchar: ", "Bytes sent to write():" }, 10925 { "syscr: ", "Read() system calls:" }, 10926 { "syscw: ", "Write() system calls:" }, 10927 { "read_bytes: ", "Bytes read from storage:" }, 10928 { "write_bytes: ", "Bytes written to storage:" }, 10929 { "cancelled_write_bytes: ", "Cancelled write bytes:" }, 10930 }; 10931 int i; 10932 for(i=0; i<ArraySize(aTrans); i++){ 10933 int n = strlen30(aTrans[i].zPattern); 10934 if( strncmp(aTrans[i].zPattern, z, n)==0 ){ 10935 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]); 10936 break; 10937 } 10938 } 10939 } 10940 fclose(in); 10941 } 10942 #endif 10943 10944 /* 10945 ** Display a single line of status using 64-bit values. 10946 */ 10947 static void displayStatLine( 10948 ShellState *p, /* The shell context */ 10949 char *zLabel, /* Label for this one line */ 10950 char *zFormat, /* Format for the result */ 10951 int iStatusCtrl, /* Which status to display */ 10952 int bReset /* True to reset the stats */ 10953 ){ 10954 sqlite3_int64 iCur = -1; 10955 sqlite3_int64 iHiwtr = -1; 10956 int i, nPercent; 10957 char zLine[200]; 10958 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset); 10959 for(i=0, nPercent=0; zFormat[i]; i++){ 10960 if( zFormat[i]=='%' ) nPercent++; 10961 } 10962 if( nPercent>1 ){ 10963 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr); 10964 }else{ 10965 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr); 10966 } 10967 raw_printf(p->out, "%-36s %s\n", zLabel, zLine); 10968 } 10969 10970 /* 10971 ** Display memory stats. 10972 */ 10973 static int display_stats( 10974 sqlite3 *db, /* Database to query */ 10975 ShellState *pArg, /* Pointer to ShellState */ 10976 int bReset /* True to reset the stats */ 10977 ){ 10978 int iCur; 10979 int iHiwtr; 10980 FILE *out; 10981 if( pArg==0 || pArg->out==0 ) return 0; 10982 out = pArg->out; 10983 10984 if( pArg->pStmt && (pArg->statsOn & 2) ){ 10985 int nCol, i, x; 10986 sqlite3_stmt *pStmt = pArg->pStmt; 10987 char z[100]; 10988 nCol = sqlite3_column_count(pStmt); 10989 raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol); 10990 for(i=0; i<nCol; i++){ 10991 sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x); 10992 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i)); 10993 #ifndef SQLITE_OMIT_DECLTYPE 10994 sqlite3_snprintf(30, z+x, "declared type:"); 10995 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i)); 10996 #endif 10997 #ifdef SQLITE_ENABLE_COLUMN_METADATA 10998 sqlite3_snprintf(30, z+x, "database name:"); 10999 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i)); 11000 sqlite3_snprintf(30, z+x, "table name:"); 11001 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i)); 11002 sqlite3_snprintf(30, z+x, "origin name:"); 11003 utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i)); 11004 #endif 11005 } 11006 } 11007 11008 displayStatLine(pArg, "Memory Used:", 11009 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset); 11010 displayStatLine(pArg, "Number of Outstanding Allocations:", 11011 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset); 11012 if( pArg->shellFlgs & SHFLG_Pagecache ){ 11013 displayStatLine(pArg, "Number of Pcache Pages Used:", 11014 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset); 11015 } 11016 displayStatLine(pArg, "Number of Pcache Overflow Bytes:", 11017 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset); 11018 displayStatLine(pArg, "Largest Allocation:", 11019 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset); 11020 displayStatLine(pArg, "Largest Pcache Allocation:", 11021 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset); 11022 #ifdef YYTRACKMAXSTACKDEPTH 11023 displayStatLine(pArg, "Deepest Parser Stack:", 11024 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset); 11025 #endif 11026 11027 if( db ){ 11028 if( pArg->shellFlgs & SHFLG_Lookaside ){ 11029 iHiwtr = iCur = -1; 11030 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, 11031 &iCur, &iHiwtr, bReset); 11032 raw_printf(pArg->out, 11033 "Lookaside Slots Used: %d (max %d)\n", 11034 iCur, iHiwtr); 11035 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, 11036 &iCur, &iHiwtr, bReset); 11037 raw_printf(pArg->out, "Successful lookaside attempts: %d\n", 11038 iHiwtr); 11039 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, 11040 &iCur, &iHiwtr, bReset); 11041 raw_printf(pArg->out, "Lookaside failures due to size: %d\n", 11042 iHiwtr); 11043 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, 11044 &iCur, &iHiwtr, bReset); 11045 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n", 11046 iHiwtr); 11047 } 11048 iHiwtr = iCur = -1; 11049 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset); 11050 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n", 11051 iCur); 11052 iHiwtr = iCur = -1; 11053 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1); 11054 raw_printf(pArg->out, "Page cache hits: %d\n", iCur); 11055 iHiwtr = iCur = -1; 11056 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1); 11057 raw_printf(pArg->out, "Page cache misses: %d\n", iCur); 11058 iHiwtr = iCur = -1; 11059 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1); 11060 raw_printf(pArg->out, "Page cache writes: %d\n", iCur); 11061 iHiwtr = iCur = -1; 11062 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1); 11063 raw_printf(pArg->out, "Page cache spills: %d\n", iCur); 11064 iHiwtr = iCur = -1; 11065 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset); 11066 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n", 11067 iCur); 11068 iHiwtr = iCur = -1; 11069 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset); 11070 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", 11071 iCur); 11072 } 11073 11074 if( pArg->pStmt ){ 11075 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, 11076 bReset); 11077 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur); 11078 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset); 11079 raw_printf(pArg->out, "Sort Operations: %d\n", iCur); 11080 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset); 11081 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur); 11082 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset); 11083 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur); 11084 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE, bReset); 11085 raw_printf(pArg->out, "Reprepare operations: %d\n", iCur); 11086 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset); 11087 raw_printf(pArg->out, "Number of times run: %d\n", iCur); 11088 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset); 11089 raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur); 11090 } 11091 11092 #ifdef __linux__ 11093 displayLinuxIoStats(pArg->out); 11094 #endif 11095 11096 /* Do not remove this machine readable comment: extra-stats-output-here */ 11097 11098 return 0; 11099 } 11100 11101 /* 11102 ** Display scan stats. 11103 */ 11104 static void display_scanstats( 11105 sqlite3 *db, /* Database to query */ 11106 ShellState *pArg /* Pointer to ShellState */ 11107 ){ 11108 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS 11109 UNUSED_PARAMETER(db); 11110 UNUSED_PARAMETER(pArg); 11111 #else 11112 int i, k, n, mx; 11113 raw_printf(pArg->out, "-------- scanstats --------\n"); 11114 mx = 0; 11115 for(k=0; k<=mx; k++){ 11116 double rEstLoop = 1.0; 11117 for(i=n=0; 1; i++){ 11118 sqlite3_stmt *p = pArg->pStmt; 11119 sqlite3_int64 nLoop, nVisit; 11120 double rEst; 11121 int iSid; 11122 const char *zExplain; 11123 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){ 11124 break; 11125 } 11126 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid); 11127 if( iSid>mx ) mx = iSid; 11128 if( iSid!=k ) continue; 11129 if( n==0 ){ 11130 rEstLoop = (double)nLoop; 11131 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k); 11132 } 11133 n++; 11134 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit); 11135 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst); 11136 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain); 11137 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain); 11138 rEstLoop *= rEst; 11139 raw_printf(pArg->out, 11140 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n", 11141 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst 11142 ); 11143 } 11144 } 11145 raw_printf(pArg->out, "---------------------------\n"); 11146 #endif 11147 } 11148 11149 /* 11150 ** Parameter azArray points to a zero-terminated array of strings. zStr 11151 ** points to a single nul-terminated string. Return non-zero if zStr 11152 ** is equal, according to strcmp(), to any of the strings in the array. 11153 ** Otherwise, return zero. 11154 */ 11155 static int str_in_array(const char *zStr, const char **azArray){ 11156 int i; 11157 for(i=0; azArray[i]; i++){ 11158 if( 0==strcmp(zStr, azArray[i]) ) return 1; 11159 } 11160 return 0; 11161 } 11162 11163 /* 11164 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate 11165 ** and populate the ShellState.aiIndent[] array with the number of 11166 ** spaces each opcode should be indented before it is output. 11167 ** 11168 ** The indenting rules are: 11169 ** 11170 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent 11171 ** all opcodes that occur between the p2 jump destination and the opcode 11172 ** itself by 2 spaces. 11173 ** 11174 ** * For each "Goto", if the jump destination is earlier in the program 11175 ** and ends on one of: 11176 ** Yield SeekGt SeekLt RowSetRead Rewind 11177 ** or if the P1 parameter is one instead of zero, 11178 ** then indent all opcodes between the earlier instruction 11179 ** and "Goto" by 2 spaces. 11180 */ 11181 static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){ 11182 const char *zSql; /* The text of the SQL statement */ 11183 const char *z; /* Used to check if this is an EXPLAIN */ 11184 int *abYield = 0; /* True if op is an OP_Yield */ 11185 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */ 11186 int iOp; /* Index of operation in p->aiIndent[] */ 11187 11188 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 }; 11189 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead", 11190 "Rewind", 0 }; 11191 const char *azGoto[] = { "Goto", 0 }; 11192 11193 /* Try to figure out if this is really an EXPLAIN statement. If this 11194 ** cannot be verified, return early. */ 11195 if( sqlite3_column_count(pSql)!=8 ){ 11196 p->cMode = p->mode; 11197 return; 11198 } 11199 zSql = sqlite3_sql(pSql); 11200 if( zSql==0 ) return; 11201 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++); 11202 if( sqlite3_strnicmp(z, "explain", 7) ){ 11203 p->cMode = p->mode; 11204 return; 11205 } 11206 11207 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){ 11208 int i; 11209 int iAddr = sqlite3_column_int(pSql, 0); 11210 const char *zOp = (const char*)sqlite3_column_text(pSql, 1); 11211 11212 /* Set p2 to the P2 field of the current opcode. Then, assuming that 11213 ** p2 is an instruction address, set variable p2op to the index of that 11214 ** instruction in the aiIndent[] array. p2 and p2op may be different if 11215 ** the current instruction is part of a sub-program generated by an 11216 ** SQL trigger or foreign key. */ 11217 int p2 = sqlite3_column_int(pSql, 3); 11218 int p2op = (p2 + (iOp-iAddr)); 11219 11220 /* Grow the p->aiIndent array as required */ 11221 if( iOp>=nAlloc ){ 11222 if( iOp==0 ){ 11223 /* Do further verfication that this is explain output. Abort if 11224 ** it is not */ 11225 static const char *explainCols[] = { 11226 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" }; 11227 int jj; 11228 for(jj=0; jj<ArraySize(explainCols); jj++){ 11229 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){ 11230 p->cMode = p->mode; 11231 sqlite3_reset(pSql); 11232 return; 11233 } 11234 } 11235 } 11236 nAlloc += 100; 11237 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int)); 11238 if( p->aiIndent==0 ) shell_out_of_memory(); 11239 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int)); 11240 if( abYield==0 ) shell_out_of_memory(); 11241 } 11242 abYield[iOp] = str_in_array(zOp, azYield); 11243 p->aiIndent[iOp] = 0; 11244 p->nIndent = iOp+1; 11245 11246 if( str_in_array(zOp, azNext) ){ 11247 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 11248 } 11249 if( str_in_array(zOp, azGoto) && p2op<p->nIndent 11250 && (abYield[p2op] || sqlite3_column_int(pSql, 2)) 11251 ){ 11252 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 11253 } 11254 } 11255 11256 p->iIndent = 0; 11257 sqlite3_free(abYield); 11258 sqlite3_reset(pSql); 11259 } 11260 11261 /* 11262 ** Free the array allocated by explain_data_prepare(). 11263 */ 11264 static void explain_data_delete(ShellState *p){ 11265 sqlite3_free(p->aiIndent); 11266 p->aiIndent = 0; 11267 p->nIndent = 0; 11268 p->iIndent = 0; 11269 } 11270 11271 /* 11272 ** Disable and restore .wheretrace and .selecttrace settings. 11273 */ 11274 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 11275 extern int sqlite3SelectTrace; 11276 static int savedSelectTrace; 11277 #endif 11278 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 11279 extern int sqlite3WhereTrace; 11280 static int savedWhereTrace; 11281 #endif 11282 static void disable_debug_trace_modes(void){ 11283 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 11284 savedSelectTrace = sqlite3SelectTrace; 11285 sqlite3SelectTrace = 0; 11286 #endif 11287 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 11288 savedWhereTrace = sqlite3WhereTrace; 11289 sqlite3WhereTrace = 0; 11290 #endif 11291 } 11292 static void restore_debug_trace_modes(void){ 11293 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 11294 sqlite3SelectTrace = savedSelectTrace; 11295 #endif 11296 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 11297 sqlite3WhereTrace = savedWhereTrace; 11298 #endif 11299 } 11300 11301 /* Create the TEMP table used to store parameter bindings */ 11302 static void bind_table_init(ShellState *p){ 11303 int wrSchema = 0; 11304 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema); 11305 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0); 11306 sqlite3_exec(p->db, 11307 "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n" 11308 " key TEXT PRIMARY KEY,\n" 11309 " value ANY\n" 11310 ") WITHOUT ROWID;", 11311 0, 0, 0); 11312 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0); 11313 } 11314 11315 /* 11316 ** Bind parameters on a prepared statement. 11317 ** 11318 ** Parameter bindings are taken from a TEMP table of the form: 11319 ** 11320 ** CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value) 11321 ** WITHOUT ROWID; 11322 ** 11323 ** No bindings occur if this table does not exist. The special character '$' 11324 ** is included in the table name to help prevent collisions with actual tables. 11325 ** The table must be in the TEMP schema. 11326 */ 11327 static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){ 11328 int nVar; 11329 int i; 11330 int rc; 11331 sqlite3_stmt *pQ = 0; 11332 11333 nVar = sqlite3_bind_parameter_count(pStmt); 11334 if( nVar==0 ) return; /* Nothing to do */ 11335 if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters", 11336 "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){ 11337 return; /* Parameter table does not exist */ 11338 } 11339 rc = sqlite3_prepare_v2(pArg->db, 11340 "SELECT value FROM temp.sqlite_parameters" 11341 " WHERE key=?1", -1, &pQ, 0); 11342 if( rc || pQ==0 ) return; 11343 for(i=1; i<=nVar; i++){ 11344 char zNum[30]; 11345 const char *zVar = sqlite3_bind_parameter_name(pStmt, i); 11346 if( zVar==0 ){ 11347 sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i); 11348 zVar = zNum; 11349 } 11350 sqlite3_bind_text(pQ, 1, zVar, -1, SQLITE_STATIC); 11351 if( sqlite3_step(pQ)==SQLITE_ROW ){ 11352 sqlite3_bind_value(pStmt, i, sqlite3_column_value(pQ, 0)); 11353 }else{ 11354 sqlite3_bind_null(pStmt, i); 11355 } 11356 sqlite3_reset(pQ); 11357 } 11358 sqlite3_finalize(pQ); 11359 } 11360 11361 /* 11362 ** Run a prepared statement 11363 */ 11364 static void exec_prepared_stmt( 11365 ShellState *pArg, /* Pointer to ShellState */ 11366 sqlite3_stmt *pStmt /* Statment to run */ 11367 ){ 11368 int rc; 11369 11370 /* perform the first step. this will tell us if we 11371 ** have a result set or not and how wide it is. 11372 */ 11373 rc = sqlite3_step(pStmt); 11374 /* if we have a result set... */ 11375 if( SQLITE_ROW == rc ){ 11376 /* allocate space for col name ptr, value ptr, and type */ 11377 int nCol = sqlite3_column_count(pStmt); 11378 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1); 11379 if( !pData ){ 11380 rc = SQLITE_NOMEM; 11381 }else{ 11382 char **azCols = (char **)pData; /* Names of result columns */ 11383 char **azVals = &azCols[nCol]; /* Results */ 11384 int *aiTypes = (int *)&azVals[nCol]; /* Result types */ 11385 int i, x; 11386 assert(sizeof(int) <= sizeof(char *)); 11387 /* save off ptrs to column names */ 11388 for(i=0; i<nCol; i++){ 11389 azCols[i] = (char *)sqlite3_column_name(pStmt, i); 11390 } 11391 do{ 11392 /* extract the data and data types */ 11393 for(i=0; i<nCol; i++){ 11394 aiTypes[i] = x = sqlite3_column_type(pStmt, i); 11395 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){ 11396 azVals[i] = ""; 11397 }else{ 11398 azVals[i] = (char*)sqlite3_column_text(pStmt, i); 11399 } 11400 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){ 11401 rc = SQLITE_NOMEM; 11402 break; /* from for */ 11403 } 11404 } /* end for */ 11405 11406 /* if data and types extracted successfully... */ 11407 if( SQLITE_ROW == rc ){ 11408 /* call the supplied callback with the result row data */ 11409 if( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){ 11410 rc = SQLITE_ABORT; 11411 }else{ 11412 rc = sqlite3_step(pStmt); 11413 } 11414 } 11415 } while( SQLITE_ROW == rc ); 11416 sqlite3_free(pData); 11417 } 11418 } 11419 } 11420 11421 #ifndef SQLITE_OMIT_VIRTUALTABLE 11422 /* 11423 ** This function is called to process SQL if the previous shell command 11424 ** was ".expert". It passes the SQL in the second argument directly to 11425 ** the sqlite3expert object. 11426 ** 11427 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 11428 ** code. In this case, (*pzErr) may be set to point to a buffer containing 11429 ** an English language error message. It is the responsibility of the 11430 ** caller to eventually free this buffer using sqlite3_free(). 11431 */ 11432 static int expertHandleSQL( 11433 ShellState *pState, 11434 const char *zSql, 11435 char **pzErr 11436 ){ 11437 assert( pState->expert.pExpert ); 11438 assert( pzErr==0 || *pzErr==0 ); 11439 return sqlite3_expert_sql(pState->expert.pExpert, zSql, pzErr); 11440 } 11441 11442 /* 11443 ** This function is called either to silently clean up the object 11444 ** created by the ".expert" command (if bCancel==1), or to generate a 11445 ** report from it and then clean it up (if bCancel==0). 11446 ** 11447 ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 11448 ** code. In this case, (*pzErr) may be set to point to a buffer containing 11449 ** an English language error message. It is the responsibility of the 11450 ** caller to eventually free this buffer using sqlite3_free(). 11451 */ 11452 static int expertFinish( 11453 ShellState *pState, 11454 int bCancel, 11455 char **pzErr 11456 ){ 11457 int rc = SQLITE_OK; 11458 sqlite3expert *p = pState->expert.pExpert; 11459 assert( p ); 11460 assert( bCancel || pzErr==0 || *pzErr==0 ); 11461 if( bCancel==0 ){ 11462 FILE *out = pState->out; 11463 int bVerbose = pState->expert.bVerbose; 11464 11465 rc = sqlite3_expert_analyze(p, pzErr); 11466 if( rc==SQLITE_OK ){ 11467 int nQuery = sqlite3_expert_count(p); 11468 int i; 11469 11470 if( bVerbose ){ 11471 const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES); 11472 raw_printf(out, "-- Candidates -----------------------------\n"); 11473 raw_printf(out, "%s\n", zCand); 11474 } 11475 for(i=0; i<nQuery; i++){ 11476 const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL); 11477 const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES); 11478 const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN); 11479 if( zIdx==0 ) zIdx = "(no new indexes)\n"; 11480 if( bVerbose ){ 11481 raw_printf(out, "-- Query %d --------------------------------\n",i+1); 11482 raw_printf(out, "%s\n\n", zSql); 11483 } 11484 raw_printf(out, "%s\n", zIdx); 11485 raw_printf(out, "%s\n", zEQP); 11486 } 11487 } 11488 } 11489 sqlite3_expert_destroy(p); 11490 pState->expert.pExpert = 0; 11491 return rc; 11492 } 11493 11494 /* 11495 ** Implementation of ".expert" dot command. 11496 */ 11497 static int expertDotCommand( 11498 ShellState *pState, /* Current shell tool state */ 11499 char **azArg, /* Array of arguments passed to dot command */ 11500 int nArg /* Number of entries in azArg[] */ 11501 ){ 11502 int rc = SQLITE_OK; 11503 char *zErr = 0; 11504 int i; 11505 int iSample = 0; 11506 11507 assert( pState->expert.pExpert==0 ); 11508 memset(&pState->expert, 0, sizeof(ExpertInfo)); 11509 11510 for(i=1; rc==SQLITE_OK && i<nArg; i++){ 11511 char *z = azArg[i]; 11512 int n; 11513 if( z[0]=='-' && z[1]=='-' ) z++; 11514 n = strlen30(z); 11515 if( n>=2 && 0==strncmp(z, "-verbose", n) ){ 11516 pState->expert.bVerbose = 1; 11517 } 11518 else if( n>=2 && 0==strncmp(z, "-sample", n) ){ 11519 if( i==(nArg-1) ){ 11520 raw_printf(stderr, "option requires an argument: %s\n", z); 11521 rc = SQLITE_ERROR; 11522 }else{ 11523 iSample = (int)integerValue(azArg[++i]); 11524 if( iSample<0 || iSample>100 ){ 11525 raw_printf(stderr, "value out of range: %s\n", azArg[i]); 11526 rc = SQLITE_ERROR; 11527 } 11528 } 11529 } 11530 else{ 11531 raw_printf(stderr, "unknown option: %s\n", z); 11532 rc = SQLITE_ERROR; 11533 } 11534 } 11535 11536 if( rc==SQLITE_OK ){ 11537 pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr); 11538 if( pState->expert.pExpert==0 ){ 11539 raw_printf(stderr, "sqlite3_expert_new: %s\n", zErr); 11540 rc = SQLITE_ERROR; 11541 }else{ 11542 sqlite3_expert_config( 11543 pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample 11544 ); 11545 } 11546 } 11547 11548 return rc; 11549 } 11550 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ 11551 11552 /* 11553 ** Execute a statement or set of statements. Print 11554 ** any result rows/columns depending on the current mode 11555 ** set via the supplied callback. 11556 ** 11557 ** This is very similar to SQLite's built-in sqlite3_exec() 11558 ** function except it takes a slightly different callback 11559 ** and callback data argument. 11560 */ 11561 static int shell_exec( 11562 ShellState *pArg, /* Pointer to ShellState */ 11563 const char *zSql, /* SQL to be evaluated */ 11564 char **pzErrMsg /* Error msg written here */ 11565 ){ 11566 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */ 11567 int rc = SQLITE_OK; /* Return Code */ 11568 int rc2; 11569 const char *zLeftover; /* Tail of unprocessed SQL */ 11570 sqlite3 *db = pArg->db; 11571 11572 if( pzErrMsg ){ 11573 *pzErrMsg = NULL; 11574 } 11575 11576 #ifndef SQLITE_OMIT_VIRTUALTABLE 11577 if( pArg->expert.pExpert ){ 11578 rc = expertHandleSQL(pArg, zSql, pzErrMsg); 11579 return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg); 11580 } 11581 #endif 11582 11583 while( zSql[0] && (SQLITE_OK == rc) ){ 11584 static const char *zStmtSql; 11585 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); 11586 if( SQLITE_OK != rc ){ 11587 if( pzErrMsg ){ 11588 *pzErrMsg = save_err_msg(db); 11589 } 11590 }else{ 11591 if( !pStmt ){ 11592 /* this happens for a comment or white-space */ 11593 zSql = zLeftover; 11594 while( IsSpace(zSql[0]) ) zSql++; 11595 continue; 11596 } 11597 zStmtSql = sqlite3_sql(pStmt); 11598 if( zStmtSql==0 ) zStmtSql = ""; 11599 while( IsSpace(zStmtSql[0]) ) zStmtSql++; 11600 11601 /* save off the prepared statment handle and reset row count */ 11602 if( pArg ){ 11603 pArg->pStmt = pStmt; 11604 pArg->cnt = 0; 11605 } 11606 11607 /* echo the sql statement if echo on */ 11608 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){ 11609 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql); 11610 } 11611 11612 /* Show the EXPLAIN QUERY PLAN if .eqp is on */ 11613 if( pArg && pArg->autoEQP && sqlite3_stmt_isexplain(pStmt)==0 ){ 11614 sqlite3_stmt *pExplain; 11615 char *zEQP; 11616 int triggerEQP = 0; 11617 disable_debug_trace_modes(); 11618 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP); 11619 if( pArg->autoEQP>=AUTOEQP_trigger ){ 11620 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0); 11621 } 11622 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql); 11623 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 11624 if( rc==SQLITE_OK ){ 11625 while( sqlite3_step(pExplain)==SQLITE_ROW ){ 11626 const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3); 11627 int iEqpId = sqlite3_column_int(pExplain, 0); 11628 int iParentId = sqlite3_column_int(pExplain, 1); 11629 if( zEQPLine[0]=='-' ) eqp_render(pArg); 11630 eqp_append(pArg, iEqpId, iParentId, zEQPLine); 11631 } 11632 eqp_render(pArg); 11633 } 11634 sqlite3_finalize(pExplain); 11635 sqlite3_free(zEQP); 11636 if( pArg->autoEQP>=AUTOEQP_full ){ 11637 /* Also do an EXPLAIN for ".eqp full" mode */ 11638 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql); 11639 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 11640 if( rc==SQLITE_OK ){ 11641 pArg->cMode = MODE_Explain; 11642 explain_data_prepare(pArg, pExplain); 11643 exec_prepared_stmt(pArg, pExplain); 11644 explain_data_delete(pArg); 11645 } 11646 sqlite3_finalize(pExplain); 11647 sqlite3_free(zEQP); 11648 } 11649 if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){ 11650 sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0); 11651 /* Reprepare pStmt before reactiving trace modes */ 11652 sqlite3_finalize(pStmt); 11653 sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 11654 if( pArg ) pArg->pStmt = pStmt; 11655 } 11656 restore_debug_trace_modes(); 11657 } 11658 11659 if( pArg ){ 11660 pArg->cMode = pArg->mode; 11661 if( pArg->autoExplain ){ 11662 if( sqlite3_stmt_isexplain(pStmt)==1 ){ 11663 pArg->cMode = MODE_Explain; 11664 } 11665 if( sqlite3_stmt_isexplain(pStmt)==2 ){ 11666 pArg->cMode = MODE_EQP; 11667 } 11668 } 11669 11670 /* If the shell is currently in ".explain" mode, gather the extra 11671 ** data required to add indents to the output.*/ 11672 if( pArg->cMode==MODE_Explain ){ 11673 explain_data_prepare(pArg, pStmt); 11674 } 11675 } 11676 11677 bind_prepared_stmt(pArg, pStmt); 11678 exec_prepared_stmt(pArg, pStmt); 11679 explain_data_delete(pArg); 11680 eqp_render(pArg); 11681 11682 /* print usage stats if stats on */ 11683 if( pArg && pArg->statsOn ){ 11684 display_stats(db, pArg, 0); 11685 } 11686 11687 /* print loop-counters if required */ 11688 if( pArg && pArg->scanstatsOn ){ 11689 display_scanstats(db, pArg); 11690 } 11691 11692 /* Finalize the statement just executed. If this fails, save a 11693 ** copy of the error message. Otherwise, set zSql to point to the 11694 ** next statement to execute. */ 11695 rc2 = sqlite3_finalize(pStmt); 11696 if( rc!=SQLITE_NOMEM ) rc = rc2; 11697 if( rc==SQLITE_OK ){ 11698 zSql = zLeftover; 11699 while( IsSpace(zSql[0]) ) zSql++; 11700 }else if( pzErrMsg ){ 11701 *pzErrMsg = save_err_msg(db); 11702 } 11703 11704 /* clear saved stmt handle */ 11705 if( pArg ){ 11706 pArg->pStmt = NULL; 11707 } 11708 } 11709 } /* end while */ 11710 11711 return rc; 11712 } 11713 11714 /* 11715 ** Release memory previously allocated by tableColumnList(). 11716 */ 11717 static void freeColumnList(char **azCol){ 11718 int i; 11719 for(i=1; azCol[i]; i++){ 11720 sqlite3_free(azCol[i]); 11721 } 11722 /* azCol[0] is a static string */ 11723 sqlite3_free(azCol); 11724 } 11725 11726 /* 11727 ** Return a list of pointers to strings which are the names of all 11728 ** columns in table zTab. The memory to hold the names is dynamically 11729 ** allocated and must be released by the caller using a subsequent call 11730 ** to freeColumnList(). 11731 ** 11732 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid 11733 ** value that needs to be preserved, then azCol[0] is filled in with the 11734 ** name of the rowid column. 11735 ** 11736 ** The first regular column in the table is azCol[1]. The list is terminated 11737 ** by an entry with azCol[i]==0. 11738 */ 11739 static char **tableColumnList(ShellState *p, const char *zTab){ 11740 char **azCol = 0; 11741 sqlite3_stmt *pStmt; 11742 char *zSql; 11743 int nCol = 0; 11744 int nAlloc = 0; 11745 int nPK = 0; /* Number of PRIMARY KEY columns seen */ 11746 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */ 11747 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid); 11748 int rc; 11749 11750 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab); 11751 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 11752 sqlite3_free(zSql); 11753 if( rc ) return 0; 11754 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 11755 if( nCol>=nAlloc-2 ){ 11756 nAlloc = nAlloc*2 + nCol + 10; 11757 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0])); 11758 if( azCol==0 ) shell_out_of_memory(); 11759 } 11760 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1)); 11761 if( sqlite3_column_int(pStmt, 5) ){ 11762 nPK++; 11763 if( nPK==1 11764 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2), 11765 "INTEGER")==0 11766 ){ 11767 isIPK = 1; 11768 }else{ 11769 isIPK = 0; 11770 } 11771 } 11772 } 11773 sqlite3_finalize(pStmt); 11774 if( azCol==0 ) return 0; 11775 azCol[0] = 0; 11776 azCol[nCol+1] = 0; 11777 11778 /* The decision of whether or not a rowid really needs to be preserved 11779 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table 11780 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve 11781 ** rowids on tables where the rowid is inaccessible because there are other 11782 ** columns in the table named "rowid", "_rowid_", and "oid". 11783 */ 11784 if( preserveRowid && isIPK ){ 11785 /* If a single PRIMARY KEY column with type INTEGER was seen, then it 11786 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID 11787 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are 11788 ** ROWID aliases. To distinguish these cases, check to see if 11789 ** there is a "pk" entry in "PRAGMA index_list". There will be 11790 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID. 11791 */ 11792 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)" 11793 " WHERE origin='pk'", zTab); 11794 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 11795 sqlite3_free(zSql); 11796 if( rc ){ 11797 freeColumnList(azCol); 11798 return 0; 11799 } 11800 rc = sqlite3_step(pStmt); 11801 sqlite3_finalize(pStmt); 11802 preserveRowid = rc==SQLITE_ROW; 11803 } 11804 if( preserveRowid ){ 11805 /* Only preserve the rowid if we can find a name to use for the 11806 ** rowid */ 11807 static char *azRowid[] = { "rowid", "_rowid_", "oid" }; 11808 int i, j; 11809 for(j=0; j<3; j++){ 11810 for(i=1; i<=nCol; i++){ 11811 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break; 11812 } 11813 if( i>nCol ){ 11814 /* At this point, we know that azRowid[j] is not the name of any 11815 ** ordinary column in the table. Verify that azRowid[j] is a valid 11816 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID 11817 ** tables will fail this last check */ 11818 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0); 11819 if( rc==SQLITE_OK ) azCol[0] = azRowid[j]; 11820 break; 11821 } 11822 } 11823 } 11824 return azCol; 11825 } 11826 11827 /* 11828 ** Toggle the reverse_unordered_selects setting. 11829 */ 11830 static void toggleSelectOrder(sqlite3 *db){ 11831 sqlite3_stmt *pStmt = 0; 11832 int iSetting = 0; 11833 char zStmt[100]; 11834 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0); 11835 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 11836 iSetting = sqlite3_column_int(pStmt, 0); 11837 } 11838 sqlite3_finalize(pStmt); 11839 sqlite3_snprintf(sizeof(zStmt), zStmt, 11840 "PRAGMA reverse_unordered_selects(%d)", !iSetting); 11841 sqlite3_exec(db, zStmt, 0, 0, 0); 11842 } 11843 11844 /* 11845 ** This is a different callback routine used for dumping the database. 11846 ** Each row received by this callback consists of a table name, 11847 ** the table type ("index" or "table") and SQL to create the table. 11848 ** This routine should print text sufficient to recreate the table. 11849 */ 11850 static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){ 11851 int rc; 11852 const char *zTable; 11853 const char *zType; 11854 const char *zSql; 11855 ShellState *p = (ShellState *)pArg; 11856 11857 UNUSED_PARAMETER(azNotUsed); 11858 if( nArg!=3 || azArg==0 ) return 0; 11859 zTable = azArg[0]; 11860 zType = azArg[1]; 11861 zSql = azArg[2]; 11862 11863 if( strcmp(zTable, "sqlite_sequence")==0 ){ 11864 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n"); 11865 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){ 11866 raw_printf(p->out, "ANALYZE sqlite_master;\n"); 11867 }else if( strncmp(zTable, "sqlite_", 7)==0 ){ 11868 return 0; 11869 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ 11870 char *zIns; 11871 if( !p->writableSchema ){ 11872 raw_printf(p->out, "PRAGMA writable_schema=ON;\n"); 11873 p->writableSchema = 1; 11874 } 11875 zIns = sqlite3_mprintf( 11876 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)" 11877 "VALUES('table','%q','%q',0,'%q');", 11878 zTable, zTable, zSql); 11879 utf8_printf(p->out, "%s\n", zIns); 11880 sqlite3_free(zIns); 11881 return 0; 11882 }else{ 11883 printSchemaLine(p->out, zSql, ";\n"); 11884 } 11885 11886 if( strcmp(zType, "table")==0 ){ 11887 ShellText sSelect; 11888 ShellText sTable; 11889 char **azCol; 11890 int i; 11891 char *savedDestTable; 11892 int savedMode; 11893 11894 azCol = tableColumnList(p, zTable); 11895 if( azCol==0 ){ 11896 p->nErr++; 11897 return 0; 11898 } 11899 11900 /* Always quote the table name, even if it appears to be pure ascii, 11901 ** in case it is a keyword. Ex: INSERT INTO "table" ... */ 11902 initText(&sTable); 11903 appendText(&sTable, zTable, quoteChar(zTable)); 11904 /* If preserving the rowid, add a column list after the table name. 11905 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)" 11906 ** instead of the usual "INSERT INTO tab VALUES(...)". 11907 */ 11908 if( azCol[0] ){ 11909 appendText(&sTable, "(", 0); 11910 appendText(&sTable, azCol[0], 0); 11911 for(i=1; azCol[i]; i++){ 11912 appendText(&sTable, ",", 0); 11913 appendText(&sTable, azCol[i], quoteChar(azCol[i])); 11914 } 11915 appendText(&sTable, ")", 0); 11916 } 11917 11918 /* Build an appropriate SELECT statement */ 11919 initText(&sSelect); 11920 appendText(&sSelect, "SELECT ", 0); 11921 if( azCol[0] ){ 11922 appendText(&sSelect, azCol[0], 0); 11923 appendText(&sSelect, ",", 0); 11924 } 11925 for(i=1; azCol[i]; i++){ 11926 appendText(&sSelect, azCol[i], quoteChar(azCol[i])); 11927 if( azCol[i+1] ){ 11928 appendText(&sSelect, ",", 0); 11929 } 11930 } 11931 freeColumnList(azCol); 11932 appendText(&sSelect, " FROM ", 0); 11933 appendText(&sSelect, zTable, quoteChar(zTable)); 11934 11935 savedDestTable = p->zDestTable; 11936 savedMode = p->mode; 11937 p->zDestTable = sTable.z; 11938 p->mode = p->cMode = MODE_Insert; 11939 rc = shell_exec(p, sSelect.z, 0); 11940 if( (rc&0xff)==SQLITE_CORRUPT ){ 11941 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 11942 toggleSelectOrder(p->db); 11943 shell_exec(p, sSelect.z, 0); 11944 toggleSelectOrder(p->db); 11945 } 11946 p->zDestTable = savedDestTable; 11947 p->mode = savedMode; 11948 freeText(&sTable); 11949 freeText(&sSelect); 11950 if( rc ) p->nErr++; 11951 } 11952 return 0; 11953 } 11954 11955 /* 11956 ** Run zQuery. Use dump_callback() as the callback routine so that 11957 ** the contents of the query are output as SQL statements. 11958 ** 11959 ** If we get a SQLITE_CORRUPT error, rerun the query after appending 11960 ** "ORDER BY rowid DESC" to the end. 11961 */ 11962 static int run_schema_dump_query( 11963 ShellState *p, 11964 const char *zQuery 11965 ){ 11966 int rc; 11967 char *zErr = 0; 11968 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr); 11969 if( rc==SQLITE_CORRUPT ){ 11970 char *zQ2; 11971 int len = strlen30(zQuery); 11972 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 11973 if( zErr ){ 11974 utf8_printf(p->out, "/****** %s ******/\n", zErr); 11975 sqlite3_free(zErr); 11976 zErr = 0; 11977 } 11978 zQ2 = malloc( len+100 ); 11979 if( zQ2==0 ) return rc; 11980 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery); 11981 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr); 11982 if( rc ){ 11983 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr); 11984 }else{ 11985 rc = SQLITE_CORRUPT; 11986 } 11987 sqlite3_free(zErr); 11988 free(zQ2); 11989 } 11990 return rc; 11991 } 11992 11993 /* 11994 ** Text of help messages. 11995 ** 11996 ** The help text for each individual command begins with a line that starts 11997 ** with ".". Subsequent lines are supplimental information. 11998 ** 11999 ** There must be two or more spaces between the end of the command and the 12000 ** start of the description of what that command does. 12001 */ 12002 static const char *(azHelp[]) = { 12003 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 12004 ".archive ... Manage SQL archives", 12005 " Each command must have exactly one of the following options:", 12006 " -c, --create Create a new archive", 12007 " -u, --update Add files or update files with changed mtime", 12008 " -i, --insert Like -u but always add even if mtime unchanged", 12009 " -t, --list List contents of archive", 12010 " -x, --extract Extract files from archive", 12011 " Optional arguments:", 12012 " -v, --verbose Print each filename as it is processed", 12013 " -f FILE, --file FILE Operate on archive FILE (default is current db)", 12014 " -a FILE, --append FILE Operate on FILE opened using the apndvfs VFS", 12015 " -C DIR, --directory DIR Change to directory DIR to read/extract files", 12016 " -n, --dryrun Show the SQL that would have occurred", 12017 " Examples:", 12018 " .ar -cf archive.sar foo bar # Create archive.sar from files foo and bar", 12019 " .ar -tf archive.sar # List members of archive.sar", 12020 " .ar -xvf archive.sar # Verbosely extract files from archive.sar", 12021 " See also:", 12022 " http://sqlite.org/cli.html#sqlar_archive_support", 12023 #endif 12024 #ifndef SQLITE_OMIT_AUTHORIZATION 12025 ".auth ON|OFF Show authorizer callbacks", 12026 #endif 12027 ".backup ?DB? FILE Backup DB (default \"main\") to FILE", 12028 " --append Use the appendvfs", 12029 " --async Write to FILE without a journal and without fsync()", 12030 ".bail on|off Stop after hitting an error. Default OFF", 12031 ".binary on|off Turn binary output on or off. Default OFF", 12032 ".cd DIRECTORY Change the working directory to DIRECTORY", 12033 ".changes on|off Show number of rows changed by SQL", 12034 ".check GLOB Fail if output since .testcase does not match", 12035 ".clone NEWDB Clone data into NEWDB from the existing database", 12036 ".databases List names and files of attached databases", 12037 ".dbconfig ?op? ?val? List or change sqlite3_db_config() options", 12038 ".dbinfo ?DB? Show status information about the database", 12039 ".dump ?TABLE? ... Render all database content as SQL", 12040 " Options:", 12041 " --preserve-rowids Include ROWID values in the output", 12042 " --newlines Allow unescaped newline characters in output", 12043 " TABLE is a LIKE pattern for the tables to dump", 12044 ".echo on|off Turn command echo on or off", 12045 ".eqp on|off|full|... Enable or disable automatic EXPLAIN QUERY PLAN", 12046 " Other Modes:", 12047 #ifdef SQLITE_DEBUG 12048 " test Show raw EXPLAIN QUERY PLAN output", 12049 " trace Like \"full\" but also enable \"PRAGMA vdbe_trace\"", 12050 #endif 12051 " trigger Like \"full\" but also show trigger bytecode", 12052 ".excel Display the output of next command in a spreadsheet", 12053 ".exit ?CODE? Exit this program with return-code CODE", 12054 ".expert EXPERIMENTAL. Suggest indexes for specified queries", 12055 /* Because explain mode comes on automatically now, the ".explain" mode 12056 ** is removed from the help screen. It is still supported for legacy, however */ 12057 /*".explain ?on|off|auto? Turn EXPLAIN output mode on or off or to automatic",*/ 12058 ".filectrl CMD ... Run various sqlite3_file_control() operations", 12059 " Run \".filectrl\" with no arguments for details", 12060 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables", 12061 ".headers on|off Turn display of headers on or off", 12062 ".help ?-all? ?PATTERN? Show help text for PATTERN", 12063 ".import FILE TABLE Import data from FILE into TABLE", 12064 #ifndef SQLITE_OMIT_TEST_CONTROL 12065 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX", 12066 #endif 12067 ".indexes ?TABLE? Show names of indexes", 12068 " If TABLE is specified, only show indexes for", 12069 " tables matching TABLE using the LIKE operator.", 12070 #ifdef SQLITE_ENABLE_IOTRACE 12071 ".iotrace FILE Enable I/O diagnostic logging to FILE", 12072 #endif 12073 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT", 12074 ".lint OPTIONS Report potential schema issues.", 12075 " Options:", 12076 " fkey-indexes Find missing foreign key indexes", 12077 #ifndef SQLITE_OMIT_LOAD_EXTENSION 12078 ".load FILE ?ENTRY? Load an extension library", 12079 #endif 12080 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout", 12081 ".mode MODE ?TABLE? Set output mode", 12082 " MODE is one of:", 12083 " ascii Columns/rows delimited by 0x1F and 0x1E", 12084 " csv Comma-separated values", 12085 " column Left-aligned columns. (See .width)", 12086 " html HTML <table> code", 12087 " insert SQL insert statements for TABLE", 12088 " line One value per line", 12089 " list Values delimited by \"|\"", 12090 " quote Escape answers as for SQL", 12091 " tabs Tab-separated values", 12092 " tcl TCL list elements", 12093 ".nullvalue STRING Use STRING in place of NULL values", 12094 ".once (-e|-x|FILE) Output for the next SQL command only to FILE", 12095 " If FILE begins with '|' then open as a pipe", 12096 " Other options:", 12097 " -e Invoke system text editor", 12098 " -x Open in a spreadsheet", 12099 ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE", 12100 " Options:", 12101 " --append Use appendvfs to append database to the end of FILE", 12102 #ifdef SQLITE_ENABLE_DESERIALIZE 12103 " --deserialize Load into memory useing sqlite3_deserialize()", 12104 " --hexdb Load the output of \"dbtotxt\" as an in-memory database", 12105 " --maxsize N Maximum size for --hexdb or --deserialized database", 12106 #endif 12107 " --new Initialize FILE to an empty database", 12108 " --readonly Open FILE readonly", 12109 " --zip FILE is a ZIP archive", 12110 ".output ?FILE? Send output to FILE or stdout if FILE is omitted", 12111 " If FILE begins with '|' then open it as a pipe.", 12112 ".parameter CMD ... Manage SQL parameter bindings", 12113 " clear Erase all bindings", 12114 " init Initialize the TEMP table that holds bindings", 12115 " list List the current parameter bindings", 12116 " set PARAMETER VALUE Given SQL parameter PARAMETER a value of VALUE", 12117 " PARAMETER should start with '$', ':', '@', or '?'", 12118 " unset PARAMETER Remove PARAMETER from the binding table", 12119 ".print STRING... Print literal STRING", 12120 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 12121 ".progress N Invoke progress handler after every N opcodes", 12122 " --limit N Interrupt after N progress callbacks", 12123 " --once Do no more than one progress interrupt", 12124 " --quiet|-q No output except at interrupts", 12125 " --reset Reset the count for each input and interrupt", 12126 #endif 12127 ".prompt MAIN CONTINUE Replace the standard prompts", 12128 ".quit Exit this program", 12129 ".read FILE Read input from FILE", 12130 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 12131 ".recover Recover as much data as possible from corrupt db.", 12132 #endif 12133 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE", 12134 ".save FILE Write in-memory database into FILE", 12135 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off", 12136 ".schema ?PATTERN? Show the CREATE statements matching PATTERN", 12137 " Options:", 12138 " --indent Try to pretty-print the schema", 12139 ".selftest ?OPTIONS? Run tests defined in the SELFTEST table", 12140 " Options:", 12141 " --init Create a new SELFTEST table", 12142 " -v Verbose output", 12143 ".separator COL ?ROW? Change the column and row separators", 12144 #if defined(SQLITE_ENABLE_SESSION) 12145 ".session ?NAME? CMD ... Create or control sessions", 12146 " Subcommands:", 12147 " attach TABLE Attach TABLE", 12148 " changeset FILE Write a changeset into FILE", 12149 " close Close one session", 12150 " enable ?BOOLEAN? Set or query the enable bit", 12151 " filter GLOB... Reject tables matching GLOBs", 12152 " indirect ?BOOLEAN? Mark or query the indirect status", 12153 " isempty Query whether the session is empty", 12154 " list List currently open session names", 12155 " open DB NAME Open a new session on DB", 12156 " patchset FILE Write a patchset into FILE", 12157 " If ?NAME? is omitted, the first defined session is used.", 12158 #endif 12159 ".sha3sum ... Compute a SHA3 hash of database content", 12160 " Options:", 12161 " --schema Also hash the sqlite_master table", 12162 " --sha3-224 Use the sha3-224 algorithm", 12163 " --sha3-256 Use the sha3-256 algorithm. This is the default.", 12164 " --sha3-384 Use the sha3-384 algorithm", 12165 " --sha3-512 Use the sha3-512 algorithm", 12166 " Any other argument is a LIKE pattern for tables to hash", 12167 #ifndef SQLITE_NOHAVE_SYSTEM 12168 ".shell CMD ARGS... Run CMD ARGS... in a system shell", 12169 #endif 12170 ".show Show the current values for various settings", 12171 ".stats ?on|off? Show stats or turn stats on or off", 12172 #ifndef SQLITE_NOHAVE_SYSTEM 12173 ".system CMD ARGS... Run CMD ARGS... in a system shell", 12174 #endif 12175 ".tables ?TABLE? List names of tables matching LIKE pattern TABLE", 12176 ".testcase NAME Begin redirecting output to 'testcase-out.txt'", 12177 ".testctrl CMD ... Run various sqlite3_test_control() operations", 12178 " Run \".testctrl\" with no arguments for details", 12179 ".timeout MS Try opening locked tables for MS milliseconds", 12180 ".timer on|off Turn SQL timer on or off", 12181 #ifndef SQLITE_OMIT_TRACE 12182 ".trace ?OPTIONS? Output each SQL statement as it is run", 12183 " FILE Send output to FILE", 12184 " stdout Send output to stdout", 12185 " stderr Send output to stderr", 12186 " off Disable tracing", 12187 " --expanded Expand query parameters", 12188 #ifdef SQLITE_ENABLE_NORMALIZE 12189 " --normalized Normal the SQL statements", 12190 #endif 12191 " --plain Show SQL as it is input", 12192 " --stmt Trace statement execution (SQLITE_TRACE_STMT)", 12193 " --profile Profile statements (SQLITE_TRACE_PROFILE)", 12194 " --row Trace each row (SQLITE_TRACE_ROW)", 12195 " --close Trace connection close (SQLITE_TRACE_CLOSE)", 12196 #endif /* SQLITE_OMIT_TRACE */ 12197 ".vfsinfo ?AUX? Information about the top-level VFS", 12198 ".vfslist List all available VFSes", 12199 ".vfsname ?AUX? Print the name of the VFS stack", 12200 ".width NUM1 NUM2 ... Set column widths for \"column\" mode", 12201 " Negative values right-justify", 12202 }; 12203 12204 /* 12205 ** Output help text. 12206 ** 12207 ** zPattern describes the set of commands for which help text is provided. 12208 ** If zPattern is NULL, then show all commands, but only give a one-line 12209 ** description of each. 12210 ** 12211 ** Return the number of matches. 12212 */ 12213 static int showHelp(FILE *out, const char *zPattern){ 12214 int i = 0; 12215 int j = 0; 12216 int n = 0; 12217 char *zPat; 12218 if( zPattern==0 12219 || zPattern[0]=='0' 12220 || strcmp(zPattern,"-a")==0 12221 || strcmp(zPattern,"-all")==0 12222 ){ 12223 /* Show all commands, but only one line per command */ 12224 if( zPattern==0 ) zPattern = ""; 12225 for(i=0; i<ArraySize(azHelp); i++){ 12226 if( azHelp[i][0]=='.' || zPattern[0] ){ 12227 utf8_printf(out, "%s\n", azHelp[i]); 12228 n++; 12229 } 12230 } 12231 }else{ 12232 /* Look for commands that for which zPattern is an exact prefix */ 12233 zPat = sqlite3_mprintf(".%s*", zPattern); 12234 for(i=0; i<ArraySize(azHelp); i++){ 12235 if( sqlite3_strglob(zPat, azHelp[i])==0 ){ 12236 utf8_printf(out, "%s\n", azHelp[i]); 12237 j = i+1; 12238 n++; 12239 } 12240 } 12241 sqlite3_free(zPat); 12242 if( n ){ 12243 if( n==1 ){ 12244 /* when zPattern is a prefix of exactly one command, then include the 12245 ** details of that command, which should begin at offset j */ 12246 while( j<ArraySize(azHelp)-1 && azHelp[j][0]!='.' ){ 12247 utf8_printf(out, "%s\n", azHelp[j]); 12248 j++; 12249 } 12250 } 12251 return n; 12252 } 12253 /* Look for commands that contain zPattern anywhere. Show the complete 12254 ** text of all commands that match. */ 12255 zPat = sqlite3_mprintf("%%%s%%", zPattern); 12256 for(i=0; i<ArraySize(azHelp); i++){ 12257 if( azHelp[i][0]=='.' ) j = i; 12258 if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){ 12259 utf8_printf(out, "%s\n", azHelp[j]); 12260 while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]!='.' ){ 12261 j++; 12262 utf8_printf(out, "%s\n", azHelp[j]); 12263 } 12264 i = j; 12265 n++; 12266 } 12267 } 12268 sqlite3_free(zPat); 12269 } 12270 return n; 12271 } 12272 12273 /* Forward reference */ 12274 static int process_input(ShellState *p); 12275 12276 /* 12277 ** Read the content of file zName into memory obtained from sqlite3_malloc64() 12278 ** and return a pointer to the buffer. The caller is responsible for freeing 12279 ** the memory. 12280 ** 12281 ** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes 12282 ** read. 12283 ** 12284 ** For convenience, a nul-terminator byte is always appended to the data read 12285 ** from the file before the buffer is returned. This byte is not included in 12286 ** the final value of (*pnByte), if applicable. 12287 ** 12288 ** NULL is returned if any error is encountered. The final value of *pnByte 12289 ** is undefined in this case. 12290 */ 12291 static char *readFile(const char *zName, int *pnByte){ 12292 FILE *in = fopen(zName, "rb"); 12293 long nIn; 12294 size_t nRead; 12295 char *pBuf; 12296 if( in==0 ) return 0; 12297 fseek(in, 0, SEEK_END); 12298 nIn = ftell(in); 12299 rewind(in); 12300 pBuf = sqlite3_malloc64( nIn+1 ); 12301 if( pBuf==0 ){ fclose(in); return 0; } 12302 nRead = fread(pBuf, nIn, 1, in); 12303 fclose(in); 12304 if( nRead!=1 ){ 12305 sqlite3_free(pBuf); 12306 return 0; 12307 } 12308 pBuf[nIn] = 0; 12309 if( pnByte ) *pnByte = nIn; 12310 return pBuf; 12311 } 12312 12313 #if defined(SQLITE_ENABLE_SESSION) 12314 /* 12315 ** Close a single OpenSession object and release all of its associated 12316 ** resources. 12317 */ 12318 static void session_close(OpenSession *pSession){ 12319 int i; 12320 sqlite3session_delete(pSession->p); 12321 sqlite3_free(pSession->zName); 12322 for(i=0; i<pSession->nFilter; i++){ 12323 sqlite3_free(pSession->azFilter[i]); 12324 } 12325 sqlite3_free(pSession->azFilter); 12326 memset(pSession, 0, sizeof(OpenSession)); 12327 } 12328 #endif 12329 12330 /* 12331 ** Close all OpenSession objects and release all associated resources. 12332 */ 12333 #if defined(SQLITE_ENABLE_SESSION) 12334 static void session_close_all(ShellState *p){ 12335 int i; 12336 for(i=0; i<p->nSession; i++){ 12337 session_close(&p->aSession[i]); 12338 } 12339 p->nSession = 0; 12340 } 12341 #else 12342 # define session_close_all(X) 12343 #endif 12344 12345 /* 12346 ** Implementation of the xFilter function for an open session. Omit 12347 ** any tables named by ".session filter" but let all other table through. 12348 */ 12349 #if defined(SQLITE_ENABLE_SESSION) 12350 static int session_filter(void *pCtx, const char *zTab){ 12351 OpenSession *pSession = (OpenSession*)pCtx; 12352 int i; 12353 for(i=0; i<pSession->nFilter; i++){ 12354 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0; 12355 } 12356 return 1; 12357 } 12358 #endif 12359 12360 /* 12361 ** Try to deduce the type of file for zName based on its content. Return 12362 ** one of the SHELL_OPEN_* constants. 12363 ** 12364 ** If the file does not exist or is empty but its name looks like a ZIP 12365 ** archive and the dfltZip flag is true, then assume it is a ZIP archive. 12366 ** Otherwise, assume an ordinary database regardless of the filename if 12367 ** the type cannot be determined from content. 12368 */ 12369 int deduceDatabaseType(const char *zName, int dfltZip){ 12370 FILE *f = fopen(zName, "rb"); 12371 size_t n; 12372 int rc = SHELL_OPEN_UNSPEC; 12373 char zBuf[100]; 12374 if( f==0 ){ 12375 if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 12376 return SHELL_OPEN_ZIPFILE; 12377 }else{ 12378 return SHELL_OPEN_NORMAL; 12379 } 12380 } 12381 n = fread(zBuf, 16, 1, f); 12382 if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){ 12383 fclose(f); 12384 return SHELL_OPEN_NORMAL; 12385 } 12386 fseek(f, -25, SEEK_END); 12387 n = fread(zBuf, 25, 1, f); 12388 if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){ 12389 rc = SHELL_OPEN_APPENDVFS; 12390 }else{ 12391 fseek(f, -22, SEEK_END); 12392 n = fread(zBuf, 22, 1, f); 12393 if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05 12394 && zBuf[3]==0x06 ){ 12395 rc = SHELL_OPEN_ZIPFILE; 12396 }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 12397 rc = SHELL_OPEN_ZIPFILE; 12398 } 12399 } 12400 fclose(f); 12401 return rc; 12402 } 12403 12404 #ifdef SQLITE_ENABLE_DESERIALIZE 12405 /* 12406 ** Reconstruct an in-memory database using the output from the "dbtotxt" 12407 ** program. Read content from the file in p->zDbFilename. If p->zDbFilename 12408 ** is 0, then read from standard input. 12409 */ 12410 static unsigned char *readHexDb(ShellState *p, int *pnData){ 12411 unsigned char *a = 0; 12412 int nLine; 12413 int n = 0; 12414 int pgsz = 0; 12415 int iOffset = 0; 12416 int j, k; 12417 int rc; 12418 FILE *in; 12419 unsigned int x[16]; 12420 char zLine[1000]; 12421 if( p->zDbFilename ){ 12422 in = fopen(p->zDbFilename, "r"); 12423 if( in==0 ){ 12424 utf8_printf(stderr, "cannot open \"%s\" for reading\n", p->zDbFilename); 12425 return 0; 12426 } 12427 nLine = 0; 12428 }else{ 12429 in = p->in; 12430 nLine = p->lineno; 12431 if( in==0 ) in = stdin; 12432 } 12433 *pnData = 0; 12434 nLine++; 12435 if( fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error; 12436 rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz); 12437 if( rc!=2 ) goto readHexDb_error; 12438 if( n<0 ) goto readHexDb_error; 12439 a = sqlite3_malloc( n ? n : 1 ); 12440 if( a==0 ){ 12441 utf8_printf(stderr, "Out of memory!\n"); 12442 goto readHexDb_error; 12443 } 12444 memset(a, 0, n); 12445 if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){ 12446 utf8_printf(stderr, "invalid pagesize\n"); 12447 goto readHexDb_error; 12448 } 12449 for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){ 12450 rc = sscanf(zLine, "| page %d offset %d", &j, &k); 12451 if( rc==2 ){ 12452 iOffset = k; 12453 continue; 12454 } 12455 if( strncmp(zLine, "| end ", 6)==0 ){ 12456 break; 12457 } 12458 rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", 12459 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7], 12460 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]); 12461 if( rc==17 ){ 12462 k = iOffset+j; 12463 if( k+16<=n ){ 12464 int ii; 12465 for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff; 12466 } 12467 } 12468 } 12469 *pnData = n; 12470 if( in!=p->in ){ 12471 fclose(in); 12472 }else{ 12473 p->lineno = nLine; 12474 } 12475 return a; 12476 12477 readHexDb_error: 12478 if( in!=p->in ){ 12479 fclose(in); 12480 }else{ 12481 while( fgets(zLine, sizeof(zLine), p->in)!=0 ){ 12482 nLine++; 12483 if(strncmp(zLine, "| end ", 6)==0 ) break; 12484 } 12485 p->lineno = nLine; 12486 } 12487 sqlite3_free(a); 12488 utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine); 12489 return 0; 12490 } 12491 #endif /* SQLITE_ENABLE_DESERIALIZE */ 12492 12493 /* 12494 ** Scalar function "shell_int32". The first argument to this function 12495 ** must be a blob. The second a non-negative integer. This function 12496 ** reads and returns a 32-bit big-endian integer from byte 12497 ** offset (4*<arg2>) of the blob. 12498 */ 12499 static void shellInt32( 12500 sqlite3_context *context, 12501 int argc, 12502 sqlite3_value **argv 12503 ){ 12504 const unsigned char *pBlob; 12505 int nBlob; 12506 int iInt; 12507 12508 UNUSED_PARAMETER(argc); 12509 nBlob = sqlite3_value_bytes(argv[0]); 12510 pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]); 12511 iInt = sqlite3_value_int(argv[1]); 12512 12513 if( iInt>=0 && (iInt+1)*4<=nBlob ){ 12514 const unsigned char *a = &pBlob[iInt*4]; 12515 sqlite3_int64 iVal = ((sqlite3_int64)a[0]<<24) 12516 + ((sqlite3_int64)a[1]<<16) 12517 + ((sqlite3_int64)a[2]<< 8) 12518 + ((sqlite3_int64)a[3]<< 0); 12519 sqlite3_result_int64(context, iVal); 12520 } 12521 } 12522 12523 /* 12524 ** Scalar function "shell_escape_crnl" used by the .recover command. 12525 ** The argument passed to this function is the output of built-in 12526 ** function quote(). If the first character of the input is "'", 12527 ** indicating that the value passed to quote() was a text value, 12528 ** then this function searches the input for "\n" and "\r" characters 12529 ** and adds a wrapper similar to the following: 12530 ** 12531 ** replace(replace(<input>, '\n', char(10), '\r', char(13)); 12532 ** 12533 ** Or, if the first character of the input is not "'", then a copy 12534 ** of the input is returned. 12535 */ 12536 static void shellEscapeCrnl( 12537 sqlite3_context *context, 12538 int argc, 12539 sqlite3_value **argv 12540 ){ 12541 const char *zText = (const char*)sqlite3_value_text(argv[0]); 12542 UNUSED_PARAMETER(argc); 12543 if( zText[0]=='\'' ){ 12544 int nText = sqlite3_value_bytes(argv[0]); 12545 int i; 12546 char zBuf1[20]; 12547 char zBuf2[20]; 12548 const char *zNL = 0; 12549 const char *zCR = 0; 12550 int nCR = 0; 12551 int nNL = 0; 12552 12553 for(i=0; zText[i]; i++){ 12554 if( zNL==0 && zText[i]=='\n' ){ 12555 zNL = unused_string(zText, "\\n", "\\012", zBuf1); 12556 nNL = (int)strlen(zNL); 12557 } 12558 if( zCR==0 && zText[i]=='\r' ){ 12559 zCR = unused_string(zText, "\\r", "\\015", zBuf2); 12560 nCR = (int)strlen(zCR); 12561 } 12562 } 12563 12564 if( zNL || zCR ){ 12565 int iOut = 0; 12566 i64 nMax = (nNL > nCR) ? nNL : nCR; 12567 i64 nAlloc = nMax * nText + (nMax+64)*2; 12568 char *zOut = (char*)sqlite3_malloc64(nAlloc); 12569 if( zOut==0 ){ 12570 sqlite3_result_error_nomem(context); 12571 return; 12572 } 12573 12574 if( zNL && zCR ){ 12575 memcpy(&zOut[iOut], "replace(replace(", 16); 12576 iOut += 16; 12577 }else{ 12578 memcpy(&zOut[iOut], "replace(", 8); 12579 iOut += 8; 12580 } 12581 for(i=0; zText[i]; i++){ 12582 if( zText[i]=='\n' ){ 12583 memcpy(&zOut[iOut], zNL, nNL); 12584 iOut += nNL; 12585 }else if( zText[i]=='\r' ){ 12586 memcpy(&zOut[iOut], zCR, nCR); 12587 iOut += nCR; 12588 }else{ 12589 zOut[iOut] = zText[i]; 12590 iOut++; 12591 } 12592 } 12593 12594 if( zNL ){ 12595 memcpy(&zOut[iOut], ",'", 2); iOut += 2; 12596 memcpy(&zOut[iOut], zNL, nNL); iOut += nNL; 12597 memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12; 12598 } 12599 if( zCR ){ 12600 memcpy(&zOut[iOut], ",'", 2); iOut += 2; 12601 memcpy(&zOut[iOut], zCR, nCR); iOut += nCR; 12602 memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12; 12603 } 12604 12605 sqlite3_result_text(context, zOut, iOut, SQLITE_TRANSIENT); 12606 sqlite3_free(zOut); 12607 return; 12608 } 12609 } 12610 12611 sqlite3_result_value(context, argv[0]); 12612 } 12613 12614 /* Flags for open_db(). 12615 ** 12616 ** The default behavior of open_db() is to exit(1) if the database fails to 12617 ** open. The OPEN_DB_KEEPALIVE flag changes that so that it prints an error 12618 ** but still returns without calling exit. 12619 ** 12620 ** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a 12621 ** ZIP archive if the file does not exist or is empty and its name matches 12622 ** the *.zip pattern. 12623 */ 12624 #define OPEN_DB_KEEPALIVE 0x001 /* Return after error if true */ 12625 #define OPEN_DB_ZIPFILE 0x002 /* Open as ZIP if name matches *.zip */ 12626 12627 /* 12628 ** Make sure the database is open. If it is not, then open it. If 12629 ** the database fails to open, print an error message and exit. 12630 */ 12631 static void open_db(ShellState *p, int openFlags){ 12632 if( p->db==0 ){ 12633 if( p->openMode==SHELL_OPEN_UNSPEC ){ 12634 if( p->zDbFilename==0 || p->zDbFilename[0]==0 ){ 12635 p->openMode = SHELL_OPEN_NORMAL; 12636 }else{ 12637 p->openMode = (u8)deduceDatabaseType(p->zDbFilename, 12638 (openFlags & OPEN_DB_ZIPFILE)!=0); 12639 } 12640 } 12641 switch( p->openMode ){ 12642 case SHELL_OPEN_APPENDVFS: { 12643 sqlite3_open_v2(p->zDbFilename, &p->db, 12644 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, "apndvfs"); 12645 break; 12646 } 12647 case SHELL_OPEN_HEXDB: 12648 case SHELL_OPEN_DESERIALIZE: { 12649 sqlite3_open(0, &p->db); 12650 break; 12651 } 12652 case SHELL_OPEN_ZIPFILE: { 12653 sqlite3_open(":memory:", &p->db); 12654 break; 12655 } 12656 case SHELL_OPEN_READONLY: { 12657 sqlite3_open_v2(p->zDbFilename, &p->db, SQLITE_OPEN_READONLY, 0); 12658 break; 12659 } 12660 case SHELL_OPEN_UNSPEC: 12661 case SHELL_OPEN_NORMAL: { 12662 sqlite3_open(p->zDbFilename, &p->db); 12663 break; 12664 } 12665 } 12666 globalDb = p->db; 12667 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){ 12668 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n", 12669 p->zDbFilename, sqlite3_errmsg(p->db)); 12670 if( openFlags & OPEN_DB_KEEPALIVE ){ 12671 sqlite3_open(":memory:", &p->db); 12672 return; 12673 } 12674 exit(1); 12675 } 12676 #ifndef SQLITE_OMIT_LOAD_EXTENSION 12677 sqlite3_enable_load_extension(p->db, 1); 12678 #endif 12679 sqlite3_fileio_init(p->db, 0, 0); 12680 sqlite3_shathree_init(p->db, 0, 0); 12681 sqlite3_completion_init(p->db, 0, 0); 12682 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 12683 sqlite3_dbdata_init(p->db, 0, 0); 12684 #endif 12685 #ifdef SQLITE_HAVE_ZLIB 12686 sqlite3_zipfile_init(p->db, 0, 0); 12687 sqlite3_sqlar_init(p->db, 0, 0); 12688 #endif 12689 sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0, 12690 shellAddSchemaName, 0, 0); 12691 sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, 0, 12692 shellModuleSchema, 0, 0); 12693 sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p, 12694 shellPutsFunc, 0, 0); 12695 sqlite3_create_function(p->db, "shell_escape_crnl", 1, SQLITE_UTF8, 0, 12696 shellEscapeCrnl, 0, 0); 12697 sqlite3_create_function(p->db, "shell_int32", 2, SQLITE_UTF8, 0, 12698 shellInt32, 0, 0); 12699 #ifndef SQLITE_NOHAVE_SYSTEM 12700 sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0, 12701 editFunc, 0, 0); 12702 sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0, 12703 editFunc, 0, 0); 12704 #endif 12705 if( p->openMode==SHELL_OPEN_ZIPFILE ){ 12706 char *zSql = sqlite3_mprintf( 12707 "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", p->zDbFilename); 12708 sqlite3_exec(p->db, zSql, 0, 0, 0); 12709 sqlite3_free(zSql); 12710 } 12711 #ifdef SQLITE_ENABLE_DESERIALIZE 12712 else 12713 if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){ 12714 int rc; 12715 int nData = 0; 12716 unsigned char *aData; 12717 if( p->openMode==SHELL_OPEN_DESERIALIZE ){ 12718 aData = (unsigned char*)readFile(p->zDbFilename, &nData); 12719 }else{ 12720 aData = readHexDb(p, &nData); 12721 if( aData==0 ){ 12722 return; 12723 } 12724 } 12725 rc = sqlite3_deserialize(p->db, "main", aData, nData, nData, 12726 SQLITE_DESERIALIZE_RESIZEABLE | 12727 SQLITE_DESERIALIZE_FREEONCLOSE); 12728 if( rc ){ 12729 utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc); 12730 } 12731 if( p->szMax>0 ){ 12732 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax); 12733 } 12734 } 12735 #endif 12736 } 12737 } 12738 12739 /* 12740 ** Attempt to close the databaes connection. Report errors. 12741 */ 12742 void close_db(sqlite3 *db){ 12743 int rc = sqlite3_close(db); 12744 if( rc ){ 12745 utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n", 12746 rc, sqlite3_errmsg(db)); 12747 } 12748 } 12749 12750 #if HAVE_READLINE || HAVE_EDITLINE 12751 /* 12752 ** Readline completion callbacks 12753 */ 12754 static char *readline_completion_generator(const char *text, int state){ 12755 static sqlite3_stmt *pStmt = 0; 12756 char *zRet; 12757 if( state==0 ){ 12758 char *zSql; 12759 sqlite3_finalize(pStmt); 12760 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 12761 " FROM completion(%Q) ORDER BY 1", text); 12762 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 12763 sqlite3_free(zSql); 12764 } 12765 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 12766 zRet = strdup((const char*)sqlite3_column_text(pStmt, 0)); 12767 }else{ 12768 sqlite3_finalize(pStmt); 12769 pStmt = 0; 12770 zRet = 0; 12771 } 12772 return zRet; 12773 } 12774 static char **readline_completion(const char *zText, int iStart, int iEnd){ 12775 rl_attempted_completion_over = 1; 12776 return rl_completion_matches(zText, readline_completion_generator); 12777 } 12778 12779 #elif HAVE_LINENOISE 12780 /* 12781 ** Linenoise completion callback 12782 */ 12783 static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){ 12784 int nLine = strlen30(zLine); 12785 int i, iStart; 12786 sqlite3_stmt *pStmt = 0; 12787 char *zSql; 12788 char zBuf[1000]; 12789 12790 if( nLine>sizeof(zBuf)-30 ) return; 12791 if( zLine[0]=='.' || zLine[0]=='#') return; 12792 for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){} 12793 if( i==nLine-1 ) return; 12794 iStart = i+1; 12795 memcpy(zBuf, zLine, iStart); 12796 zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 12797 " FROM completion(%Q,%Q) ORDER BY 1", 12798 &zLine[iStart], zLine); 12799 sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 12800 sqlite3_free(zSql); 12801 sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */ 12802 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 12803 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0); 12804 int nCompletion = sqlite3_column_bytes(pStmt, 0); 12805 if( iStart+nCompletion < sizeof(zBuf)-1 ){ 12806 memcpy(zBuf+iStart, zCompletion, nCompletion+1); 12807 linenoiseAddCompletion(lc, zBuf); 12808 } 12809 } 12810 sqlite3_finalize(pStmt); 12811 } 12812 #endif 12813 12814 /* 12815 ** Do C-language style dequoting. 12816 ** 12817 ** \a -> alarm 12818 ** \b -> backspace 12819 ** \t -> tab 12820 ** \n -> newline 12821 ** \v -> vertical tab 12822 ** \f -> form feed 12823 ** \r -> carriage return 12824 ** \s -> space 12825 ** \" -> " 12826 ** \' -> ' 12827 ** \\ -> backslash 12828 ** \NNN -> ascii character NNN in octal 12829 */ 12830 static void resolve_backslashes(char *z){ 12831 int i, j; 12832 char c; 12833 while( *z && *z!='\\' ) z++; 12834 for(i=j=0; (c = z[i])!=0; i++, j++){ 12835 if( c=='\\' && z[i+1]!=0 ){ 12836 c = z[++i]; 12837 if( c=='a' ){ 12838 c = '\a'; 12839 }else if( c=='b' ){ 12840 c = '\b'; 12841 }else if( c=='t' ){ 12842 c = '\t'; 12843 }else if( c=='n' ){ 12844 c = '\n'; 12845 }else if( c=='v' ){ 12846 c = '\v'; 12847 }else if( c=='f' ){ 12848 c = '\f'; 12849 }else if( c=='r' ){ 12850 c = '\r'; 12851 }else if( c=='"' ){ 12852 c = '"'; 12853 }else if( c=='\'' ){ 12854 c = '\''; 12855 }else if( c=='\\' ){ 12856 c = '\\'; 12857 }else if( c>='0' && c<='7' ){ 12858 c -= '0'; 12859 if( z[i+1]>='0' && z[i+1]<='7' ){ 12860 i++; 12861 c = (c<<3) + z[i] - '0'; 12862 if( z[i+1]>='0' && z[i+1]<='7' ){ 12863 i++; 12864 c = (c<<3) + z[i] - '0'; 12865 } 12866 } 12867 } 12868 } 12869 z[j] = c; 12870 } 12871 if( j<i ) z[j] = 0; 12872 } 12873 12874 /* 12875 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0 12876 ** for TRUE and FALSE. Return the integer value if appropriate. 12877 */ 12878 static int booleanValue(const char *zArg){ 12879 int i; 12880 if( zArg[0]=='0' && zArg[1]=='x' ){ 12881 for(i=2; hexDigitValue(zArg[i])>=0; i++){} 12882 }else{ 12883 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){} 12884 } 12885 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff); 12886 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){ 12887 return 1; 12888 } 12889 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){ 12890 return 0; 12891 } 12892 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", 12893 zArg); 12894 return 0; 12895 } 12896 12897 /* 12898 ** Set or clear a shell flag according to a boolean value. 12899 */ 12900 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){ 12901 if( booleanValue(zArg) ){ 12902 ShellSetFlag(p, mFlag); 12903 }else{ 12904 ShellClearFlag(p, mFlag); 12905 } 12906 } 12907 12908 /* 12909 ** Close an output file, assuming it is not stderr or stdout 12910 */ 12911 static void output_file_close(FILE *f){ 12912 if( f && f!=stdout && f!=stderr ) fclose(f); 12913 } 12914 12915 /* 12916 ** Try to open an output file. The names "stdout" and "stderr" are 12917 ** recognized and do the right thing. NULL is returned if the output 12918 ** filename is "off". 12919 */ 12920 static FILE *output_file_open(const char *zFile, int bTextMode){ 12921 FILE *f; 12922 if( strcmp(zFile,"stdout")==0 ){ 12923 f = stdout; 12924 }else if( strcmp(zFile, "stderr")==0 ){ 12925 f = stderr; 12926 }else if( strcmp(zFile, "off")==0 ){ 12927 f = 0; 12928 }else{ 12929 f = fopen(zFile, bTextMode ? "w" : "wb"); 12930 if( f==0 ){ 12931 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 12932 } 12933 } 12934 return f; 12935 } 12936 12937 #ifndef SQLITE_OMIT_TRACE 12938 /* 12939 ** A routine for handling output from sqlite3_trace(). 12940 */ 12941 static int sql_trace_callback( 12942 unsigned mType, /* The trace type */ 12943 void *pArg, /* The ShellState pointer */ 12944 void *pP, /* Usually a pointer to sqlite_stmt */ 12945 void *pX /* Auxiliary output */ 12946 ){ 12947 ShellState *p = (ShellState*)pArg; 12948 sqlite3_stmt *pStmt; 12949 const char *zSql; 12950 int nSql; 12951 if( p->traceOut==0 ) return 0; 12952 if( mType==SQLITE_TRACE_CLOSE ){ 12953 utf8_printf(p->traceOut, "-- closing database connection\n"); 12954 return 0; 12955 } 12956 if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){ 12957 zSql = (const char*)pX; 12958 }else{ 12959 pStmt = (sqlite3_stmt*)pP; 12960 switch( p->eTraceType ){ 12961 case SHELL_TRACE_EXPANDED: { 12962 zSql = sqlite3_expanded_sql(pStmt); 12963 break; 12964 } 12965 #ifdef SQLITE_ENABLE_NORMALIZE 12966 case SHELL_TRACE_NORMALIZED: { 12967 zSql = sqlite3_normalized_sql(pStmt); 12968 break; 12969 } 12970 #endif 12971 default: { 12972 zSql = sqlite3_sql(pStmt); 12973 break; 12974 } 12975 } 12976 } 12977 if( zSql==0 ) return 0; 12978 nSql = strlen30(zSql); 12979 while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; } 12980 switch( mType ){ 12981 case SQLITE_TRACE_ROW: 12982 case SQLITE_TRACE_STMT: { 12983 utf8_printf(p->traceOut, "%.*s;\n", nSql, zSql); 12984 break; 12985 } 12986 case SQLITE_TRACE_PROFILE: { 12987 sqlite3_int64 nNanosec = *(sqlite3_int64*)pX; 12988 utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", nSql, zSql, nNanosec); 12989 break; 12990 } 12991 } 12992 return 0; 12993 } 12994 #endif 12995 12996 /* 12997 ** A no-op routine that runs with the ".breakpoint" doc-command. This is 12998 ** a useful spot to set a debugger breakpoint. 12999 */ 13000 static void test_breakpoint(void){ 13001 static int nCall = 0; 13002 nCall++; 13003 } 13004 13005 /* 13006 ** An object used to read a CSV and other files for import. 13007 */ 13008 typedef struct ImportCtx ImportCtx; 13009 struct ImportCtx { 13010 const char *zFile; /* Name of the input file */ 13011 FILE *in; /* Read the CSV text from this input stream */ 13012 char *z; /* Accumulated text for a field */ 13013 int n; /* Number of bytes in z */ 13014 int nAlloc; /* Space allocated for z[] */ 13015 int nLine; /* Current line number */ 13016 int bNotFirst; /* True if one or more bytes already read */ 13017 int cTerm; /* Character that terminated the most recent field */ 13018 int cColSep; /* The column separator character. (Usually ",") */ 13019 int cRowSep; /* The row separator character. (Usually "\n") */ 13020 }; 13021 13022 /* Append a single byte to z[] */ 13023 static void import_append_char(ImportCtx *p, int c){ 13024 if( p->n+1>=p->nAlloc ){ 13025 p->nAlloc += p->nAlloc + 100; 13026 p->z = sqlite3_realloc64(p->z, p->nAlloc); 13027 if( p->z==0 ) shell_out_of_memory(); 13028 } 13029 p->z[p->n++] = (char)c; 13030 } 13031 13032 /* Read a single field of CSV text. Compatible with rfc4180 and extended 13033 ** with the option of having a separator other than ",". 13034 ** 13035 ** + Input comes from p->in. 13036 ** + Store results in p->z of length p->n. Space to hold p->z comes 13037 ** from sqlite3_malloc64(). 13038 ** + Use p->cSep as the column separator. The default is ",". 13039 ** + Use p->rSep as the row separator. The default is "\n". 13040 ** + Keep track of the line number in p->nLine. 13041 ** + Store the character that terminates the field in p->cTerm. Store 13042 ** EOF on end-of-file. 13043 ** + Report syntax errors on stderr 13044 */ 13045 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){ 13046 int c; 13047 int cSep = p->cColSep; 13048 int rSep = p->cRowSep; 13049 p->n = 0; 13050 c = fgetc(p->in); 13051 if( c==EOF || seenInterrupt ){ 13052 p->cTerm = EOF; 13053 return 0; 13054 } 13055 if( c=='"' ){ 13056 int pc, ppc; 13057 int startLine = p->nLine; 13058 int cQuote = c; 13059 pc = ppc = 0; 13060 while( 1 ){ 13061 c = fgetc(p->in); 13062 if( c==rSep ) p->nLine++; 13063 if( c==cQuote ){ 13064 if( pc==cQuote ){ 13065 pc = 0; 13066 continue; 13067 } 13068 } 13069 if( (c==cSep && pc==cQuote) 13070 || (c==rSep && pc==cQuote) 13071 || (c==rSep && pc=='\r' && ppc==cQuote) 13072 || (c==EOF && pc==cQuote) 13073 ){ 13074 do{ p->n--; }while( p->z[p->n]!=cQuote ); 13075 p->cTerm = c; 13076 break; 13077 } 13078 if( pc==cQuote && c!='\r' ){ 13079 utf8_printf(stderr, "%s:%d: unescaped %c character\n", 13080 p->zFile, p->nLine, cQuote); 13081 } 13082 if( c==EOF ){ 13083 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n", 13084 p->zFile, startLine, cQuote); 13085 p->cTerm = c; 13086 break; 13087 } 13088 import_append_char(p, c); 13089 ppc = pc; 13090 pc = c; 13091 } 13092 }else{ 13093 /* If this is the first field being parsed and it begins with the 13094 ** UTF-8 BOM (0xEF BB BF) then skip the BOM */ 13095 if( (c&0xff)==0xef && p->bNotFirst==0 ){ 13096 import_append_char(p, c); 13097 c = fgetc(p->in); 13098 if( (c&0xff)==0xbb ){ 13099 import_append_char(p, c); 13100 c = fgetc(p->in); 13101 if( (c&0xff)==0xbf ){ 13102 p->bNotFirst = 1; 13103 p->n = 0; 13104 return csv_read_one_field(p); 13105 } 13106 } 13107 } 13108 while( c!=EOF && c!=cSep && c!=rSep ){ 13109 import_append_char(p, c); 13110 c = fgetc(p->in); 13111 } 13112 if( c==rSep ){ 13113 p->nLine++; 13114 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--; 13115 } 13116 p->cTerm = c; 13117 } 13118 if( p->z ) p->z[p->n] = 0; 13119 p->bNotFirst = 1; 13120 return p->z; 13121 } 13122 13123 /* Read a single field of ASCII delimited text. 13124 ** 13125 ** + Input comes from p->in. 13126 ** + Store results in p->z of length p->n. Space to hold p->z comes 13127 ** from sqlite3_malloc64(). 13128 ** + Use p->cSep as the column separator. The default is "\x1F". 13129 ** + Use p->rSep as the row separator. The default is "\x1E". 13130 ** + Keep track of the row number in p->nLine. 13131 ** + Store the character that terminates the field in p->cTerm. Store 13132 ** EOF on end-of-file. 13133 ** + Report syntax errors on stderr 13134 */ 13135 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){ 13136 int c; 13137 int cSep = p->cColSep; 13138 int rSep = p->cRowSep; 13139 p->n = 0; 13140 c = fgetc(p->in); 13141 if( c==EOF || seenInterrupt ){ 13142 p->cTerm = EOF; 13143 return 0; 13144 } 13145 while( c!=EOF && c!=cSep && c!=rSep ){ 13146 import_append_char(p, c); 13147 c = fgetc(p->in); 13148 } 13149 if( c==rSep ){ 13150 p->nLine++; 13151 } 13152 p->cTerm = c; 13153 if( p->z ) p->z[p->n] = 0; 13154 return p->z; 13155 } 13156 13157 /* 13158 ** Try to transfer data for table zTable. If an error is seen while 13159 ** moving forward, try to go backwards. The backwards movement won't 13160 ** work for WITHOUT ROWID tables. 13161 */ 13162 static void tryToCloneData( 13163 ShellState *p, 13164 sqlite3 *newDb, 13165 const char *zTable 13166 ){ 13167 sqlite3_stmt *pQuery = 0; 13168 sqlite3_stmt *pInsert = 0; 13169 char *zQuery = 0; 13170 char *zInsert = 0; 13171 int rc; 13172 int i, j, n; 13173 int nTable = strlen30(zTable); 13174 int k = 0; 13175 int cnt = 0; 13176 const int spinRate = 10000; 13177 13178 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); 13179 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 13180 if( rc ){ 13181 utf8_printf(stderr, "Error %d: %s on [%s]\n", 13182 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 13183 zQuery); 13184 goto end_data_xfer; 13185 } 13186 n = sqlite3_column_count(pQuery); 13187 zInsert = sqlite3_malloc64(200 + nTable + n*3); 13188 if( zInsert==0 ) shell_out_of_memory(); 13189 sqlite3_snprintf(200+nTable,zInsert, 13190 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable); 13191 i = strlen30(zInsert); 13192 for(j=1; j<n; j++){ 13193 memcpy(zInsert+i, ",?", 2); 13194 i += 2; 13195 } 13196 memcpy(zInsert+i, ");", 3); 13197 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0); 13198 if( rc ){ 13199 utf8_printf(stderr, "Error %d: %s on [%s]\n", 13200 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), 13201 zQuery); 13202 goto end_data_xfer; 13203 } 13204 for(k=0; k<2; k++){ 13205 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 13206 for(i=0; i<n; i++){ 13207 switch( sqlite3_column_type(pQuery, i) ){ 13208 case SQLITE_NULL: { 13209 sqlite3_bind_null(pInsert, i+1); 13210 break; 13211 } 13212 case SQLITE_INTEGER: { 13213 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i)); 13214 break; 13215 } 13216 case SQLITE_FLOAT: { 13217 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i)); 13218 break; 13219 } 13220 case SQLITE_TEXT: { 13221 sqlite3_bind_text(pInsert, i+1, 13222 (const char*)sqlite3_column_text(pQuery,i), 13223 -1, SQLITE_STATIC); 13224 break; 13225 } 13226 case SQLITE_BLOB: { 13227 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i), 13228 sqlite3_column_bytes(pQuery,i), 13229 SQLITE_STATIC); 13230 break; 13231 } 13232 } 13233 } /* End for */ 13234 rc = sqlite3_step(pInsert); 13235 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){ 13236 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb), 13237 sqlite3_errmsg(newDb)); 13238 } 13239 sqlite3_reset(pInsert); 13240 cnt++; 13241 if( (cnt%spinRate)==0 ){ 13242 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]); 13243 fflush(stdout); 13244 } 13245 } /* End while */ 13246 if( rc==SQLITE_DONE ) break; 13247 sqlite3_finalize(pQuery); 13248 sqlite3_free(zQuery); 13249 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;", 13250 zTable); 13251 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 13252 if( rc ){ 13253 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable); 13254 break; 13255 } 13256 } /* End for(k=0...) */ 13257 13258 end_data_xfer: 13259 sqlite3_finalize(pQuery); 13260 sqlite3_finalize(pInsert); 13261 sqlite3_free(zQuery); 13262 sqlite3_free(zInsert); 13263 } 13264 13265 13266 /* 13267 ** Try to transfer all rows of the schema that match zWhere. For 13268 ** each row, invoke xForEach() on the object defined by that row. 13269 ** If an error is encountered while moving forward through the 13270 ** sqlite_master table, try again moving backwards. 13271 */ 13272 static void tryToCloneSchema( 13273 ShellState *p, 13274 sqlite3 *newDb, 13275 const char *zWhere, 13276 void (*xForEach)(ShellState*,sqlite3*,const char*) 13277 ){ 13278 sqlite3_stmt *pQuery = 0; 13279 char *zQuery = 0; 13280 int rc; 13281 const unsigned char *zName; 13282 const unsigned char *zSql; 13283 char *zErrMsg = 0; 13284 13285 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" 13286 " WHERE %s", zWhere); 13287 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 13288 if( rc ){ 13289 utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 13290 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 13291 zQuery); 13292 goto end_schema_xfer; 13293 } 13294 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 13295 zName = sqlite3_column_text(pQuery, 0); 13296 zSql = sqlite3_column_text(pQuery, 1); 13297 printf("%s... ", zName); fflush(stdout); 13298 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 13299 if( zErrMsg ){ 13300 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 13301 sqlite3_free(zErrMsg); 13302 zErrMsg = 0; 13303 } 13304 if( xForEach ){ 13305 xForEach(p, newDb, (const char*)zName); 13306 } 13307 printf("done\n"); 13308 } 13309 if( rc!=SQLITE_DONE ){ 13310 sqlite3_finalize(pQuery); 13311 sqlite3_free(zQuery); 13312 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" 13313 " WHERE %s ORDER BY rowid DESC", zWhere); 13314 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 13315 if( rc ){ 13316 utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 13317 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 13318 zQuery); 13319 goto end_schema_xfer; 13320 } 13321 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 13322 zName = sqlite3_column_text(pQuery, 0); 13323 zSql = sqlite3_column_text(pQuery, 1); 13324 printf("%s... ", zName); fflush(stdout); 13325 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 13326 if( zErrMsg ){ 13327 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 13328 sqlite3_free(zErrMsg); 13329 zErrMsg = 0; 13330 } 13331 if( xForEach ){ 13332 xForEach(p, newDb, (const char*)zName); 13333 } 13334 printf("done\n"); 13335 } 13336 } 13337 end_schema_xfer: 13338 sqlite3_finalize(pQuery); 13339 sqlite3_free(zQuery); 13340 } 13341 13342 /* 13343 ** Open a new database file named "zNewDb". Try to recover as much information 13344 ** as possible out of the main database (which might be corrupt) and write it 13345 ** into zNewDb. 13346 */ 13347 static void tryToClone(ShellState *p, const char *zNewDb){ 13348 int rc; 13349 sqlite3 *newDb = 0; 13350 if( access(zNewDb,0)==0 ){ 13351 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb); 13352 return; 13353 } 13354 rc = sqlite3_open(zNewDb, &newDb); 13355 if( rc ){ 13356 utf8_printf(stderr, "Cannot create output database: %s\n", 13357 sqlite3_errmsg(newDb)); 13358 }else{ 13359 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0); 13360 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0); 13361 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData); 13362 tryToCloneSchema(p, newDb, "type!='table'", 0); 13363 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0); 13364 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 13365 } 13366 close_db(newDb); 13367 } 13368 13369 /* 13370 ** Change the output file back to stdout. 13371 ** 13372 ** If the p->doXdgOpen flag is set, that means the output was being 13373 ** redirected to a temporary file named by p->zTempFile. In that case, 13374 ** launch start/open/xdg-open on that temporary file. 13375 */ 13376 static void output_reset(ShellState *p){ 13377 if( p->outfile[0]=='|' ){ 13378 #ifndef SQLITE_OMIT_POPEN 13379 pclose(p->out); 13380 #endif 13381 }else{ 13382 output_file_close(p->out); 13383 #ifndef SQLITE_NOHAVE_SYSTEM 13384 if( p->doXdgOpen ){ 13385 const char *zXdgOpenCmd = 13386 #if defined(_WIN32) 13387 "start"; 13388 #elif defined(__APPLE__) 13389 "open"; 13390 #else 13391 "xdg-open"; 13392 #endif 13393 char *zCmd; 13394 zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile); 13395 if( system(zCmd) ){ 13396 utf8_printf(stderr, "Failed: [%s]\n", zCmd); 13397 } 13398 sqlite3_free(zCmd); 13399 outputModePop(p); 13400 p->doXdgOpen = 0; 13401 sqlite3_sleep(100); 13402 } 13403 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 13404 } 13405 p->outfile[0] = 0; 13406 p->out = stdout; 13407 } 13408 13409 /* 13410 ** Run an SQL command and return the single integer result. 13411 */ 13412 static int db_int(ShellState *p, const char *zSql){ 13413 sqlite3_stmt *pStmt; 13414 int res = 0; 13415 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 13416 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ 13417 res = sqlite3_column_int(pStmt,0); 13418 } 13419 sqlite3_finalize(pStmt); 13420 return res; 13421 } 13422 13423 /* 13424 ** Convert a 2-byte or 4-byte big-endian integer into a native integer 13425 */ 13426 static unsigned int get2byteInt(unsigned char *a){ 13427 return (a[0]<<8) + a[1]; 13428 } 13429 static unsigned int get4byteInt(unsigned char *a){ 13430 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3]; 13431 } 13432 13433 /* 13434 ** Implementation of the ".info" command. 13435 ** 13436 ** Return 1 on error, 2 to exit, and 0 otherwise. 13437 */ 13438 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){ 13439 static const struct { const char *zName; int ofst; } aField[] = { 13440 { "file change counter:", 24 }, 13441 { "database page count:", 28 }, 13442 { "freelist page count:", 36 }, 13443 { "schema cookie:", 40 }, 13444 { "schema format:", 44 }, 13445 { "default cache size:", 48 }, 13446 { "autovacuum top root:", 52 }, 13447 { "incremental vacuum:", 64 }, 13448 { "text encoding:", 56 }, 13449 { "user version:", 60 }, 13450 { "application id:", 68 }, 13451 { "software version:", 96 }, 13452 }; 13453 static const struct { const char *zName; const char *zSql; } aQuery[] = { 13454 { "number of tables:", 13455 "SELECT count(*) FROM %s WHERE type='table'" }, 13456 { "number of indexes:", 13457 "SELECT count(*) FROM %s WHERE type='index'" }, 13458 { "number of triggers:", 13459 "SELECT count(*) FROM %s WHERE type='trigger'" }, 13460 { "number of views:", 13461 "SELECT count(*) FROM %s WHERE type='view'" }, 13462 { "schema size:", 13463 "SELECT total(length(sql)) FROM %s" }, 13464 }; 13465 int i, rc; 13466 unsigned iDataVersion; 13467 char *zSchemaTab; 13468 char *zDb = nArg>=2 ? azArg[1] : "main"; 13469 sqlite3_stmt *pStmt = 0; 13470 unsigned char aHdr[100]; 13471 open_db(p, 0); 13472 if( p->db==0 ) return 1; 13473 rc = sqlite3_prepare_v2(p->db, 13474 "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1", 13475 -1, &pStmt, 0); 13476 if( rc ){ 13477 if( !sqlite3_compileoption_used("ENABLE_DBPAGE_VTAB") ){ 13478 utf8_printf(stderr, "the \".dbinfo\" command requires the " 13479 "-DSQLITE_ENABLE_DBPAGE_VTAB compile-time options\n"); 13480 }else{ 13481 utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db)); 13482 } 13483 sqlite3_finalize(pStmt); 13484 return 1; 13485 } 13486 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC); 13487 if( sqlite3_step(pStmt)==SQLITE_ROW 13488 && sqlite3_column_bytes(pStmt,0)>100 13489 ){ 13490 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100); 13491 sqlite3_finalize(pStmt); 13492 }else{ 13493 raw_printf(stderr, "unable to read database header\n"); 13494 sqlite3_finalize(pStmt); 13495 return 1; 13496 } 13497 i = get2byteInt(aHdr+16); 13498 if( i==1 ) i = 65536; 13499 utf8_printf(p->out, "%-20s %d\n", "database page size:", i); 13500 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]); 13501 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]); 13502 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]); 13503 for(i=0; i<ArraySize(aField); i++){ 13504 int ofst = aField[i].ofst; 13505 unsigned int val = get4byteInt(aHdr + ofst); 13506 utf8_printf(p->out, "%-20s %u", aField[i].zName, val); 13507 switch( ofst ){ 13508 case 56: { 13509 if( val==1 ) raw_printf(p->out, " (utf8)"); 13510 if( val==2 ) raw_printf(p->out, " (utf16le)"); 13511 if( val==3 ) raw_printf(p->out, " (utf16be)"); 13512 } 13513 } 13514 raw_printf(p->out, "\n"); 13515 } 13516 if( zDb==0 ){ 13517 zSchemaTab = sqlite3_mprintf("main.sqlite_master"); 13518 }else if( strcmp(zDb,"temp")==0 ){ 13519 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master"); 13520 }else{ 13521 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb); 13522 } 13523 for(i=0; i<ArraySize(aQuery); i++){ 13524 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab); 13525 int val = db_int(p, zSql); 13526 sqlite3_free(zSql); 13527 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val); 13528 } 13529 sqlite3_free(zSchemaTab); 13530 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion); 13531 utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion); 13532 return 0; 13533 } 13534 13535 /* 13536 ** Print the current sqlite3_errmsg() value to stderr and return 1. 13537 */ 13538 static int shellDatabaseError(sqlite3 *db){ 13539 const char *zErr = sqlite3_errmsg(db); 13540 utf8_printf(stderr, "Error: %s\n", zErr); 13541 return 1; 13542 } 13543 13544 /* 13545 ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE 13546 ** if they match and FALSE (0) if they do not match. 13547 ** 13548 ** Globbing rules: 13549 ** 13550 ** '*' Matches any sequence of zero or more characters. 13551 ** 13552 ** '?' Matches exactly one character. 13553 ** 13554 ** [...] Matches one character from the enclosed list of 13555 ** characters. 13556 ** 13557 ** [^...] Matches one character not in the enclosed list. 13558 ** 13559 ** '#' Matches any sequence of one or more digits with an 13560 ** optional + or - sign in front 13561 ** 13562 ** ' ' Any span of whitespace matches any other span of 13563 ** whitespace. 13564 ** 13565 ** Extra whitespace at the end of z[] is ignored. 13566 */ 13567 static int testcase_glob(const char *zGlob, const char *z){ 13568 int c, c2; 13569 int invert; 13570 int seen; 13571 13572 while( (c = (*(zGlob++)))!=0 ){ 13573 if( IsSpace(c) ){ 13574 if( !IsSpace(*z) ) return 0; 13575 while( IsSpace(*zGlob) ) zGlob++; 13576 while( IsSpace(*z) ) z++; 13577 }else if( c=='*' ){ 13578 while( (c=(*(zGlob++))) == '*' || c=='?' ){ 13579 if( c=='?' && (*(z++))==0 ) return 0; 13580 } 13581 if( c==0 ){ 13582 return 1; 13583 }else if( c=='[' ){ 13584 while( *z && testcase_glob(zGlob-1,z)==0 ){ 13585 z++; 13586 } 13587 return (*z)!=0; 13588 } 13589 while( (c2 = (*(z++)))!=0 ){ 13590 while( c2!=c ){ 13591 c2 = *(z++); 13592 if( c2==0 ) return 0; 13593 } 13594 if( testcase_glob(zGlob,z) ) return 1; 13595 } 13596 return 0; 13597 }else if( c=='?' ){ 13598 if( (*(z++))==0 ) return 0; 13599 }else if( c=='[' ){ 13600 int prior_c = 0; 13601 seen = 0; 13602 invert = 0; 13603 c = *(z++); 13604 if( c==0 ) return 0; 13605 c2 = *(zGlob++); 13606 if( c2=='^' ){ 13607 invert = 1; 13608 c2 = *(zGlob++); 13609 } 13610 if( c2==']' ){ 13611 if( c==']' ) seen = 1; 13612 c2 = *(zGlob++); 13613 } 13614 while( c2 && c2!=']' ){ 13615 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){ 13616 c2 = *(zGlob++); 13617 if( c>=prior_c && c<=c2 ) seen = 1; 13618 prior_c = 0; 13619 }else{ 13620 if( c==c2 ){ 13621 seen = 1; 13622 } 13623 prior_c = c2; 13624 } 13625 c2 = *(zGlob++); 13626 } 13627 if( c2==0 || (seen ^ invert)==0 ) return 0; 13628 }else if( c=='#' ){ 13629 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++; 13630 if( !IsDigit(z[0]) ) return 0; 13631 z++; 13632 while( IsDigit(z[0]) ){ z++; } 13633 }else{ 13634 if( c!=(*(z++)) ) return 0; 13635 } 13636 } 13637 while( IsSpace(*z) ){ z++; } 13638 return *z==0; 13639 } 13640 13641 13642 /* 13643 ** Compare the string as a command-line option with either one or two 13644 ** initial "-" characters. 13645 */ 13646 static int optionMatch(const char *zStr, const char *zOpt){ 13647 if( zStr[0]!='-' ) return 0; 13648 zStr++; 13649 if( zStr[0]=='-' ) zStr++; 13650 return strcmp(zStr, zOpt)==0; 13651 } 13652 13653 /* 13654 ** Delete a file. 13655 */ 13656 int shellDeleteFile(const char *zFilename){ 13657 int rc; 13658 #ifdef _WIN32 13659 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename); 13660 rc = _wunlink(z); 13661 sqlite3_free(z); 13662 #else 13663 rc = unlink(zFilename); 13664 #endif 13665 return rc; 13666 } 13667 13668 /* 13669 ** Try to delete the temporary file (if there is one) and free the 13670 ** memory used to hold the name of the temp file. 13671 */ 13672 static void clearTempFile(ShellState *p){ 13673 if( p->zTempFile==0 ) return; 13674 if( p->doXdgOpen ) return; 13675 if( shellDeleteFile(p->zTempFile) ) return; 13676 sqlite3_free(p->zTempFile); 13677 p->zTempFile = 0; 13678 } 13679 13680 /* 13681 ** Create a new temp file name with the given suffix. 13682 */ 13683 static void newTempFile(ShellState *p, const char *zSuffix){ 13684 clearTempFile(p); 13685 sqlite3_free(p->zTempFile); 13686 p->zTempFile = 0; 13687 if( p->db ){ 13688 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile); 13689 } 13690 if( p->zTempFile==0 ){ 13691 sqlite3_uint64 r; 13692 sqlite3_randomness(sizeof(r), &r); 13693 p->zTempFile = sqlite3_mprintf("temp%llx.%s", r, zSuffix); 13694 }else{ 13695 p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix); 13696 } 13697 if( p->zTempFile==0 ){ 13698 raw_printf(stderr, "out of memory\n"); 13699 exit(1); 13700 } 13701 } 13702 13703 13704 /* 13705 ** The implementation of SQL scalar function fkey_collate_clause(), used 13706 ** by the ".lint fkey-indexes" command. This scalar function is always 13707 ** called with four arguments - the parent table name, the parent column name, 13708 ** the child table name and the child column name. 13709 ** 13710 ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col') 13711 ** 13712 ** If either of the named tables or columns do not exist, this function 13713 ** returns an empty string. An empty string is also returned if both tables 13714 ** and columns exist but have the same default collation sequence. Or, 13715 ** if both exist but the default collation sequences are different, this 13716 ** function returns the string " COLLATE <parent-collation>", where 13717 ** <parent-collation> is the default collation sequence of the parent column. 13718 */ 13719 static void shellFkeyCollateClause( 13720 sqlite3_context *pCtx, 13721 int nVal, 13722 sqlite3_value **apVal 13723 ){ 13724 sqlite3 *db = sqlite3_context_db_handle(pCtx); 13725 const char *zParent; 13726 const char *zParentCol; 13727 const char *zParentSeq; 13728 const char *zChild; 13729 const char *zChildCol; 13730 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */ 13731 int rc; 13732 13733 assert( nVal==4 ); 13734 zParent = (const char*)sqlite3_value_text(apVal[0]); 13735 zParentCol = (const char*)sqlite3_value_text(apVal[1]); 13736 zChild = (const char*)sqlite3_value_text(apVal[2]); 13737 zChildCol = (const char*)sqlite3_value_text(apVal[3]); 13738 13739 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC); 13740 rc = sqlite3_table_column_metadata( 13741 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0 13742 ); 13743 if( rc==SQLITE_OK ){ 13744 rc = sqlite3_table_column_metadata( 13745 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0 13746 ); 13747 } 13748 13749 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){ 13750 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq); 13751 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT); 13752 sqlite3_free(z); 13753 } 13754 } 13755 13756 13757 /* 13758 ** The implementation of dot-command ".lint fkey-indexes". 13759 */ 13760 static int lintFkeyIndexes( 13761 ShellState *pState, /* Current shell tool state */ 13762 char **azArg, /* Array of arguments passed to dot command */ 13763 int nArg /* Number of entries in azArg[] */ 13764 ){ 13765 sqlite3 *db = pState->db; /* Database handle to query "main" db of */ 13766 FILE *out = pState->out; /* Stream to write non-error output to */ 13767 int bVerbose = 0; /* If -verbose is present */ 13768 int bGroupByParent = 0; /* If -groupbyparent is present */ 13769 int i; /* To iterate through azArg[] */ 13770 const char *zIndent = ""; /* How much to indent CREATE INDEX by */ 13771 int rc; /* Return code */ 13772 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */ 13773 13774 /* 13775 ** This SELECT statement returns one row for each foreign key constraint 13776 ** in the schema of the main database. The column values are: 13777 ** 13778 ** 0. The text of an SQL statement similar to: 13779 ** 13780 ** "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?" 13781 ** 13782 ** This SELECT is similar to the one that the foreign keys implementation 13783 ** needs to run internally on child tables. If there is an index that can 13784 ** be used to optimize this query, then it can also be used by the FK 13785 ** implementation to optimize DELETE or UPDATE statements on the parent 13786 ** table. 13787 ** 13788 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by 13789 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema 13790 ** contains an index that can be used to optimize the query. 13791 ** 13792 ** 2. Human readable text that describes the child table and columns. e.g. 13793 ** 13794 ** "child_table(child_key1, child_key2)" 13795 ** 13796 ** 3. Human readable text that describes the parent table and columns. e.g. 13797 ** 13798 ** "parent_table(parent_key1, parent_key2)" 13799 ** 13800 ** 4. A full CREATE INDEX statement for an index that could be used to 13801 ** optimize DELETE or UPDATE statements on the parent table. e.g. 13802 ** 13803 ** "CREATE INDEX child_table_child_key ON child_table(child_key)" 13804 ** 13805 ** 5. The name of the parent table. 13806 ** 13807 ** These six values are used by the C logic below to generate the report. 13808 */ 13809 const char *zSql = 13810 "SELECT " 13811 " 'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '" 13812 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' " 13813 " || fkey_collate_clause(" 13814 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')" 13815 ", " 13816 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('" 13817 " || group_concat('*=?', ' AND ') || ')'" 13818 ", " 13819 " s.name || '(' || group_concat(f.[from], ', ') || ')'" 13820 ", " 13821 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'" 13822 ", " 13823 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))" 13824 " || ' ON ' || quote(s.name) || '('" 13825 " || group_concat(quote(f.[from]) ||" 13826 " fkey_collate_clause(" 13827 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')" 13828 " || ');'" 13829 ", " 13830 " f.[table] " 13831 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f " 13832 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) " 13833 "GROUP BY s.name, f.id " 13834 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)" 13835 ; 13836 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)"; 13837 13838 for(i=2; i<nArg; i++){ 13839 int n = strlen30(azArg[i]); 13840 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){ 13841 bVerbose = 1; 13842 } 13843 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){ 13844 bGroupByParent = 1; 13845 zIndent = " "; 13846 } 13847 else{ 13848 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n", 13849 azArg[0], azArg[1] 13850 ); 13851 return SQLITE_ERROR; 13852 } 13853 } 13854 13855 /* Register the fkey_collate_clause() SQL function */ 13856 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8, 13857 0, shellFkeyCollateClause, 0, 0 13858 ); 13859 13860 13861 if( rc==SQLITE_OK ){ 13862 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0); 13863 } 13864 if( rc==SQLITE_OK ){ 13865 sqlite3_bind_int(pSql, 1, bGroupByParent); 13866 } 13867 13868 if( rc==SQLITE_OK ){ 13869 int rc2; 13870 char *zPrev = 0; 13871 while( SQLITE_ROW==sqlite3_step(pSql) ){ 13872 int res = -1; 13873 sqlite3_stmt *pExplain = 0; 13874 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0); 13875 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1); 13876 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2); 13877 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3); 13878 const char *zCI = (const char*)sqlite3_column_text(pSql, 4); 13879 const char *zParent = (const char*)sqlite3_column_text(pSql, 5); 13880 13881 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 13882 if( rc!=SQLITE_OK ) break; 13883 if( SQLITE_ROW==sqlite3_step(pExplain) ){ 13884 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3); 13885 res = ( 13886 0==sqlite3_strglob(zGlob, zPlan) 13887 || 0==sqlite3_strglob(zGlobIPK, zPlan) 13888 ); 13889 } 13890 rc = sqlite3_finalize(pExplain); 13891 if( rc!=SQLITE_OK ) break; 13892 13893 if( res<0 ){ 13894 raw_printf(stderr, "Error: internal error"); 13895 break; 13896 }else{ 13897 if( bGroupByParent 13898 && (bVerbose || res==0) 13899 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev)) 13900 ){ 13901 raw_printf(out, "-- Parent table %s\n", zParent); 13902 sqlite3_free(zPrev); 13903 zPrev = sqlite3_mprintf("%s", zParent); 13904 } 13905 13906 if( res==0 ){ 13907 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget); 13908 }else if( bVerbose ){ 13909 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n", 13910 zIndent, zFrom, zTarget 13911 ); 13912 } 13913 } 13914 } 13915 sqlite3_free(zPrev); 13916 13917 if( rc!=SQLITE_OK ){ 13918 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 13919 } 13920 13921 rc2 = sqlite3_finalize(pSql); 13922 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){ 13923 rc = rc2; 13924 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 13925 } 13926 }else{ 13927 raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 13928 } 13929 13930 return rc; 13931 } 13932 13933 /* 13934 ** Implementation of ".lint" dot command. 13935 */ 13936 static int lintDotCommand( 13937 ShellState *pState, /* Current shell tool state */ 13938 char **azArg, /* Array of arguments passed to dot command */ 13939 int nArg /* Number of entries in azArg[] */ 13940 ){ 13941 int n; 13942 n = (nArg>=2 ? strlen30(azArg[1]) : 0); 13943 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage; 13944 return lintFkeyIndexes(pState, azArg, nArg); 13945 13946 usage: 13947 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]); 13948 raw_printf(stderr, "Where sub-commands are:\n"); 13949 raw_printf(stderr, " fkey-indexes\n"); 13950 return SQLITE_ERROR; 13951 } 13952 13953 #if !defined SQLITE_OMIT_VIRTUALTABLE 13954 static void shellPrepare( 13955 sqlite3 *db, 13956 int *pRc, 13957 const char *zSql, 13958 sqlite3_stmt **ppStmt 13959 ){ 13960 *ppStmt = 0; 13961 if( *pRc==SQLITE_OK ){ 13962 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); 13963 if( rc!=SQLITE_OK ){ 13964 raw_printf(stderr, "sql error: %s (%d)\n", 13965 sqlite3_errmsg(db), sqlite3_errcode(db) 13966 ); 13967 *pRc = rc; 13968 } 13969 } 13970 } 13971 13972 /* 13973 ** Create a prepared statement using printf-style arguments for the SQL. 13974 ** 13975 ** This routine is could be marked "static". But it is not always used, 13976 ** depending on compile-time options. By omitting the "static", we avoid 13977 ** nuisance compiler warnings about "defined but not used". 13978 */ 13979 void shellPreparePrintf( 13980 sqlite3 *db, 13981 int *pRc, 13982 sqlite3_stmt **ppStmt, 13983 const char *zFmt, 13984 ... 13985 ){ 13986 *ppStmt = 0; 13987 if( *pRc==SQLITE_OK ){ 13988 va_list ap; 13989 char *z; 13990 va_start(ap, zFmt); 13991 z = sqlite3_vmprintf(zFmt, ap); 13992 va_end(ap); 13993 if( z==0 ){ 13994 *pRc = SQLITE_NOMEM; 13995 }else{ 13996 shellPrepare(db, pRc, z, ppStmt); 13997 sqlite3_free(z); 13998 } 13999 } 14000 } 14001 14002 /* Finalize the prepared statement created using shellPreparePrintf(). 14003 ** 14004 ** This routine is could be marked "static". But it is not always used, 14005 ** depending on compile-time options. By omitting the "static", we avoid 14006 ** nuisance compiler warnings about "defined but not used". 14007 */ 14008 void shellFinalize( 14009 int *pRc, 14010 sqlite3_stmt *pStmt 14011 ){ 14012 if( pStmt ){ 14013 sqlite3 *db = sqlite3_db_handle(pStmt); 14014 int rc = sqlite3_finalize(pStmt); 14015 if( *pRc==SQLITE_OK ){ 14016 if( rc!=SQLITE_OK ){ 14017 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 14018 } 14019 *pRc = rc; 14020 } 14021 } 14022 } 14023 14024 /* Reset the prepared statement created using shellPreparePrintf(). 14025 ** 14026 ** This routine is could be marked "static". But it is not always used, 14027 ** depending on compile-time options. By omitting the "static", we avoid 14028 ** nuisance compiler warnings about "defined but not used". 14029 */ 14030 void shellReset( 14031 int *pRc, 14032 sqlite3_stmt *pStmt 14033 ){ 14034 int rc = sqlite3_reset(pStmt); 14035 if( *pRc==SQLITE_OK ){ 14036 if( rc!=SQLITE_OK ){ 14037 sqlite3 *db = sqlite3_db_handle(pStmt); 14038 raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 14039 } 14040 *pRc = rc; 14041 } 14042 } 14043 #endif /* !defined SQLITE_OMIT_VIRTUALTABLE */ 14044 14045 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 14046 /********************************************************************************* 14047 ** The ".archive" or ".ar" command. 14048 */ 14049 /* 14050 ** Structure representing a single ".ar" command. 14051 */ 14052 typedef struct ArCommand ArCommand; 14053 struct ArCommand { 14054 u8 eCmd; /* An AR_CMD_* value */ 14055 u8 bVerbose; /* True if --verbose */ 14056 u8 bZip; /* True if the archive is a ZIP */ 14057 u8 bDryRun; /* True if --dry-run */ 14058 u8 bAppend; /* True if --append */ 14059 u8 fromCmdLine; /* Run from -A instead of .archive */ 14060 int nArg; /* Number of command arguments */ 14061 char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */ 14062 const char *zFile; /* --file argument, or NULL */ 14063 const char *zDir; /* --directory argument, or NULL */ 14064 char **azArg; /* Array of command arguments */ 14065 ShellState *p; /* Shell state */ 14066 sqlite3 *db; /* Database containing the archive */ 14067 }; 14068 14069 /* 14070 ** Print a usage message for the .ar command to stderr and return SQLITE_ERROR. 14071 */ 14072 static int arUsage(FILE *f){ 14073 showHelp(f,"archive"); 14074 return SQLITE_ERROR; 14075 } 14076 14077 /* 14078 ** Print an error message for the .ar command to stderr and return 14079 ** SQLITE_ERROR. 14080 */ 14081 static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){ 14082 va_list ap; 14083 char *z; 14084 va_start(ap, zFmt); 14085 z = sqlite3_vmprintf(zFmt, ap); 14086 va_end(ap); 14087 utf8_printf(stderr, "Error: %s\n", z); 14088 if( pAr->fromCmdLine ){ 14089 utf8_printf(stderr, "Use \"-A\" for more help\n"); 14090 }else{ 14091 utf8_printf(stderr, "Use \".archive --help\" for more help\n"); 14092 } 14093 sqlite3_free(z); 14094 return SQLITE_ERROR; 14095 } 14096 14097 /* 14098 ** Values for ArCommand.eCmd. 14099 */ 14100 #define AR_CMD_CREATE 1 14101 #define AR_CMD_UPDATE 2 14102 #define AR_CMD_INSERT 3 14103 #define AR_CMD_EXTRACT 4 14104 #define AR_CMD_LIST 5 14105 #define AR_CMD_HELP 6 14106 14107 /* 14108 ** Other (non-command) switches. 14109 */ 14110 #define AR_SWITCH_VERBOSE 7 14111 #define AR_SWITCH_FILE 8 14112 #define AR_SWITCH_DIRECTORY 9 14113 #define AR_SWITCH_APPEND 10 14114 #define AR_SWITCH_DRYRUN 11 14115 14116 static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){ 14117 switch( eSwitch ){ 14118 case AR_CMD_CREATE: 14119 case AR_CMD_EXTRACT: 14120 case AR_CMD_LIST: 14121 case AR_CMD_UPDATE: 14122 case AR_CMD_INSERT: 14123 case AR_CMD_HELP: 14124 if( pAr->eCmd ){ 14125 return arErrorMsg(pAr, "multiple command options"); 14126 } 14127 pAr->eCmd = eSwitch; 14128 break; 14129 14130 case AR_SWITCH_DRYRUN: 14131 pAr->bDryRun = 1; 14132 break; 14133 case AR_SWITCH_VERBOSE: 14134 pAr->bVerbose = 1; 14135 break; 14136 case AR_SWITCH_APPEND: 14137 pAr->bAppend = 1; 14138 /* Fall thru into --file */ 14139 case AR_SWITCH_FILE: 14140 pAr->zFile = zArg; 14141 break; 14142 case AR_SWITCH_DIRECTORY: 14143 pAr->zDir = zArg; 14144 break; 14145 } 14146 14147 return SQLITE_OK; 14148 } 14149 14150 /* 14151 ** Parse the command line for an ".ar" command. The results are written into 14152 ** structure (*pAr). SQLITE_OK is returned if the command line is parsed 14153 ** successfully, otherwise an error message is written to stderr and 14154 ** SQLITE_ERROR returned. 14155 */ 14156 static int arParseCommand( 14157 char **azArg, /* Array of arguments passed to dot command */ 14158 int nArg, /* Number of entries in azArg[] */ 14159 ArCommand *pAr /* Populate this object */ 14160 ){ 14161 struct ArSwitch { 14162 const char *zLong; 14163 char cShort; 14164 u8 eSwitch; 14165 u8 bArg; 14166 } aSwitch[] = { 14167 { "create", 'c', AR_CMD_CREATE, 0 }, 14168 { "extract", 'x', AR_CMD_EXTRACT, 0 }, 14169 { "insert", 'i', AR_CMD_INSERT, 0 }, 14170 { "list", 't', AR_CMD_LIST, 0 }, 14171 { "update", 'u', AR_CMD_UPDATE, 0 }, 14172 { "help", 'h', AR_CMD_HELP, 0 }, 14173 { "verbose", 'v', AR_SWITCH_VERBOSE, 0 }, 14174 { "file", 'f', AR_SWITCH_FILE, 1 }, 14175 { "append", 'a', AR_SWITCH_APPEND, 1 }, 14176 { "directory", 'C', AR_SWITCH_DIRECTORY, 1 }, 14177 { "dryrun", 'n', AR_SWITCH_DRYRUN, 0 }, 14178 }; 14179 int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch); 14180 struct ArSwitch *pEnd = &aSwitch[nSwitch]; 14181 14182 if( nArg<=1 ){ 14183 utf8_printf(stderr, "Wrong number of arguments. Usage:\n"); 14184 return arUsage(stderr); 14185 }else{ 14186 char *z = azArg[1]; 14187 if( z[0]!='-' ){ 14188 /* Traditional style [tar] invocation */ 14189 int i; 14190 int iArg = 2; 14191 for(i=0; z[i]; i++){ 14192 const char *zArg = 0; 14193 struct ArSwitch *pOpt; 14194 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 14195 if( z[i]==pOpt->cShort ) break; 14196 } 14197 if( pOpt==pEnd ){ 14198 return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 14199 } 14200 if( pOpt->bArg ){ 14201 if( iArg>=nArg ){ 14202 return arErrorMsg(pAr, "option requires an argument: %c",z[i]); 14203 } 14204 zArg = azArg[iArg++]; 14205 } 14206 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 14207 } 14208 pAr->nArg = nArg-iArg; 14209 if( pAr->nArg>0 ){ 14210 pAr->azArg = &azArg[iArg]; 14211 } 14212 }else{ 14213 /* Non-traditional invocation */ 14214 int iArg; 14215 for(iArg=1; iArg<nArg; iArg++){ 14216 int n; 14217 z = azArg[iArg]; 14218 if( z[0]!='-' ){ 14219 /* All remaining command line words are command arguments. */ 14220 pAr->azArg = &azArg[iArg]; 14221 pAr->nArg = nArg-iArg; 14222 break; 14223 } 14224 n = strlen30(z); 14225 14226 if( z[1]!='-' ){ 14227 int i; 14228 /* One or more short options */ 14229 for(i=1; i<n; i++){ 14230 const char *zArg = 0; 14231 struct ArSwitch *pOpt; 14232 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 14233 if( z[i]==pOpt->cShort ) break; 14234 } 14235 if( pOpt==pEnd ){ 14236 return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 14237 } 14238 if( pOpt->bArg ){ 14239 if( i<(n-1) ){ 14240 zArg = &z[i+1]; 14241 i = n; 14242 }else{ 14243 if( iArg>=(nArg-1) ){ 14244 return arErrorMsg(pAr, "option requires an argument: %c",z[i]); 14245 } 14246 zArg = azArg[++iArg]; 14247 } 14248 } 14249 if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 14250 } 14251 }else if( z[2]=='\0' ){ 14252 /* A -- option, indicating that all remaining command line words 14253 ** are command arguments. */ 14254 pAr->azArg = &azArg[iArg+1]; 14255 pAr->nArg = nArg-iArg-1; 14256 break; 14257 }else{ 14258 /* A long option */ 14259 const char *zArg = 0; /* Argument for option, if any */ 14260 struct ArSwitch *pMatch = 0; /* Matching option */ 14261 struct ArSwitch *pOpt; /* Iterator */ 14262 for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 14263 const char *zLong = pOpt->zLong; 14264 if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){ 14265 if( pMatch ){ 14266 return arErrorMsg(pAr, "ambiguous option: %s",z); 14267 }else{ 14268 pMatch = pOpt; 14269 } 14270 } 14271 } 14272 14273 if( pMatch==0 ){ 14274 return arErrorMsg(pAr, "unrecognized option: %s", z); 14275 } 14276 if( pMatch->bArg ){ 14277 if( iArg>=(nArg-1) ){ 14278 return arErrorMsg(pAr, "option requires an argument: %s", z); 14279 } 14280 zArg = azArg[++iArg]; 14281 } 14282 if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR; 14283 } 14284 } 14285 } 14286 } 14287 14288 return SQLITE_OK; 14289 } 14290 14291 /* 14292 ** This function assumes that all arguments within the ArCommand.azArg[] 14293 ** array refer to archive members, as for the --extract or --list commands. 14294 ** It checks that each of them are present. If any specified file is not 14295 ** present in the archive, an error is printed to stderr and an error 14296 ** code returned. Otherwise, if all specified arguments are present in 14297 ** the archive, SQLITE_OK is returned. 14298 ** 14299 ** This function strips any trailing '/' characters from each argument. 14300 ** This is consistent with the way the [tar] command seems to work on 14301 ** Linux. 14302 */ 14303 static int arCheckEntries(ArCommand *pAr){ 14304 int rc = SQLITE_OK; 14305 if( pAr->nArg ){ 14306 int i, j; 14307 sqlite3_stmt *pTest = 0; 14308 14309 shellPreparePrintf(pAr->db, &rc, &pTest, 14310 "SELECT name FROM %s WHERE name=$name", 14311 pAr->zSrcTable 14312 ); 14313 j = sqlite3_bind_parameter_index(pTest, "$name"); 14314 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 14315 char *z = pAr->azArg[i]; 14316 int n = strlen30(z); 14317 int bOk = 0; 14318 while( n>0 && z[n-1]=='/' ) n--; 14319 z[n] = '\0'; 14320 sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC); 14321 if( SQLITE_ROW==sqlite3_step(pTest) ){ 14322 bOk = 1; 14323 } 14324 shellReset(&rc, pTest); 14325 if( rc==SQLITE_OK && bOk==0 ){ 14326 utf8_printf(stderr, "not found in archive: %s\n", z); 14327 rc = SQLITE_ERROR; 14328 } 14329 } 14330 shellFinalize(&rc, pTest); 14331 } 14332 return rc; 14333 } 14334 14335 /* 14336 ** Format a WHERE clause that can be used against the "sqlar" table to 14337 ** identify all archive members that match the command arguments held 14338 ** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning. 14339 ** The caller is responsible for eventually calling sqlite3_free() on 14340 ** any non-NULL (*pzWhere) value. 14341 */ 14342 static void arWhereClause( 14343 int *pRc, 14344 ArCommand *pAr, 14345 char **pzWhere /* OUT: New WHERE clause */ 14346 ){ 14347 char *zWhere = 0; 14348 if( *pRc==SQLITE_OK ){ 14349 if( pAr->nArg==0 ){ 14350 zWhere = sqlite3_mprintf("1"); 14351 }else{ 14352 int i; 14353 const char *zSep = ""; 14354 for(i=0; i<pAr->nArg; i++){ 14355 const char *z = pAr->azArg[i]; 14356 zWhere = sqlite3_mprintf( 14357 "%z%s name = '%q' OR substr(name,1,%d) = '%q/'", 14358 zWhere, zSep, z, strlen30(z)+1, z 14359 ); 14360 if( zWhere==0 ){ 14361 *pRc = SQLITE_NOMEM; 14362 break; 14363 } 14364 zSep = " OR "; 14365 } 14366 } 14367 } 14368 *pzWhere = zWhere; 14369 } 14370 14371 /* 14372 ** Implementation of .ar "lisT" command. 14373 */ 14374 static int arListCommand(ArCommand *pAr){ 14375 const char *zSql = "SELECT %s FROM %s WHERE %s"; 14376 const char *azCols[] = { 14377 "name", 14378 "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name" 14379 }; 14380 14381 char *zWhere = 0; 14382 sqlite3_stmt *pSql = 0; 14383 int rc; 14384 14385 rc = arCheckEntries(pAr); 14386 arWhereClause(&rc, pAr, &zWhere); 14387 14388 shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose], 14389 pAr->zSrcTable, zWhere); 14390 if( pAr->bDryRun ){ 14391 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 14392 }else{ 14393 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 14394 if( pAr->bVerbose ){ 14395 utf8_printf(pAr->p->out, "%s % 10d %s %s\n", 14396 sqlite3_column_text(pSql, 0), 14397 sqlite3_column_int(pSql, 1), 14398 sqlite3_column_text(pSql, 2), 14399 sqlite3_column_text(pSql, 3) 14400 ); 14401 }else{ 14402 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 14403 } 14404 } 14405 } 14406 shellFinalize(&rc, pSql); 14407 sqlite3_free(zWhere); 14408 return rc; 14409 } 14410 14411 14412 /* 14413 ** Implementation of .ar "eXtract" command. 14414 */ 14415 static int arExtractCommand(ArCommand *pAr){ 14416 const char *zSql1 = 14417 "SELECT " 14418 " ($dir || name)," 14419 " writefile(($dir || name), %s, mode, mtime) " 14420 "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)" 14421 " AND name NOT GLOB '*..[/\\]*'"; 14422 14423 const char *azExtraArg[] = { 14424 "sqlar_uncompress(data, sz)", 14425 "data" 14426 }; 14427 14428 sqlite3_stmt *pSql = 0; 14429 int rc = SQLITE_OK; 14430 char *zDir = 0; 14431 char *zWhere = 0; 14432 int i, j; 14433 14434 /* If arguments are specified, check that they actually exist within 14435 ** the archive before proceeding. And formulate a WHERE clause to 14436 ** match them. */ 14437 rc = arCheckEntries(pAr); 14438 arWhereClause(&rc, pAr, &zWhere); 14439 14440 if( rc==SQLITE_OK ){ 14441 if( pAr->zDir ){ 14442 zDir = sqlite3_mprintf("%s/", pAr->zDir); 14443 }else{ 14444 zDir = sqlite3_mprintf(""); 14445 } 14446 if( zDir==0 ) rc = SQLITE_NOMEM; 14447 } 14448 14449 shellPreparePrintf(pAr->db, &rc, &pSql, zSql1, 14450 azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere 14451 ); 14452 14453 if( rc==SQLITE_OK ){ 14454 j = sqlite3_bind_parameter_index(pSql, "$dir"); 14455 sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC); 14456 14457 /* Run the SELECT statement twice. The first time, writefile() is called 14458 ** for all archive members that should be extracted. The second time, 14459 ** only for the directories. This is because the timestamps for 14460 ** extracted directories must be reset after they are populated (as 14461 ** populating them changes the timestamp). */ 14462 for(i=0; i<2; i++){ 14463 j = sqlite3_bind_parameter_index(pSql, "$dirOnly"); 14464 sqlite3_bind_int(pSql, j, i); 14465 if( pAr->bDryRun ){ 14466 utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 14467 }else{ 14468 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 14469 if( i==0 && pAr->bVerbose ){ 14470 utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 14471 } 14472 } 14473 } 14474 shellReset(&rc, pSql); 14475 } 14476 shellFinalize(&rc, pSql); 14477 } 14478 14479 sqlite3_free(zDir); 14480 sqlite3_free(zWhere); 14481 return rc; 14482 } 14483 14484 /* 14485 ** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out. 14486 */ 14487 static int arExecSql(ArCommand *pAr, const char *zSql){ 14488 int rc; 14489 if( pAr->bDryRun ){ 14490 utf8_printf(pAr->p->out, "%s\n", zSql); 14491 rc = SQLITE_OK; 14492 }else{ 14493 char *zErr = 0; 14494 rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr); 14495 if( zErr ){ 14496 utf8_printf(stdout, "ERROR: %s\n", zErr); 14497 sqlite3_free(zErr); 14498 } 14499 } 14500 return rc; 14501 } 14502 14503 14504 /* 14505 ** Implementation of .ar "create", "insert", and "update" commands. 14506 ** 14507 ** create -> Create a new SQL archive 14508 ** insert -> Insert or reinsert all files listed 14509 ** update -> Insert files that have changed or that were not 14510 ** previously in the archive 14511 ** 14512 ** Create the "sqlar" table in the database if it does not already exist. 14513 ** Then add each file in the azFile[] array to the archive. Directories 14514 ** are added recursively. If argument bVerbose is non-zero, a message is 14515 ** printed on stdout for each file archived. 14516 ** 14517 ** The create command is the same as update, except that it drops 14518 ** any existing "sqlar" table before beginning. The "insert" command 14519 ** always overwrites every file named on the command-line, where as 14520 ** "update" only overwrites if the size or mtime or mode has changed. 14521 */ 14522 static int arCreateOrUpdateCommand( 14523 ArCommand *pAr, /* Command arguments and options */ 14524 int bUpdate, /* true for a --create. */ 14525 int bOnlyIfChanged /* Only update if file has changed */ 14526 ){ 14527 const char *zCreate = 14528 "CREATE TABLE IF NOT EXISTS sqlar(\n" 14529 " name TEXT PRIMARY KEY, -- name of the file\n" 14530 " mode INT, -- access permissions\n" 14531 " mtime INT, -- last modification time\n" 14532 " sz INT, -- original file size\n" 14533 " data BLOB -- compressed content\n" 14534 ")"; 14535 const char *zDrop = "DROP TABLE IF EXISTS sqlar"; 14536 const char *zInsertFmt[2] = { 14537 "REPLACE INTO %s(name,mode,mtime,sz,data)\n" 14538 " SELECT\n" 14539 " %s,\n" 14540 " mode,\n" 14541 " mtime,\n" 14542 " CASE substr(lsmode(mode),1,1)\n" 14543 " WHEN '-' THEN length(data)\n" 14544 " WHEN 'd' THEN 0\n" 14545 " ELSE -1 END,\n" 14546 " sqlar_compress(data)\n" 14547 " FROM fsdir(%Q,%Q) AS disk\n" 14548 " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 14549 , 14550 "REPLACE INTO %s(name,mode,mtime,data)\n" 14551 " SELECT\n" 14552 " %s,\n" 14553 " mode,\n" 14554 " mtime,\n" 14555 " data\n" 14556 " FROM fsdir(%Q,%Q) AS disk\n" 14557 " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 14558 }; 14559 int i; /* For iterating through azFile[] */ 14560 int rc; /* Return code */ 14561 const char *zTab = 0; /* SQL table into which to insert */ 14562 char *zSql; 14563 char zTemp[50]; 14564 char *zExists = 0; 14565 14566 arExecSql(pAr, "PRAGMA page_size=512"); 14567 rc = arExecSql(pAr, "SAVEPOINT ar;"); 14568 if( rc!=SQLITE_OK ) return rc; 14569 zTemp[0] = 0; 14570 if( pAr->bZip ){ 14571 /* Initialize the zipfile virtual table, if necessary */ 14572 if( pAr->zFile ){ 14573 sqlite3_uint64 r; 14574 sqlite3_randomness(sizeof(r),&r); 14575 sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r); 14576 zTab = zTemp; 14577 zSql = sqlite3_mprintf( 14578 "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)", 14579 zTab, pAr->zFile 14580 ); 14581 rc = arExecSql(pAr, zSql); 14582 sqlite3_free(zSql); 14583 }else{ 14584 zTab = "zip"; 14585 } 14586 }else{ 14587 /* Initialize the table for an SQLAR */ 14588 zTab = "sqlar"; 14589 if( bUpdate==0 ){ 14590 rc = arExecSql(pAr, zDrop); 14591 if( rc!=SQLITE_OK ) goto end_ar_transaction; 14592 } 14593 rc = arExecSql(pAr, zCreate); 14594 } 14595 if( bOnlyIfChanged ){ 14596 zExists = sqlite3_mprintf( 14597 " AND NOT EXISTS(" 14598 "SELECT 1 FROM %s AS mem" 14599 " WHERE mem.name=disk.name" 14600 " AND mem.mtime=disk.mtime" 14601 " AND mem.mode=disk.mode)", zTab); 14602 }else{ 14603 zExists = sqlite3_mprintf(""); 14604 } 14605 if( zExists==0 ) rc = SQLITE_NOMEM; 14606 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 14607 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab, 14608 pAr->bVerbose ? "shell_putsnl(name)" : "name", 14609 pAr->azArg[i], pAr->zDir, zExists); 14610 rc = arExecSql(pAr, zSql2); 14611 sqlite3_free(zSql2); 14612 } 14613 end_ar_transaction: 14614 if( rc!=SQLITE_OK ){ 14615 sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0); 14616 }else{ 14617 rc = arExecSql(pAr, "RELEASE ar;"); 14618 if( pAr->bZip && pAr->zFile ){ 14619 zSql = sqlite3_mprintf("DROP TABLE %s", zTemp); 14620 arExecSql(pAr, zSql); 14621 sqlite3_free(zSql); 14622 } 14623 } 14624 sqlite3_free(zExists); 14625 return rc; 14626 } 14627 14628 /* 14629 ** Implementation of ".ar" dot command. 14630 */ 14631 static int arDotCommand( 14632 ShellState *pState, /* Current shell tool state */ 14633 int fromCmdLine, /* True if -A command-line option, not .ar cmd */ 14634 char **azArg, /* Array of arguments passed to dot command */ 14635 int nArg /* Number of entries in azArg[] */ 14636 ){ 14637 ArCommand cmd; 14638 int rc; 14639 memset(&cmd, 0, sizeof(cmd)); 14640 cmd.fromCmdLine = fromCmdLine; 14641 rc = arParseCommand(azArg, nArg, &cmd); 14642 if( rc==SQLITE_OK ){ 14643 int eDbType = SHELL_OPEN_UNSPEC; 14644 cmd.p = pState; 14645 cmd.db = pState->db; 14646 if( cmd.zFile ){ 14647 eDbType = deduceDatabaseType(cmd.zFile, 1); 14648 }else{ 14649 eDbType = pState->openMode; 14650 } 14651 if( eDbType==SHELL_OPEN_ZIPFILE ){ 14652 if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){ 14653 if( cmd.zFile==0 ){ 14654 cmd.zSrcTable = sqlite3_mprintf("zip"); 14655 }else{ 14656 cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile); 14657 } 14658 } 14659 cmd.bZip = 1; 14660 }else if( cmd.zFile ){ 14661 int flags; 14662 if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS; 14663 if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT 14664 || cmd.eCmd==AR_CMD_UPDATE ){ 14665 flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE; 14666 }else{ 14667 flags = SQLITE_OPEN_READONLY; 14668 } 14669 cmd.db = 0; 14670 if( cmd.bDryRun ){ 14671 utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile, 14672 eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : ""); 14673 } 14674 rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags, 14675 eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0); 14676 if( rc!=SQLITE_OK ){ 14677 utf8_printf(stderr, "cannot open file: %s (%s)\n", 14678 cmd.zFile, sqlite3_errmsg(cmd.db) 14679 ); 14680 goto end_ar_command; 14681 } 14682 sqlite3_fileio_init(cmd.db, 0, 0); 14683 sqlite3_sqlar_init(cmd.db, 0, 0); 14684 sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p, 14685 shellPutsFunc, 0, 0); 14686 14687 } 14688 if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){ 14689 if( cmd.eCmd!=AR_CMD_CREATE 14690 && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0) 14691 ){ 14692 utf8_printf(stderr, "database does not contain an 'sqlar' table\n"); 14693 rc = SQLITE_ERROR; 14694 goto end_ar_command; 14695 } 14696 cmd.zSrcTable = sqlite3_mprintf("sqlar"); 14697 } 14698 14699 switch( cmd.eCmd ){ 14700 case AR_CMD_CREATE: 14701 rc = arCreateOrUpdateCommand(&cmd, 0, 0); 14702 break; 14703 14704 case AR_CMD_EXTRACT: 14705 rc = arExtractCommand(&cmd); 14706 break; 14707 14708 case AR_CMD_LIST: 14709 rc = arListCommand(&cmd); 14710 break; 14711 14712 case AR_CMD_HELP: 14713 arUsage(pState->out); 14714 break; 14715 14716 case AR_CMD_INSERT: 14717 rc = arCreateOrUpdateCommand(&cmd, 1, 0); 14718 break; 14719 14720 default: 14721 assert( cmd.eCmd==AR_CMD_UPDATE ); 14722 rc = arCreateOrUpdateCommand(&cmd, 1, 1); 14723 break; 14724 } 14725 } 14726 end_ar_command: 14727 if( cmd.db!=pState->db ){ 14728 close_db(cmd.db); 14729 } 14730 sqlite3_free(cmd.zSrcTable); 14731 14732 return rc; 14733 } 14734 /* End of the ".archive" or ".ar" command logic 14735 **********************************************************************************/ 14736 #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */ 14737 14738 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 14739 /* 14740 ** If (*pRc) is not SQLITE_OK when this function is called, it is a no-op. 14741 ** Otherwise, the SQL statement or statements in zSql are executed using 14742 ** database connection db and the error code written to *pRc before 14743 ** this function returns. 14744 */ 14745 static void shellExec(sqlite3 *db, int *pRc, const char *zSql){ 14746 int rc = *pRc; 14747 if( rc==SQLITE_OK ){ 14748 char *zErr = 0; 14749 rc = sqlite3_exec(db, zSql, 0, 0, &zErr); 14750 if( rc!=SQLITE_OK ){ 14751 raw_printf(stderr, "SQL error: %s\n", zErr); 14752 } 14753 *pRc = rc; 14754 } 14755 } 14756 14757 /* 14758 ** Like shellExec(), except that zFmt is a printf() style format string. 14759 */ 14760 static void shellExecPrintf(sqlite3 *db, int *pRc, const char *zFmt, ...){ 14761 char *z = 0; 14762 if( *pRc==SQLITE_OK ){ 14763 va_list ap; 14764 va_start(ap, zFmt); 14765 z = sqlite3_vmprintf(zFmt, ap); 14766 va_end(ap); 14767 if( z==0 ){ 14768 *pRc = SQLITE_NOMEM; 14769 }else{ 14770 shellExec(db, pRc, z); 14771 } 14772 sqlite3_free(z); 14773 } 14774 } 14775 14776 /* 14777 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op. 14778 ** Otherwise, an attempt is made to allocate, zero and return a pointer 14779 ** to a buffer nByte bytes in size. If an OOM error occurs, *pRc is set 14780 ** to SQLITE_NOMEM and NULL returned. 14781 */ 14782 static void *shellMalloc(int *pRc, sqlite3_int64 nByte){ 14783 void *pRet = 0; 14784 if( *pRc==SQLITE_OK ){ 14785 pRet = sqlite3_malloc64(nByte); 14786 if( pRet==0 ){ 14787 *pRc = SQLITE_NOMEM; 14788 }else{ 14789 memset(pRet, 0, nByte); 14790 } 14791 } 14792 return pRet; 14793 } 14794 14795 /* 14796 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op. 14797 ** Otherwise, zFmt is treated as a printf() style string. The result of 14798 ** formatting it along with any trailing arguments is written into a 14799 ** buffer obtained from sqlite3_malloc(), and pointer to which is returned. 14800 ** It is the responsibility of the caller to eventually free this buffer 14801 ** using a call to sqlite3_free(). 14802 ** 14803 ** If an OOM error occurs, (*pRc) is set to SQLITE_NOMEM and a NULL 14804 ** pointer returned. 14805 */ 14806 static char *shellMPrintf(int *pRc, const char *zFmt, ...){ 14807 char *z = 0; 14808 if( *pRc==SQLITE_OK ){ 14809 va_list ap; 14810 va_start(ap, zFmt); 14811 z = sqlite3_vmprintf(zFmt, ap); 14812 va_end(ap); 14813 if( z==0 ){ 14814 *pRc = SQLITE_NOMEM; 14815 } 14816 } 14817 return z; 14818 } 14819 14820 /* 14821 ** When running the ".recover" command, each output table, and the special 14822 ** orphaned row table if it is required, is represented by an instance 14823 ** of the following struct. 14824 */ 14825 typedef struct RecoverTable RecoverTable; 14826 struct RecoverTable { 14827 char *zQuoted; /* Quoted version of table name */ 14828 int nCol; /* Number of columns in table */ 14829 char **azlCol; /* Array of column lists */ 14830 int iPk; /* Index of IPK column */ 14831 }; 14832 14833 /* 14834 ** Free a RecoverTable object allocated by recoverFindTable() or 14835 ** recoverOrphanTable(). 14836 */ 14837 static void recoverFreeTable(RecoverTable *pTab){ 14838 if( pTab ){ 14839 sqlite3_free(pTab->zQuoted); 14840 if( pTab->azlCol ){ 14841 int i; 14842 for(i=0; i<=pTab->nCol; i++){ 14843 sqlite3_free(pTab->azlCol[i]); 14844 } 14845 sqlite3_free(pTab->azlCol); 14846 } 14847 sqlite3_free(pTab); 14848 } 14849 } 14850 14851 /* 14852 ** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. 14853 ** Otherwise, it allocates and returns a RecoverTable object based on the 14854 ** final four arguments passed to this function. It is the responsibility 14855 ** of the caller to eventually free the returned object using 14856 ** recoverFreeTable(). 14857 */ 14858 static RecoverTable *recoverNewTable( 14859 int *pRc, /* IN/OUT: Error code */ 14860 const char *zName, /* Name of table */ 14861 const char *zSql, /* CREATE TABLE statement */ 14862 int bIntkey, 14863 int nCol 14864 ){ 14865 sqlite3 *dbtmp = 0; /* sqlite3 handle for testing CREATE TABLE */ 14866 int rc = *pRc; 14867 RecoverTable *pTab = 0; 14868 14869 pTab = (RecoverTable*)shellMalloc(&rc, sizeof(RecoverTable)); 14870 if( rc==SQLITE_OK ){ 14871 int nSqlCol = 0; 14872 int bSqlIntkey = 0; 14873 sqlite3_stmt *pStmt = 0; 14874 14875 rc = sqlite3_open("", &dbtmp); 14876 if( rc==SQLITE_OK ){ 14877 rc = sqlite3_exec(dbtmp, "PRAGMA writable_schema = on", 0, 0, 0); 14878 } 14879 if( rc==SQLITE_OK ){ 14880 rc = sqlite3_exec(dbtmp, zSql, 0, 0, 0); 14881 if( rc==SQLITE_ERROR ){ 14882 rc = SQLITE_OK; 14883 goto finished; 14884 } 14885 } 14886 shellPreparePrintf(dbtmp, &rc, &pStmt, 14887 "SELECT count(*) FROM pragma_table_info(%Q)", zName 14888 ); 14889 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 14890 nSqlCol = sqlite3_column_int(pStmt, 0); 14891 } 14892 shellFinalize(&rc, pStmt); 14893 14894 if( rc!=SQLITE_OK || nSqlCol<nCol ){ 14895 goto finished; 14896 } 14897 14898 shellPreparePrintf(dbtmp, &rc, &pStmt, 14899 "SELECT (" 14900 " SELECT substr(data,1,1)==X'0D' FROM sqlite_dbpage WHERE pgno=rootpage" 14901 ") FROM sqlite_master WHERE name = %Q", zName 14902 ); 14903 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 14904 bSqlIntkey = sqlite3_column_int(pStmt, 0); 14905 } 14906 shellFinalize(&rc, pStmt); 14907 14908 if( bIntkey==bSqlIntkey ){ 14909 int i; 14910 const char *zPk = "_rowid_"; 14911 sqlite3_stmt *pPkFinder = 0; 14912 14913 /* If this is an intkey table and there is an INTEGER PRIMARY KEY, 14914 ** set zPk to the name of the PK column, and pTab->iPk to the index 14915 ** of the column, where columns are 0-numbered from left to right. 14916 ** Or, if this is a WITHOUT ROWID table or if there is no IPK column, 14917 ** leave zPk as "_rowid_" and pTab->iPk at -2. */ 14918 pTab->iPk = -2; 14919 if( bIntkey ){ 14920 shellPreparePrintf(dbtmp, &rc, &pPkFinder, 14921 "SELECT cid, name FROM pragma_table_info(%Q) " 14922 " WHERE pk=1 AND type='integer' COLLATE nocase" 14923 " AND NOT EXISTS (SELECT cid FROM pragma_table_info(%Q) WHERE pk=2)" 14924 , zName, zName 14925 ); 14926 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPkFinder) ){ 14927 pTab->iPk = sqlite3_column_int(pPkFinder, 0); 14928 zPk = (const char*)sqlite3_column_text(pPkFinder, 1); 14929 } 14930 } 14931 14932 pTab->zQuoted = shellMPrintf(&rc, "%Q", zName); 14933 pTab->azlCol = (char**)shellMalloc(&rc, sizeof(char*) * (nSqlCol+1)); 14934 pTab->nCol = nSqlCol; 14935 14936 if( bIntkey ){ 14937 pTab->azlCol[0] = shellMPrintf(&rc, "%Q", zPk); 14938 }else{ 14939 pTab->azlCol[0] = shellMPrintf(&rc, ""); 14940 } 14941 i = 1; 14942 shellPreparePrintf(dbtmp, &rc, &pStmt, 14943 "SELECT %Q || group_concat(name, ', ') " 14944 " FILTER (WHERE cid!=%d) OVER (ORDER BY %s cid) " 14945 "FROM pragma_table_info(%Q)", 14946 bIntkey ? ", " : "", pTab->iPk, 14947 bIntkey ? "" : "(CASE WHEN pk=0 THEN 1000000 ELSE pk END), ", 14948 zName 14949 ); 14950 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 14951 const char *zText = (const char*)sqlite3_column_text(pStmt, 0); 14952 pTab->azlCol[i] = shellMPrintf(&rc, "%s%s", pTab->azlCol[0], zText); 14953 i++; 14954 } 14955 shellFinalize(&rc, pStmt); 14956 14957 shellFinalize(&rc, pPkFinder); 14958 } 14959 } 14960 14961 finished: 14962 sqlite3_close(dbtmp); 14963 *pRc = rc; 14964 if( rc!=SQLITE_OK || (pTab && pTab->zQuoted==0) ){ 14965 recoverFreeTable(pTab); 14966 pTab = 0; 14967 } 14968 return pTab; 14969 } 14970 14971 /* 14972 ** This function is called to search the schema recovered from the 14973 ** sqlite_master table of the (possibly) corrupt database as part 14974 ** of a ".recover" command. Specifically, for a table with root page 14975 ** iRoot and at least nCol columns. Additionally, if bIntkey is 0, the 14976 ** table must be a WITHOUT ROWID table, or if non-zero, not one of 14977 ** those. 14978 ** 14979 ** If a table is found, a (RecoverTable*) object is returned. Or, if 14980 ** no such table is found, but bIntkey is false and iRoot is the 14981 ** root page of an index in the recovered schema, then (*pbNoop) is 14982 ** set to true and NULL returned. Or, if there is no such table or 14983 ** index, NULL is returned and (*pbNoop) set to 0, indicating that 14984 ** the caller should write data to the orphans table. 14985 */ 14986 static RecoverTable *recoverFindTable( 14987 ShellState *pState, /* Shell state object */ 14988 int *pRc, /* IN/OUT: Error code */ 14989 int iRoot, /* Root page of table */ 14990 int bIntkey, /* True for an intkey table */ 14991 int nCol, /* Number of columns in table */ 14992 int *pbNoop /* OUT: True if iRoot is root of index */ 14993 ){ 14994 sqlite3_stmt *pStmt = 0; 14995 RecoverTable *pRet = 0; 14996 int bNoop = 0; 14997 const char *zSql = 0; 14998 const char *zName = 0; 14999 15000 /* Search the recovered schema for an object with root page iRoot. */ 15001 shellPreparePrintf(pState->db, pRc, &pStmt, 15002 "SELECT type, name, sql FROM recovery.schema WHERE rootpage=%d", iRoot 15003 ); 15004 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 15005 const char *zType = (const char*)sqlite3_column_text(pStmt, 0); 15006 if( bIntkey==0 && sqlite3_stricmp(zType, "index")==0 ){ 15007 bNoop = 1; 15008 break; 15009 } 15010 if( sqlite3_stricmp(zType, "table")==0 ){ 15011 zName = (const char*)sqlite3_column_text(pStmt, 1); 15012 zSql = (const char*)sqlite3_column_text(pStmt, 2); 15013 pRet = recoverNewTable(pRc, zName, zSql, bIntkey, nCol); 15014 break; 15015 } 15016 } 15017 15018 shellFinalize(pRc, pStmt); 15019 *pbNoop = bNoop; 15020 return pRet; 15021 } 15022 15023 /* 15024 ** Return a RecoverTable object representing the orphans table. 15025 */ 15026 static RecoverTable *recoverOrphanTable( 15027 ShellState *pState, /* Shell state object */ 15028 int *pRc, /* IN/OUT: Error code */ 15029 const char *zLostAndFound, /* Base name for orphans table */ 15030 int nCol /* Number of user data columns */ 15031 ){ 15032 RecoverTable *pTab = 0; 15033 if( nCol>=0 && *pRc==SQLITE_OK ){ 15034 int i; 15035 15036 /* This block determines the name of the orphan table. The prefered 15037 ** name is zLostAndFound. But if that clashes with another name 15038 ** in the recovered schema, try zLostAndFound_0, zLostAndFound_1 15039 ** and so on until a non-clashing name is found. */ 15040 int iTab = 0; 15041 char *zTab = shellMPrintf(pRc, "%s", zLostAndFound); 15042 sqlite3_stmt *pTest = 0; 15043 shellPrepare(pState->db, pRc, 15044 "SELECT 1 FROM recovery.schema WHERE name=?", &pTest 15045 ); 15046 if( pTest ) sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT); 15047 while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pTest) ){ 15048 shellReset(pRc, pTest); 15049 sqlite3_free(zTab); 15050 zTab = shellMPrintf(pRc, "%s_%d", zLostAndFound, iTab++); 15051 sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT); 15052 } 15053 shellFinalize(pRc, pTest); 15054 15055 pTab = (RecoverTable*)shellMalloc(pRc, sizeof(RecoverTable)); 15056 if( pTab ){ 15057 pTab->zQuoted = shellMPrintf(pRc, "%Q", zTab); 15058 pTab->nCol = nCol; 15059 pTab->iPk = -2; 15060 if( nCol>0 ){ 15061 pTab->azlCol = (char**)shellMalloc(pRc, sizeof(char*) * (nCol+1)); 15062 if( pTab->azlCol ){ 15063 pTab->azlCol[nCol] = shellMPrintf(pRc, ""); 15064 for(i=nCol-1; i>=0; i--){ 15065 pTab->azlCol[i] = shellMPrintf(pRc, "%s, NULL", pTab->azlCol[i+1]); 15066 } 15067 } 15068 } 15069 15070 if( *pRc!=SQLITE_OK ){ 15071 recoverFreeTable(pTab); 15072 pTab = 0; 15073 }else{ 15074 raw_printf(pState->out, 15075 "CREATE TABLE %s(rootpgno INTEGER, " 15076 "pgno INTEGER, nfield INTEGER, id INTEGER", pTab->zQuoted 15077 ); 15078 for(i=0; i<nCol; i++){ 15079 raw_printf(pState->out, ", c%d", i); 15080 } 15081 raw_printf(pState->out, ");\n"); 15082 } 15083 } 15084 sqlite3_free(zTab); 15085 } 15086 return pTab; 15087 } 15088 15089 /* 15090 ** This function is called to recover data from the database. A script 15091 ** to construct a new database containing all recovered data is output 15092 ** on stream pState->out. 15093 */ 15094 static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){ 15095 int rc = SQLITE_OK; 15096 sqlite3_stmt *pLoop = 0; /* Loop through all root pages */ 15097 sqlite3_stmt *pPages = 0; /* Loop through all pages in a group */ 15098 sqlite3_stmt *pCells = 0; /* Loop through all cells in a page */ 15099 const char *zRecoveryDb = ""; /* Name of "recovery" database */ 15100 const char *zLostAndFound = "lost_and_found"; 15101 int i; 15102 int nOrphan = -1; 15103 RecoverTable *pOrphan = 0; 15104 15105 int bFreelist = 1; /* 0 if --freelist-corrupt is specified */ 15106 for(i=1; i<nArg; i++){ 15107 char *z = azArg[i]; 15108 int n; 15109 if( z[0]=='-' && z[1]=='-' ) z++; 15110 n = strlen30(z); 15111 if( n<=17 && memcmp("-freelist-corrupt", z, n)==0 ){ 15112 bFreelist = 0; 15113 }else 15114 if( n<=12 && memcmp("-recovery-db", z, n)==0 && i<(nArg-1) ){ 15115 i++; 15116 zRecoveryDb = azArg[i]; 15117 }else 15118 if( n<=15 && memcmp("-lost-and-found", z, n)==0 && i<(nArg-1) ){ 15119 i++; 15120 zLostAndFound = azArg[i]; 15121 } 15122 else{ 15123 raw_printf(stderr, "unexpected option: %s\n", azArg[i]); 15124 raw_printf(stderr, "options are:\n"); 15125 raw_printf(stderr, " --freelist-corrupt\n"); 15126 raw_printf(stderr, " --recovery-db DATABASE\n"); 15127 raw_printf(stderr, " --lost-and-found TABLE-NAME\n"); 15128 return 1; 15129 } 15130 } 15131 15132 shellExecPrintf(pState->db, &rc, 15133 /* Attach an in-memory database named 'recovery'. Create an indexed 15134 ** cache of the sqlite_dbptr virtual table. */ 15135 "ATTACH %Q AS recovery;" 15136 "DROP TABLE IF EXISTS recovery.dbptr;" 15137 "DROP TABLE IF EXISTS recovery.freelist;" 15138 "DROP TABLE IF EXISTS recovery.map;" 15139 "DROP TABLE IF EXISTS recovery.schema;" 15140 "CREATE TABLE recovery.freelist(pgno INTEGER PRIMARY KEY);", zRecoveryDb 15141 ); 15142 15143 if( bFreelist ){ 15144 shellExec(pState->db, &rc, 15145 "WITH trunk(pgno) AS (" 15146 " SELECT shell_int32(" 15147 " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 8) AS x " 15148 " WHERE x>0" 15149 " UNION" 15150 " SELECT shell_int32(" 15151 " (SELECT data FROM sqlite_dbpage WHERE pgno=trunk.pgno), 0) AS x " 15152 " FROM trunk WHERE x>0" 15153 ")," 15154 "freelist(data, n, freepgno) AS (" 15155 " SELECT data, min(16384, shell_int32(data, 1)-1), t.pgno " 15156 " FROM trunk t, sqlite_dbpage s WHERE s.pgno=t.pgno" 15157 " UNION ALL" 15158 " SELECT data, n-1, shell_int32(data, 2+n) " 15159 " FROM freelist WHERE n>=0" 15160 ")" 15161 "REPLACE INTO recovery.freelist SELECT freepgno FROM freelist;" 15162 ); 15163 } 15164 15165 shellExec(pState->db, &rc, 15166 "CREATE TABLE recovery.dbptr(" 15167 " pgno, child, PRIMARY KEY(child, pgno)" 15168 ") WITHOUT ROWID;" 15169 "INSERT OR IGNORE INTO recovery.dbptr(pgno, child) " 15170 " SELECT * FROM sqlite_dbptr" 15171 " WHERE pgno NOT IN freelist AND child NOT IN freelist;" 15172 15173 /* Delete any pointer to page 1. This ensures that page 1 is considered 15174 ** a root page, regardless of how corrupt the db is. */ 15175 "DELETE FROM recovery.dbptr WHERE child = 1;" 15176 15177 /* Delete all pointers to any pages that have more than one pointer 15178 ** to them. Such pages will be treated as root pages when recovering 15179 ** data. */ 15180 "DELETE FROM recovery.dbptr WHERE child IN (" 15181 " SELECT child FROM recovery.dbptr GROUP BY child HAVING count(*)>1" 15182 ");" 15183 15184 /* Create the "map" table that will (eventually) contain instructions 15185 ** for dealing with each page in the db that contains one or more 15186 ** records. */ 15187 "CREATE TABLE recovery.map(" 15188 "pgno INTEGER PRIMARY KEY, maxlen INT, intkey, root INT" 15189 ");" 15190 15191 /* Populate table [map]. If there are circular loops of pages in the 15192 ** database, the following adds all pages in such a loop to the map 15193 ** as individual root pages. This could be handled better. */ 15194 "WITH pages(i, maxlen) AS (" 15195 " SELECT page_count, (" 15196 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=page_count" 15197 " ) FROM pragma_page_count WHERE page_count>0" 15198 " UNION ALL" 15199 " SELECT i-1, (" 15200 " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=i-1" 15201 " ) FROM pages WHERE i>=2" 15202 ")" 15203 "INSERT INTO recovery.map(pgno, maxlen, intkey, root) " 15204 " SELECT i, maxlen, NULL, (" 15205 " WITH p(orig, pgno, parent) AS (" 15206 " SELECT 0, i, (SELECT pgno FROM recovery.dbptr WHERE child=i)" 15207 " UNION " 15208 " SELECT i, p.parent, " 15209 " (SELECT pgno FROM recovery.dbptr WHERE child=p.parent) FROM p" 15210 " )" 15211 " SELECT pgno FROM p WHERE (parent IS NULL OR pgno = orig)" 15212 ") " 15213 "FROM pages WHERE maxlen > 0 AND i NOT IN freelist;" 15214 "UPDATE recovery.map AS o SET intkey = (" 15215 " SELECT substr(data, 1, 1)==X'0D' FROM sqlite_dbpage WHERE pgno=o.pgno" 15216 ");" 15217 15218 /* Extract data from page 1 and any linked pages into table 15219 ** recovery.schema. With the same schema as an sqlite_master table. */ 15220 "CREATE TABLE recovery.schema(type, name, tbl_name, rootpage, sql);" 15221 "INSERT INTO recovery.schema SELECT " 15222 " max(CASE WHEN field=0 THEN value ELSE NULL END)," 15223 " max(CASE WHEN field=1 THEN value ELSE NULL END)," 15224 " max(CASE WHEN field=2 THEN value ELSE NULL END)," 15225 " max(CASE WHEN field=3 THEN value ELSE NULL END)," 15226 " max(CASE WHEN field=4 THEN value ELSE NULL END)" 15227 "FROM sqlite_dbdata WHERE pgno IN (" 15228 " SELECT pgno FROM recovery.map WHERE root=1" 15229 ")" 15230 "GROUP BY pgno, cell;" 15231 "CREATE INDEX recovery.schema_rootpage ON schema(rootpage);" 15232 ); 15233 15234 /* Open a transaction, then print out all non-virtual, non-"sqlite_%" 15235 ** CREATE TABLE statements that extracted from the existing schema. */ 15236 if( rc==SQLITE_OK ){ 15237 sqlite3_stmt *pStmt = 0; 15238 raw_printf(pState->out, "BEGIN;\n"); 15239 raw_printf(pState->out, "PRAGMA writable_schema = on;\n"); 15240 shellPrepare(pState->db, &rc, 15241 "SELECT sql FROM recovery.schema " 15242 "WHERE type='table' AND sql LIKE 'create table%'", &pStmt 15243 ); 15244 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 15245 const char *zCreateTable = (const char*)sqlite3_column_text(pStmt, 0); 15246 raw_printf(pState->out, "CREATE TABLE IF NOT EXISTS %s;\n", 15247 &zCreateTable[12] 15248 ); 15249 } 15250 shellFinalize(&rc, pStmt); 15251 } 15252 15253 /* Figure out if an orphan table will be required. And if so, how many 15254 ** user columns it should contain */ 15255 shellPrepare(pState->db, &rc, 15256 "SELECT coalesce(max(maxlen), -2) FROM recovery.map WHERE root>1" 15257 , &pLoop 15258 ); 15259 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){ 15260 nOrphan = sqlite3_column_int(pLoop, 0); 15261 } 15262 shellFinalize(&rc, pLoop); 15263 pLoop = 0; 15264 15265 shellPrepare(pState->db, &rc, 15266 "SELECT pgno FROM recovery.map WHERE root=?", &pPages 15267 ); 15268 shellPrepare(pState->db, &rc, 15269 "SELECT max(field), group_concat(shell_escape_crnl(quote(value)), ', ')" 15270 "FROM sqlite_dbdata WHERE pgno = ? AND field != ?" 15271 "GROUP BY cell", &pCells 15272 ); 15273 15274 /* Loop through each root page. */ 15275 shellPrepare(pState->db, &rc, 15276 "SELECT root, intkey, max(maxlen) FROM recovery.map" 15277 " WHERE root>1 GROUP BY root, intkey ORDER BY root=(" 15278 " SELECT rootpage FROM recovery.schema WHERE name='sqlite_sequence'" 15279 ")", &pLoop 15280 ); 15281 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){ 15282 int iRoot = sqlite3_column_int(pLoop, 0); 15283 int bIntkey = sqlite3_column_int(pLoop, 1); 15284 int nCol = sqlite3_column_int(pLoop, 2); 15285 int bNoop = 0; 15286 RecoverTable *pTab; 15287 15288 pTab = recoverFindTable(pState, &rc, iRoot, bIntkey, nCol, &bNoop); 15289 if( bNoop || rc ) continue; 15290 if( pTab==0 ){ 15291 if( pOrphan==0 ){ 15292 pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan); 15293 } 15294 pTab = pOrphan; 15295 if( pTab==0 ) break; 15296 } 15297 15298 if( 0==sqlite3_stricmp(pTab->zQuoted, "'sqlite_sequence'") ){ 15299 raw_printf(pState->out, "DELETE FROM sqlite_sequence;\n"); 15300 } 15301 sqlite3_bind_int(pPages, 1, iRoot); 15302 sqlite3_bind_int(pCells, 2, pTab->iPk); 15303 15304 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPages) ){ 15305 int iPgno = sqlite3_column_int(pPages, 0); 15306 sqlite3_bind_int(pCells, 1, iPgno); 15307 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pCells) ){ 15308 int nField = sqlite3_column_int(pCells, 0); 15309 const char *zVal = (const char*)sqlite3_column_text(pCells, 1); 15310 15311 nField = nField+1; 15312 if( pTab==pOrphan ){ 15313 raw_printf(pState->out, 15314 "INSERT INTO %s VALUES(%d, %d, %d, %s%s%s);\n", 15315 pTab->zQuoted, iRoot, iPgno, nField, 15316 bIntkey ? "" : "NULL, ", zVal, pTab->azlCol[nField] 15317 ); 15318 }else{ 15319 raw_printf(pState->out, "INSERT INTO %s(%s) VALUES( %s );\n", 15320 pTab->zQuoted, pTab->azlCol[nField], zVal 15321 ); 15322 } 15323 } 15324 shellReset(&rc, pCells); 15325 } 15326 shellReset(&rc, pPages); 15327 if( pTab!=pOrphan ) recoverFreeTable(pTab); 15328 } 15329 shellFinalize(&rc, pLoop); 15330 shellFinalize(&rc, pPages); 15331 shellFinalize(&rc, pCells); 15332 recoverFreeTable(pOrphan); 15333 15334 /* The rest of the schema */ 15335 if( rc==SQLITE_OK ){ 15336 sqlite3_stmt *pStmt = 0; 15337 shellPrepare(pState->db, &rc, 15338 "SELECT sql, name FROM recovery.schema " 15339 "WHERE sql NOT LIKE 'create table%'", &pStmt 15340 ); 15341 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 15342 const char *zSql = (const char*)sqlite3_column_text(pStmt, 0); 15343 if( sqlite3_strnicmp(zSql, "create virt", 11)==0 ){ 15344 const char *zName = (const char*)sqlite3_column_text(pStmt, 1); 15345 char *zPrint = shellMPrintf(&rc, 15346 "INSERT INTO sqlite_master VALUES('table', %Q, %Q, 0, %Q)", 15347 zName, zName, zSql 15348 ); 15349 raw_printf(pState->out, "%s;\n", zPrint); 15350 sqlite3_free(zPrint); 15351 }else{ 15352 raw_printf(pState->out, "%s;\n", zSql); 15353 } 15354 } 15355 shellFinalize(&rc, pStmt); 15356 } 15357 15358 if( rc==SQLITE_OK ){ 15359 raw_printf(pState->out, "PRAGMA writable_schema = off;\n"); 15360 raw_printf(pState->out, "COMMIT;\n"); 15361 } 15362 sqlite3_exec(pState->db, "DETACH recovery", 0, 0, 0); 15363 return rc; 15364 } 15365 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */ 15366 15367 15368 /* 15369 ** If an input line begins with "." then invoke this routine to 15370 ** process that line. 15371 ** 15372 ** Return 1 on error, 2 to exit, and 0 otherwise. 15373 */ 15374 static int do_meta_command(char *zLine, ShellState *p){ 15375 int h = 1; 15376 int nArg = 0; 15377 int n, c; 15378 int rc = 0; 15379 char *azArg[50]; 15380 15381 #ifndef SQLITE_OMIT_VIRTUALTABLE 15382 if( p->expert.pExpert ){ 15383 expertFinish(p, 1, 0); 15384 } 15385 #endif 15386 15387 /* Parse the input line into tokens. 15388 */ 15389 while( zLine[h] && nArg<ArraySize(azArg) ){ 15390 while( IsSpace(zLine[h]) ){ h++; } 15391 if( zLine[h]==0 ) break; 15392 if( zLine[h]=='\'' || zLine[h]=='"' ){ 15393 int delim = zLine[h++]; 15394 azArg[nArg++] = &zLine[h]; 15395 while( zLine[h] && zLine[h]!=delim ){ 15396 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++; 15397 h++; 15398 } 15399 if( zLine[h]==delim ){ 15400 zLine[h++] = 0; 15401 } 15402 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]); 15403 }else{ 15404 azArg[nArg++] = &zLine[h]; 15405 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; } 15406 if( zLine[h] ) zLine[h++] = 0; 15407 resolve_backslashes(azArg[nArg-1]); 15408 } 15409 } 15410 15411 /* Process the input line. 15412 */ 15413 if( nArg==0 ) return 0; /* no tokens, no error */ 15414 n = strlen30(azArg[0]); 15415 c = azArg[0][0]; 15416 clearTempFile(p); 15417 15418 #ifndef SQLITE_OMIT_AUTHORIZATION 15419 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){ 15420 if( nArg!=2 ){ 15421 raw_printf(stderr, "Usage: .auth ON|OFF\n"); 15422 rc = 1; 15423 goto meta_command_exit; 15424 } 15425 open_db(p, 0); 15426 if( booleanValue(azArg[1]) ){ 15427 sqlite3_set_authorizer(p->db, shellAuth, p); 15428 }else{ 15429 sqlite3_set_authorizer(p->db, 0, 0); 15430 } 15431 }else 15432 #endif 15433 15434 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 15435 if( c=='a' && strncmp(azArg[0], "archive", n)==0 ){ 15436 open_db(p, 0); 15437 rc = arDotCommand(p, 0, azArg, nArg); 15438 }else 15439 #endif 15440 15441 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0) 15442 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0) 15443 ){ 15444 const char *zDestFile = 0; 15445 const char *zDb = 0; 15446 sqlite3 *pDest; 15447 sqlite3_backup *pBackup; 15448 int j; 15449 int bAsync = 0; 15450 const char *zVfs = 0; 15451 for(j=1; j<nArg; j++){ 15452 const char *z = azArg[j]; 15453 if( z[0]=='-' ){ 15454 if( z[1]=='-' ) z++; 15455 if( strcmp(z, "-append")==0 ){ 15456 zVfs = "apndvfs"; 15457 }else 15458 if( strcmp(z, "-async")==0 ){ 15459 bAsync = 1; 15460 }else 15461 { 15462 utf8_printf(stderr, "unknown option: %s\n", azArg[j]); 15463 return 1; 15464 } 15465 }else if( zDestFile==0 ){ 15466 zDestFile = azArg[j]; 15467 }else if( zDb==0 ){ 15468 zDb = zDestFile; 15469 zDestFile = azArg[j]; 15470 }else{ 15471 raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n"); 15472 return 1; 15473 } 15474 } 15475 if( zDestFile==0 ){ 15476 raw_printf(stderr, "missing FILENAME argument on .backup\n"); 15477 return 1; 15478 } 15479 if( zDb==0 ) zDb = "main"; 15480 rc = sqlite3_open_v2(zDestFile, &pDest, 15481 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs); 15482 if( rc!=SQLITE_OK ){ 15483 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile); 15484 close_db(pDest); 15485 return 1; 15486 } 15487 if( bAsync ){ 15488 sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;", 15489 0, 0, 0); 15490 } 15491 open_db(p, 0); 15492 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb); 15493 if( pBackup==0 ){ 15494 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 15495 close_db(pDest); 15496 return 1; 15497 } 15498 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} 15499 sqlite3_backup_finish(pBackup); 15500 if( rc==SQLITE_DONE ){ 15501 rc = 0; 15502 }else{ 15503 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 15504 rc = 1; 15505 } 15506 close_db(pDest); 15507 }else 15508 15509 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){ 15510 if( nArg==2 ){ 15511 bail_on_error = booleanValue(azArg[1]); 15512 }else{ 15513 raw_printf(stderr, "Usage: .bail on|off\n"); 15514 rc = 1; 15515 } 15516 }else 15517 15518 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){ 15519 if( nArg==2 ){ 15520 if( booleanValue(azArg[1]) ){ 15521 setBinaryMode(p->out, 1); 15522 }else{ 15523 setTextMode(p->out, 1); 15524 } 15525 }else{ 15526 raw_printf(stderr, "Usage: .binary on|off\n"); 15527 rc = 1; 15528 } 15529 }else 15530 15531 if( c=='c' && strcmp(azArg[0],"cd")==0 ){ 15532 if( nArg==2 ){ 15533 #if defined(_WIN32) || defined(WIN32) 15534 wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]); 15535 rc = !SetCurrentDirectoryW(z); 15536 sqlite3_free(z); 15537 #else 15538 rc = chdir(azArg[1]); 15539 #endif 15540 if( rc ){ 15541 utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]); 15542 rc = 1; 15543 } 15544 }else{ 15545 raw_printf(stderr, "Usage: .cd DIRECTORY\n"); 15546 rc = 1; 15547 } 15548 }else 15549 15550 /* The undocumented ".breakpoint" command causes a call to the no-op 15551 ** routine named test_breakpoint(). 15552 */ 15553 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){ 15554 test_breakpoint(); 15555 }else 15556 15557 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){ 15558 if( nArg==2 ){ 15559 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]); 15560 }else{ 15561 raw_printf(stderr, "Usage: .changes on|off\n"); 15562 rc = 1; 15563 } 15564 }else 15565 15566 /* Cancel output redirection, if it is currently set (by .testcase) 15567 ** Then read the content of the testcase-out.txt file and compare against 15568 ** azArg[1]. If there are differences, report an error and exit. 15569 */ 15570 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){ 15571 char *zRes = 0; 15572 output_reset(p); 15573 if( nArg!=2 ){ 15574 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n"); 15575 rc = 2; 15576 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){ 15577 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n"); 15578 rc = 2; 15579 }else if( testcase_glob(azArg[1],zRes)==0 ){ 15580 utf8_printf(stderr, 15581 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n", 15582 p->zTestcase, azArg[1], zRes); 15583 rc = 1; 15584 }else{ 15585 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase); 15586 p->nCheck++; 15587 } 15588 sqlite3_free(zRes); 15589 }else 15590 15591 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){ 15592 if( nArg==2 ){ 15593 tryToClone(p, azArg[1]); 15594 }else{ 15595 raw_printf(stderr, "Usage: .clone FILENAME\n"); 15596 rc = 1; 15597 } 15598 }else 15599 15600 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){ 15601 ShellState data; 15602 char *zErrMsg = 0; 15603 open_db(p, 0); 15604 memcpy(&data, p, sizeof(data)); 15605 data.showHeader = 0; 15606 data.cMode = data.mode = MODE_List; 15607 sqlite3_snprintf(sizeof(data.colSeparator),data.colSeparator,": "); 15608 data.cnt = 0; 15609 sqlite3_exec(p->db, "SELECT name, file FROM pragma_database_list", 15610 callback, &data, &zErrMsg); 15611 if( zErrMsg ){ 15612 utf8_printf(stderr,"Error: %s\n", zErrMsg); 15613 sqlite3_free(zErrMsg); 15614 rc = 1; 15615 } 15616 }else 15617 15618 if( c=='d' && n>=3 && strncmp(azArg[0], "dbconfig", n)==0 ){ 15619 static const struct DbConfigChoices { 15620 const char *zName; 15621 int op; 15622 } aDbConfig[] = { 15623 { "enable_fkey", SQLITE_DBCONFIG_ENABLE_FKEY }, 15624 { "enable_trigger", SQLITE_DBCONFIG_ENABLE_TRIGGER }, 15625 { "fts3_tokenizer", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER }, 15626 { "load_extension", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION }, 15627 { "no_ckpt_on_close", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE }, 15628 { "enable_qpsg", SQLITE_DBCONFIG_ENABLE_QPSG }, 15629 { "trigger_eqp", SQLITE_DBCONFIG_TRIGGER_EQP }, 15630 { "reset_database", SQLITE_DBCONFIG_RESET_DATABASE }, 15631 { "defensive", SQLITE_DBCONFIG_DEFENSIVE }, 15632 { "writable_schema", SQLITE_DBCONFIG_WRITABLE_SCHEMA }, 15633 { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE }, 15634 { "dqs_dml", SQLITE_DBCONFIG_DQS_DML }, 15635 { "dqs_ddl", SQLITE_DBCONFIG_DQS_DDL }, 15636 }; 15637 int ii, v; 15638 open_db(p, 0); 15639 for(ii=0; ii<ArraySize(aDbConfig); ii++){ 15640 if( nArg>1 && strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue; 15641 if( nArg>=3 ){ 15642 sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0); 15643 } 15644 sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v); 15645 utf8_printf(p->out, "%18s %s\n", aDbConfig[ii].zName, v ? "on" : "off"); 15646 if( nArg>1 ) break; 15647 } 15648 if( nArg>1 && ii==ArraySize(aDbConfig) ){ 15649 utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]); 15650 utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n"); 15651 } 15652 }else 15653 15654 if( c=='d' && n>=3 && strncmp(azArg[0], "dbinfo", n)==0 ){ 15655 rc = shell_dbinfo_command(p, nArg, azArg); 15656 }else 15657 15658 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 15659 if( c=='r' && strncmp(azArg[0], "recover", n)==0 ){ 15660 open_db(p, 0); 15661 rc = recoverDatabaseCmd(p, nArg, azArg); 15662 }else 15663 #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */ 15664 15665 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ 15666 const char *zLike = 0; 15667 int i; 15668 int savedShowHeader = p->showHeader; 15669 int savedShellFlags = p->shellFlgs; 15670 ShellClearFlag(p, SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo); 15671 for(i=1; i<nArg; i++){ 15672 if( azArg[i][0]=='-' ){ 15673 const char *z = azArg[i]+1; 15674 if( z[0]=='-' ) z++; 15675 if( strcmp(z,"preserve-rowids")==0 ){ 15676 #ifdef SQLITE_OMIT_VIRTUALTABLE 15677 raw_printf(stderr, "The --preserve-rowids option is not compatible" 15678 " with SQLITE_OMIT_VIRTUALTABLE\n"); 15679 rc = 1; 15680 goto meta_command_exit; 15681 #else 15682 ShellSetFlag(p, SHFLG_PreserveRowid); 15683 #endif 15684 }else 15685 if( strcmp(z,"newlines")==0 ){ 15686 ShellSetFlag(p, SHFLG_Newlines); 15687 }else 15688 { 15689 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]); 15690 rc = 1; 15691 goto meta_command_exit; 15692 } 15693 }else if( zLike ){ 15694 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? " 15695 "?--newlines? ?LIKE-PATTERN?\n"); 15696 rc = 1; 15697 goto meta_command_exit; 15698 }else{ 15699 zLike = azArg[i]; 15700 } 15701 } 15702 15703 open_db(p, 0); 15704 15705 /* When playing back a "dump", the content might appear in an order 15706 ** which causes immediate foreign key constraints to be violated. 15707 ** So disable foreign-key constraint enforcement to prevent problems. */ 15708 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n"); 15709 raw_printf(p->out, "BEGIN TRANSACTION;\n"); 15710 p->writableSchema = 0; 15711 p->showHeader = 0; 15712 /* Set writable_schema=ON since doing so forces SQLite to initialize 15713 ** as much of the schema as it can even if the sqlite_master table is 15714 ** corrupt. */ 15715 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0); 15716 p->nErr = 0; 15717 if( zLike==0 ){ 15718 run_schema_dump_query(p, 15719 "SELECT name, type, sql FROM sqlite_master " 15720 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'" 15721 ); 15722 run_schema_dump_query(p, 15723 "SELECT name, type, sql FROM sqlite_master " 15724 "WHERE name=='sqlite_sequence'" 15725 ); 15726 run_table_dump_query(p, 15727 "SELECT sql FROM sqlite_master " 15728 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0 15729 ); 15730 }else{ 15731 char *zSql; 15732 zSql = sqlite3_mprintf( 15733 "SELECT name, type, sql FROM sqlite_master " 15734 "WHERE tbl_name LIKE %Q AND type=='table'" 15735 " AND sql NOT NULL", zLike); 15736 run_schema_dump_query(p,zSql); 15737 sqlite3_free(zSql); 15738 zSql = sqlite3_mprintf( 15739 "SELECT sql FROM sqlite_master " 15740 "WHERE sql NOT NULL" 15741 " AND type IN ('index','trigger','view')" 15742 " AND tbl_name LIKE %Q", zLike); 15743 run_table_dump_query(p, zSql, 0); 15744 sqlite3_free(zSql); 15745 } 15746 if( p->writableSchema ){ 15747 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n"); 15748 p->writableSchema = 0; 15749 } 15750 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 15751 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0); 15752 raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n"); 15753 p->showHeader = savedShowHeader; 15754 p->shellFlgs = savedShellFlags; 15755 }else 15756 15757 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){ 15758 if( nArg==2 ){ 15759 setOrClearFlag(p, SHFLG_Echo, azArg[1]); 15760 }else{ 15761 raw_printf(stderr, "Usage: .echo on|off\n"); 15762 rc = 1; 15763 } 15764 }else 15765 15766 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){ 15767 if( nArg==2 ){ 15768 p->autoEQPtest = 0; 15769 if( p->autoEQPtrace ){ 15770 if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0); 15771 p->autoEQPtrace = 0; 15772 } 15773 if( strcmp(azArg[1],"full")==0 ){ 15774 p->autoEQP = AUTOEQP_full; 15775 }else if( strcmp(azArg[1],"trigger")==0 ){ 15776 p->autoEQP = AUTOEQP_trigger; 15777 #ifdef SQLITE_DEBUG 15778 }else if( strcmp(azArg[1],"test")==0 ){ 15779 p->autoEQP = AUTOEQP_on; 15780 p->autoEQPtest = 1; 15781 }else if( strcmp(azArg[1],"trace")==0 ){ 15782 p->autoEQP = AUTOEQP_full; 15783 p->autoEQPtrace = 1; 15784 open_db(p, 0); 15785 sqlite3_exec(p->db, "SELECT name FROM sqlite_master LIMIT 1", 0, 0, 0); 15786 sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0); 15787 #endif 15788 }else{ 15789 p->autoEQP = (u8)booleanValue(azArg[1]); 15790 } 15791 }else{ 15792 raw_printf(stderr, "Usage: .eqp off|on|trace|trigger|full\n"); 15793 rc = 1; 15794 } 15795 }else 15796 15797 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){ 15798 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc); 15799 rc = 2; 15800 }else 15801 15802 /* The ".explain" command is automatic now. It is largely pointless. It 15803 ** retained purely for backwards compatibility */ 15804 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ 15805 int val = 1; 15806 if( nArg>=2 ){ 15807 if( strcmp(azArg[1],"auto")==0 ){ 15808 val = 99; 15809 }else{ 15810 val = booleanValue(azArg[1]); 15811 } 15812 } 15813 if( val==1 && p->mode!=MODE_Explain ){ 15814 p->normalMode = p->mode; 15815 p->mode = MODE_Explain; 15816 p->autoExplain = 0; 15817 }else if( val==0 ){ 15818 if( p->mode==MODE_Explain ) p->mode = p->normalMode; 15819 p->autoExplain = 0; 15820 }else if( val==99 ){ 15821 if( p->mode==MODE_Explain ) p->mode = p->normalMode; 15822 p->autoExplain = 1; 15823 } 15824 }else 15825 15826 #ifndef SQLITE_OMIT_VIRTUALTABLE 15827 if( c=='e' && strncmp(azArg[0], "expert", n)==0 ){ 15828 open_db(p, 0); 15829 expertDotCommand(p, azArg, nArg); 15830 }else 15831 #endif 15832 15833 if( c=='f' && strncmp(azArg[0], "filectrl", n)==0 ){ 15834 static const struct { 15835 const char *zCtrlName; /* Name of a test-control option */ 15836 int ctrlCode; /* Integer code for that option */ 15837 const char *zUsage; /* Usage notes */ 15838 } aCtrl[] = { 15839 { "size_limit", SQLITE_FCNTL_SIZE_LIMIT, "[LIMIT]" }, 15840 { "chunk_size", SQLITE_FCNTL_CHUNK_SIZE, "SIZE" }, 15841 /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY, "COUNT DELAY" },*/ 15842 { "persist_wal", SQLITE_FCNTL_PERSIST_WAL, "[BOOLEAN]" }, 15843 { "psow", SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]" }, 15844 /* { "pragma", SQLITE_FCNTL_PRAGMA, "NAME ARG" },*/ 15845 { "tempfilename", SQLITE_FCNTL_TEMPFILENAME, "" }, 15846 { "has_moved", SQLITE_FCNTL_HAS_MOVED, "" }, 15847 { "lock_timeout", SQLITE_FCNTL_LOCK_TIMEOUT, "MILLISEC" }, 15848 }; 15849 int filectrl = -1; 15850 int iCtrl = -1; 15851 sqlite3_int64 iRes = 0; /* Integer result to display if rc2==1 */ 15852 int isOk = 0; /* 0: usage 1: %lld 2: no-result */ 15853 int n2, i; 15854 const char *zCmd = 0; 15855 15856 open_db(p, 0); 15857 zCmd = nArg>=2 ? azArg[1] : "help"; 15858 15859 /* The argument can optionally begin with "-" or "--" */ 15860 if( zCmd[0]=='-' && zCmd[1] ){ 15861 zCmd++; 15862 if( zCmd[0]=='-' && zCmd[1] ) zCmd++; 15863 } 15864 15865 /* --help lists all file-controls */ 15866 if( strcmp(zCmd,"help")==0 ){ 15867 utf8_printf(p->out, "Available file-controls:\n"); 15868 for(i=0; i<ArraySize(aCtrl); i++){ 15869 utf8_printf(p->out, " .filectrl %s %s\n", 15870 aCtrl[i].zCtrlName, aCtrl[i].zUsage); 15871 } 15872 rc = 1; 15873 goto meta_command_exit; 15874 } 15875 15876 /* convert filectrl text option to value. allow any unique prefix 15877 ** of the option name, or a numerical value. */ 15878 n2 = strlen30(zCmd); 15879 for(i=0; i<ArraySize(aCtrl); i++){ 15880 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){ 15881 if( filectrl<0 ){ 15882 filectrl = aCtrl[i].ctrlCode; 15883 iCtrl = i; 15884 }else{ 15885 utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n" 15886 "Use \".filectrl --help\" for help\n", zCmd); 15887 rc = 1; 15888 goto meta_command_exit; 15889 } 15890 } 15891 } 15892 if( filectrl<0 ){ 15893 utf8_printf(stderr,"Error: unknown file-control: %s\n" 15894 "Use \".filectrl --help\" for help\n", zCmd); 15895 }else{ 15896 switch(filectrl){ 15897 case SQLITE_FCNTL_SIZE_LIMIT: { 15898 if( nArg!=2 && nArg!=3 ) break; 15899 iRes = nArg==3 ? integerValue(azArg[2]) : -1; 15900 sqlite3_file_control(p->db, 0, SQLITE_FCNTL_SIZE_LIMIT, &iRes); 15901 isOk = 1; 15902 break; 15903 } 15904 case SQLITE_FCNTL_LOCK_TIMEOUT: 15905 case SQLITE_FCNTL_CHUNK_SIZE: { 15906 int x; 15907 if( nArg!=3 ) break; 15908 x = (int)integerValue(azArg[2]); 15909 sqlite3_file_control(p->db, 0, filectrl, &x); 15910 isOk = 2; 15911 break; 15912 } 15913 case SQLITE_FCNTL_PERSIST_WAL: 15914 case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { 15915 int x; 15916 if( nArg!=2 && nArg!=3 ) break; 15917 x = nArg==3 ? booleanValue(azArg[2]) : -1; 15918 sqlite3_file_control(p->db, 0, filectrl, &x); 15919 iRes = x; 15920 isOk = 1; 15921 break; 15922 } 15923 case SQLITE_FCNTL_HAS_MOVED: { 15924 int x; 15925 if( nArg!=2 ) break; 15926 sqlite3_file_control(p->db, 0, filectrl, &x); 15927 iRes = x; 15928 isOk = 1; 15929 break; 15930 } 15931 case SQLITE_FCNTL_TEMPFILENAME: { 15932 char *z = 0; 15933 if( nArg!=2 ) break; 15934 sqlite3_file_control(p->db, 0, filectrl, &z); 15935 if( z ){ 15936 utf8_printf(p->out, "%s\n", z); 15937 sqlite3_free(z); 15938 } 15939 isOk = 2; 15940 break; 15941 } 15942 } 15943 } 15944 if( isOk==0 && iCtrl>=0 ){ 15945 utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage); 15946 rc = 1; 15947 }else if( isOk==1 ){ 15948 char zBuf[100]; 15949 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes); 15950 raw_printf(p->out, "%s\n", zBuf); 15951 } 15952 }else 15953 15954 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){ 15955 ShellState data; 15956 char *zErrMsg = 0; 15957 int doStats = 0; 15958 memcpy(&data, p, sizeof(data)); 15959 data.showHeader = 0; 15960 data.cMode = data.mode = MODE_Semi; 15961 if( nArg==2 && optionMatch(azArg[1], "indent") ){ 15962 data.cMode = data.mode = MODE_Pretty; 15963 nArg = 1; 15964 } 15965 if( nArg!=1 ){ 15966 raw_printf(stderr, "Usage: .fullschema ?--indent?\n"); 15967 rc = 1; 15968 goto meta_command_exit; 15969 } 15970 open_db(p, 0); 15971 rc = sqlite3_exec(p->db, 15972 "SELECT sql FROM" 15973 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" 15974 " FROM sqlite_master UNION ALL" 15975 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " 15976 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " 15977 "ORDER BY rowid", 15978 callback, &data, &zErrMsg 15979 ); 15980 if( rc==SQLITE_OK ){ 15981 sqlite3_stmt *pStmt; 15982 rc = sqlite3_prepare_v2(p->db, 15983 "SELECT rowid FROM sqlite_master" 15984 " WHERE name GLOB 'sqlite_stat[134]'", 15985 -1, &pStmt, 0); 15986 doStats = sqlite3_step(pStmt)==SQLITE_ROW; 15987 sqlite3_finalize(pStmt); 15988 } 15989 if( doStats==0 ){ 15990 raw_printf(p->out, "/* No STAT tables available */\n"); 15991 }else{ 15992 raw_printf(p->out, "ANALYZE sqlite_master;\n"); 15993 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'", 15994 callback, &data, &zErrMsg); 15995 data.cMode = data.mode = MODE_Insert; 15996 data.zDestTable = "sqlite_stat1"; 15997 shell_exec(&data, "SELECT * FROM sqlite_stat1", &zErrMsg); 15998 data.zDestTable = "sqlite_stat3"; 15999 shell_exec(&data, "SELECT * FROM sqlite_stat3", &zErrMsg); 16000 data.zDestTable = "sqlite_stat4"; 16001 shell_exec(&data, "SELECT * FROM sqlite_stat4", &zErrMsg); 16002 raw_printf(p->out, "ANALYZE sqlite_master;\n"); 16003 } 16004 }else 16005 16006 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){ 16007 if( nArg==2 ){ 16008 p->showHeader = booleanValue(azArg[1]); 16009 }else{ 16010 raw_printf(stderr, "Usage: .headers on|off\n"); 16011 rc = 1; 16012 } 16013 }else 16014 16015 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ 16016 if( nArg>=2 ){ 16017 n = showHelp(p->out, azArg[1]); 16018 if( n==0 ){ 16019 utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]); 16020 } 16021 }else{ 16022 showHelp(p->out, 0); 16023 } 16024 }else 16025 16026 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){ 16027 char *zTable; /* Insert data into this table */ 16028 char *zFile; /* Name of file to extra content from */ 16029 sqlite3_stmt *pStmt = NULL; /* A statement */ 16030 int nCol; /* Number of columns in the table */ 16031 int nByte; /* Number of bytes in an SQL string */ 16032 int i, j; /* Loop counters */ 16033 int needCommit; /* True to COMMIT or ROLLBACK at end */ 16034 int nSep; /* Number of bytes in p->colSeparator[] */ 16035 char *zSql; /* An SQL statement */ 16036 ImportCtx sCtx; /* Reader context */ 16037 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */ 16038 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */ 16039 16040 if( nArg!=3 ){ 16041 raw_printf(stderr, "Usage: .import FILE TABLE\n"); 16042 goto meta_command_exit; 16043 } 16044 zFile = azArg[1]; 16045 zTable = azArg[2]; 16046 seenInterrupt = 0; 16047 memset(&sCtx, 0, sizeof(sCtx)); 16048 open_db(p, 0); 16049 nSep = strlen30(p->colSeparator); 16050 if( nSep==0 ){ 16051 raw_printf(stderr, 16052 "Error: non-null column separator required for import\n"); 16053 return 1; 16054 } 16055 if( nSep>1 ){ 16056 raw_printf(stderr, "Error: multi-character column separators not allowed" 16057 " for import\n"); 16058 return 1; 16059 } 16060 nSep = strlen30(p->rowSeparator); 16061 if( nSep==0 ){ 16062 raw_printf(stderr, "Error: non-null row separator required for import\n"); 16063 return 1; 16064 } 16065 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){ 16066 /* When importing CSV (only), if the row separator is set to the 16067 ** default output row separator, change it to the default input 16068 ** row separator. This avoids having to maintain different input 16069 ** and output row separators. */ 16070 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 16071 nSep = strlen30(p->rowSeparator); 16072 } 16073 if( nSep>1 ){ 16074 raw_printf(stderr, "Error: multi-character row separators not allowed" 16075 " for import\n"); 16076 return 1; 16077 } 16078 sCtx.zFile = zFile; 16079 sCtx.nLine = 1; 16080 if( sCtx.zFile[0]=='|' ){ 16081 #ifdef SQLITE_OMIT_POPEN 16082 raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 16083 return 1; 16084 #else 16085 sCtx.in = popen(sCtx.zFile+1, "r"); 16086 sCtx.zFile = "<pipe>"; 16087 xCloser = pclose; 16088 #endif 16089 }else{ 16090 sCtx.in = fopen(sCtx.zFile, "rb"); 16091 xCloser = fclose; 16092 } 16093 if( p->mode==MODE_Ascii ){ 16094 xRead = ascii_read_one_field; 16095 }else{ 16096 xRead = csv_read_one_field; 16097 } 16098 if( sCtx.in==0 ){ 16099 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 16100 return 1; 16101 } 16102 sCtx.cColSep = p->colSeparator[0]; 16103 sCtx.cRowSep = p->rowSeparator[0]; 16104 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable); 16105 if( zSql==0 ){ 16106 xCloser(sCtx.in); 16107 shell_out_of_memory(); 16108 } 16109 nByte = strlen30(zSql); 16110 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 16111 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */ 16112 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){ 16113 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable); 16114 char cSep = '('; 16115 while( xRead(&sCtx) ){ 16116 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z); 16117 cSep = ','; 16118 if( sCtx.cTerm!=sCtx.cColSep ) break; 16119 } 16120 if( cSep=='(' ){ 16121 sqlite3_free(zCreate); 16122 sqlite3_free(sCtx.z); 16123 xCloser(sCtx.in); 16124 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile); 16125 return 1; 16126 } 16127 zCreate = sqlite3_mprintf("%z\n)", zCreate); 16128 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0); 16129 sqlite3_free(zCreate); 16130 if( rc ){ 16131 utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable, 16132 sqlite3_errmsg(p->db)); 16133 sqlite3_free(sCtx.z); 16134 xCloser(sCtx.in); 16135 return 1; 16136 } 16137 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 16138 } 16139 sqlite3_free(zSql); 16140 if( rc ){ 16141 if (pStmt) sqlite3_finalize(pStmt); 16142 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db)); 16143 xCloser(sCtx.in); 16144 return 1; 16145 } 16146 nCol = sqlite3_column_count(pStmt); 16147 sqlite3_finalize(pStmt); 16148 pStmt = 0; 16149 if( nCol==0 ) return 0; /* no columns, no error */ 16150 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 ); 16151 if( zSql==0 ){ 16152 xCloser(sCtx.in); 16153 shell_out_of_memory(); 16154 } 16155 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable); 16156 j = strlen30(zSql); 16157 for(i=1; i<nCol; i++){ 16158 zSql[j++] = ','; 16159 zSql[j++] = '?'; 16160 } 16161 zSql[j++] = ')'; 16162 zSql[j] = 0; 16163 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 16164 sqlite3_free(zSql); 16165 if( rc ){ 16166 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 16167 if (pStmt) sqlite3_finalize(pStmt); 16168 xCloser(sCtx.in); 16169 return 1; 16170 } 16171 needCommit = sqlite3_get_autocommit(p->db); 16172 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0); 16173 do{ 16174 int startLine = sCtx.nLine; 16175 for(i=0; i<nCol; i++){ 16176 char *z = xRead(&sCtx); 16177 /* 16178 ** Did we reach end-of-file before finding any columns? 16179 ** If so, stop instead of NULL filling the remaining columns. 16180 */ 16181 if( z==0 && i==0 ) break; 16182 /* 16183 ** Did we reach end-of-file OR end-of-line before finding any 16184 ** columns in ASCII mode? If so, stop instead of NULL filling 16185 ** the remaining columns. 16186 */ 16187 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break; 16188 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT); 16189 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){ 16190 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 16191 "filling the rest with NULL\n", 16192 sCtx.zFile, startLine, nCol, i+1); 16193 i += 2; 16194 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; } 16195 } 16196 } 16197 if( sCtx.cTerm==sCtx.cColSep ){ 16198 do{ 16199 xRead(&sCtx); 16200 i++; 16201 }while( sCtx.cTerm==sCtx.cColSep ); 16202 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 16203 "extras ignored\n", 16204 sCtx.zFile, startLine, nCol, i); 16205 } 16206 if( i>=nCol ){ 16207 sqlite3_step(pStmt); 16208 rc = sqlite3_reset(pStmt); 16209 if( rc!=SQLITE_OK ){ 16210 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, 16211 startLine, sqlite3_errmsg(p->db)); 16212 } 16213 } 16214 }while( sCtx.cTerm!=EOF ); 16215 16216 xCloser(sCtx.in); 16217 sqlite3_free(sCtx.z); 16218 sqlite3_finalize(pStmt); 16219 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0); 16220 }else 16221 16222 #ifndef SQLITE_UNTESTABLE 16223 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){ 16224 char *zSql; 16225 char *zCollist = 0; 16226 sqlite3_stmt *pStmt; 16227 int tnum = 0; 16228 int i; 16229 if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){ 16230 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n" 16231 " .imposter off\n"); 16232 rc = 1; 16233 goto meta_command_exit; 16234 } 16235 open_db(p, 0); 16236 if( nArg==2 ){ 16237 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1); 16238 goto meta_command_exit; 16239 } 16240 zSql = sqlite3_mprintf("SELECT rootpage FROM sqlite_master" 16241 " WHERE name='%q' AND type='index'", azArg[1]); 16242 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 16243 sqlite3_free(zSql); 16244 if( sqlite3_step(pStmt)==SQLITE_ROW ){ 16245 tnum = sqlite3_column_int(pStmt, 0); 16246 } 16247 sqlite3_finalize(pStmt); 16248 if( tnum==0 ){ 16249 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]); 16250 rc = 1; 16251 goto meta_command_exit; 16252 } 16253 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]); 16254 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 16255 sqlite3_free(zSql); 16256 i = 0; 16257 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 16258 char zLabel[20]; 16259 const char *zCol = (const char*)sqlite3_column_text(pStmt,2); 16260 i++; 16261 if( zCol==0 ){ 16262 if( sqlite3_column_int(pStmt,1)==-1 ){ 16263 zCol = "_ROWID_"; 16264 }else{ 16265 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i); 16266 zCol = zLabel; 16267 } 16268 } 16269 if( zCollist==0 ){ 16270 zCollist = sqlite3_mprintf("\"%w\"", zCol); 16271 }else{ 16272 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol); 16273 } 16274 } 16275 sqlite3_finalize(pStmt); 16276 zSql = sqlite3_mprintf( 16277 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%s))WITHOUT ROWID", 16278 azArg[2], zCollist, zCollist); 16279 sqlite3_free(zCollist); 16280 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum); 16281 if( rc==SQLITE_OK ){ 16282 rc = sqlite3_exec(p->db, zSql, 0, 0, 0); 16283 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0); 16284 if( rc ){ 16285 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db)); 16286 }else{ 16287 utf8_printf(stdout, "%s;\n", zSql); 16288 raw_printf(stdout, 16289 "WARNING: writing to an imposter table will corrupt the index!\n" 16290 ); 16291 } 16292 }else{ 16293 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc); 16294 rc = 1; 16295 } 16296 sqlite3_free(zSql); 16297 }else 16298 #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */ 16299 16300 #ifdef SQLITE_ENABLE_IOTRACE 16301 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ 16302 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...); 16303 if( iotrace && iotrace!=stdout ) fclose(iotrace); 16304 iotrace = 0; 16305 if( nArg<2 ){ 16306 sqlite3IoTrace = 0; 16307 }else if( strcmp(azArg[1], "-")==0 ){ 16308 sqlite3IoTrace = iotracePrintf; 16309 iotrace = stdout; 16310 }else{ 16311 iotrace = fopen(azArg[1], "w"); 16312 if( iotrace==0 ){ 16313 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); 16314 sqlite3IoTrace = 0; 16315 rc = 1; 16316 }else{ 16317 sqlite3IoTrace = iotracePrintf; 16318 } 16319 } 16320 }else 16321 #endif 16322 16323 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){ 16324 static const struct { 16325 const char *zLimitName; /* Name of a limit */ 16326 int limitCode; /* Integer code for that limit */ 16327 } aLimit[] = { 16328 { "length", SQLITE_LIMIT_LENGTH }, 16329 { "sql_length", SQLITE_LIMIT_SQL_LENGTH }, 16330 { "column", SQLITE_LIMIT_COLUMN }, 16331 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH }, 16332 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT }, 16333 { "vdbe_op", SQLITE_LIMIT_VDBE_OP }, 16334 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG }, 16335 { "attached", SQLITE_LIMIT_ATTACHED }, 16336 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH }, 16337 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER }, 16338 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH }, 16339 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS }, 16340 }; 16341 int i, n2; 16342 open_db(p, 0); 16343 if( nArg==1 ){ 16344 for(i=0; i<ArraySize(aLimit); i++){ 16345 printf("%20s %d\n", aLimit[i].zLimitName, 16346 sqlite3_limit(p->db, aLimit[i].limitCode, -1)); 16347 } 16348 }else if( nArg>3 ){ 16349 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n"); 16350 rc = 1; 16351 goto meta_command_exit; 16352 }else{ 16353 int iLimit = -1; 16354 n2 = strlen30(azArg[1]); 16355 for(i=0; i<ArraySize(aLimit); i++){ 16356 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){ 16357 if( iLimit<0 ){ 16358 iLimit = i; 16359 }else{ 16360 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]); 16361 rc = 1; 16362 goto meta_command_exit; 16363 } 16364 } 16365 } 16366 if( iLimit<0 ){ 16367 utf8_printf(stderr, "unknown limit: \"%s\"\n" 16368 "enter \".limits\" with no arguments for a list.\n", 16369 azArg[1]); 16370 rc = 1; 16371 goto meta_command_exit; 16372 } 16373 if( nArg==3 ){ 16374 sqlite3_limit(p->db, aLimit[iLimit].limitCode, 16375 (int)integerValue(azArg[2])); 16376 } 16377 printf("%20s %d\n", aLimit[iLimit].zLimitName, 16378 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1)); 16379 } 16380 }else 16381 16382 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){ 16383 open_db(p, 0); 16384 lintDotCommand(p, azArg, nArg); 16385 }else 16386 16387 #ifndef SQLITE_OMIT_LOAD_EXTENSION 16388 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){ 16389 const char *zFile, *zProc; 16390 char *zErrMsg = 0; 16391 if( nArg<2 ){ 16392 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n"); 16393 rc = 1; 16394 goto meta_command_exit; 16395 } 16396 zFile = azArg[1]; 16397 zProc = nArg>=3 ? azArg[2] : 0; 16398 open_db(p, 0); 16399 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); 16400 if( rc!=SQLITE_OK ){ 16401 utf8_printf(stderr, "Error: %s\n", zErrMsg); 16402 sqlite3_free(zErrMsg); 16403 rc = 1; 16404 } 16405 }else 16406 #endif 16407 16408 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){ 16409 if( nArg!=2 ){ 16410 raw_printf(stderr, "Usage: .log FILENAME\n"); 16411 rc = 1; 16412 }else{ 16413 const char *zFile = azArg[1]; 16414 output_file_close(p->pLog); 16415 p->pLog = output_file_open(zFile, 0); 16416 } 16417 }else 16418 16419 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){ 16420 const char *zMode = nArg>=2 ? azArg[1] : ""; 16421 int n2 = strlen30(zMode); 16422 int c2 = zMode[0]; 16423 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){ 16424 p->mode = MODE_Line; 16425 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 16426 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){ 16427 p->mode = MODE_Column; 16428 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 16429 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){ 16430 p->mode = MODE_List; 16431 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column); 16432 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 16433 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){ 16434 p->mode = MODE_Html; 16435 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){ 16436 p->mode = MODE_Tcl; 16437 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space); 16438 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 16439 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){ 16440 p->mode = MODE_Csv; 16441 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 16442 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 16443 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){ 16444 p->mode = MODE_List; 16445 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab); 16446 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){ 16447 p->mode = MODE_Insert; 16448 set_table_name(p, nArg>=3 ? azArg[2] : "table"); 16449 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){ 16450 p->mode = MODE_Quote; 16451 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){ 16452 p->mode = MODE_Ascii; 16453 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit); 16454 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record); 16455 }else if( nArg==1 ){ 16456 raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]); 16457 }else{ 16458 raw_printf(stderr, "Error: mode should be one of: " 16459 "ascii column csv html insert line list quote tabs tcl\n"); 16460 rc = 1; 16461 } 16462 p->cMode = p->mode; 16463 }else 16464 16465 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){ 16466 if( nArg==2 ){ 16467 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue, 16468 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]); 16469 }else{ 16470 raw_printf(stderr, "Usage: .nullvalue STRING\n"); 16471 rc = 1; 16472 } 16473 }else 16474 16475 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){ 16476 char *zNewFilename; /* Name of the database file to open */ 16477 int iName = 1; /* Index in azArg[] of the filename */ 16478 int newFlag = 0; /* True to delete file before opening */ 16479 /* Close the existing database */ 16480 session_close_all(p); 16481 close_db(p->db); 16482 p->db = 0; 16483 p->zDbFilename = 0; 16484 sqlite3_free(p->zFreeOnClose); 16485 p->zFreeOnClose = 0; 16486 p->openMode = SHELL_OPEN_UNSPEC; 16487 p->szMax = 0; 16488 /* Check for command-line arguments */ 16489 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){ 16490 const char *z = azArg[iName]; 16491 if( optionMatch(z,"new") ){ 16492 newFlag = 1; 16493 #ifdef SQLITE_HAVE_ZLIB 16494 }else if( optionMatch(z, "zip") ){ 16495 p->openMode = SHELL_OPEN_ZIPFILE; 16496 #endif 16497 }else if( optionMatch(z, "append") ){ 16498 p->openMode = SHELL_OPEN_APPENDVFS; 16499 }else if( optionMatch(z, "readonly") ){ 16500 p->openMode = SHELL_OPEN_READONLY; 16501 #ifdef SQLITE_ENABLE_DESERIALIZE 16502 }else if( optionMatch(z, "deserialize") ){ 16503 p->openMode = SHELL_OPEN_DESERIALIZE; 16504 }else if( optionMatch(z, "hexdb") ){ 16505 p->openMode = SHELL_OPEN_HEXDB; 16506 }else if( optionMatch(z, "maxsize") && iName+1<nArg ){ 16507 p->szMax = integerValue(azArg[++iName]); 16508 #endif /* SQLITE_ENABLE_DESERIALIZE */ 16509 }else if( z[0]=='-' ){ 16510 utf8_printf(stderr, "unknown option: %s\n", z); 16511 rc = 1; 16512 goto meta_command_exit; 16513 } 16514 } 16515 /* If a filename is specified, try to open it first */ 16516 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0; 16517 if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){ 16518 if( newFlag ) shellDeleteFile(zNewFilename); 16519 p->zDbFilename = zNewFilename; 16520 open_db(p, OPEN_DB_KEEPALIVE); 16521 if( p->db==0 ){ 16522 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename); 16523 sqlite3_free(zNewFilename); 16524 }else{ 16525 p->zFreeOnClose = zNewFilename; 16526 } 16527 } 16528 if( p->db==0 ){ 16529 /* As a fall-back open a TEMP database */ 16530 p->zDbFilename = 0; 16531 open_db(p, 0); 16532 } 16533 }else 16534 16535 if( (c=='o' 16536 && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0)) 16537 || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0) 16538 ){ 16539 const char *zFile = nArg>=2 ? azArg[1] : "stdout"; 16540 int bTxtMode = 0; 16541 if( azArg[0][0]=='e' ){ 16542 /* Transform the ".excel" command into ".once -x" */ 16543 nArg = 2; 16544 azArg[0] = "once"; 16545 zFile = azArg[1] = "-x"; 16546 n = 4; 16547 } 16548 if( nArg>2 ){ 16549 utf8_printf(stderr, "Usage: .%s [-e|-x|FILE]\n", azArg[0]); 16550 rc = 1; 16551 goto meta_command_exit; 16552 } 16553 if( n>1 && strncmp(azArg[0], "once", n)==0 ){ 16554 if( nArg<2 ){ 16555 raw_printf(stderr, "Usage: .once (-e|-x|FILE)\n"); 16556 rc = 1; 16557 goto meta_command_exit; 16558 } 16559 p->outCount = 2; 16560 }else{ 16561 p->outCount = 0; 16562 } 16563 output_reset(p); 16564 if( zFile[0]=='-' && zFile[1]=='-' ) zFile++; 16565 #ifndef SQLITE_NOHAVE_SYSTEM 16566 if( strcmp(zFile, "-e")==0 || strcmp(zFile, "-x")==0 ){ 16567 p->doXdgOpen = 1; 16568 outputModePush(p); 16569 if( zFile[1]=='x' ){ 16570 newTempFile(p, "csv"); 16571 p->mode = MODE_Csv; 16572 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 16573 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 16574 }else{ 16575 newTempFile(p, "txt"); 16576 bTxtMode = 1; 16577 } 16578 zFile = p->zTempFile; 16579 } 16580 #endif /* SQLITE_NOHAVE_SYSTEM */ 16581 if( zFile[0]=='|' ){ 16582 #ifdef SQLITE_OMIT_POPEN 16583 raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 16584 rc = 1; 16585 p->out = stdout; 16586 #else 16587 p->out = popen(zFile + 1, "w"); 16588 if( p->out==0 ){ 16589 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1); 16590 p->out = stdout; 16591 rc = 1; 16592 }else{ 16593 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 16594 } 16595 #endif 16596 }else{ 16597 p->out = output_file_open(zFile, bTxtMode); 16598 if( p->out==0 ){ 16599 if( strcmp(zFile,"off")!=0 ){ 16600 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile); 16601 } 16602 p->out = stdout; 16603 rc = 1; 16604 } else { 16605 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 16606 } 16607 } 16608 }else 16609 16610 if( c=='p' && n>=3 && strncmp(azArg[0], "parameter", n)==0 ){ 16611 open_db(p,0); 16612 if( nArg<=1 ) goto parameter_syntax_error; 16613 16614 /* .parameter clear 16615 ** Clear all bind parameters by dropping the TEMP table that holds them. 16616 */ 16617 if( nArg==2 && strcmp(azArg[1],"clear")==0 ){ 16618 int wrSchema = 0; 16619 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema); 16620 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0); 16621 sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;", 16622 0, 0, 0); 16623 sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0); 16624 }else 16625 16626 /* .parameter list 16627 ** List all bind parameters. 16628 */ 16629 if( nArg==2 && strcmp(azArg[1],"list")==0 ){ 16630 sqlite3_stmt *pStmt = 0; 16631 int rx; 16632 int len = 0; 16633 rx = sqlite3_prepare_v2(p->db, 16634 "SELECT max(length(key)) " 16635 "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 16636 if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ 16637 len = sqlite3_column_int(pStmt, 0); 16638 if( len>40 ) len = 40; 16639 } 16640 sqlite3_finalize(pStmt); 16641 pStmt = 0; 16642 if( len ){ 16643 rx = sqlite3_prepare_v2(p->db, 16644 "SELECT key, quote(value) " 16645 "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 16646 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 16647 utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0), 16648 sqlite3_column_text(pStmt,1)); 16649 } 16650 sqlite3_finalize(pStmt); 16651 } 16652 }else 16653 16654 /* .parameter init 16655 ** Make sure the TEMP table used to hold bind parameters exists. 16656 ** Create it if necessary. 16657 */ 16658 if( nArg==2 && strcmp(azArg[1],"init")==0 ){ 16659 bind_table_init(p); 16660 }else 16661 16662 /* .parameter set NAME VALUE 16663 ** Set or reset a bind parameter. NAME should be the full parameter 16664 ** name exactly as it appears in the query. (ex: $abc, @def). The 16665 ** VALUE can be in either SQL literal notation, or if not it will be 16666 ** understood to be a text string. 16667 */ 16668 if( nArg==4 && strcmp(azArg[1],"set")==0 ){ 16669 int rx; 16670 char *zSql; 16671 sqlite3_stmt *pStmt; 16672 const char *zKey = azArg[2]; 16673 const char *zValue = azArg[3]; 16674 bind_table_init(p); 16675 zSql = sqlite3_mprintf( 16676 "REPLACE INTO temp.sqlite_parameters(key,value)" 16677 "VALUES(%Q,%s);", zKey, zValue); 16678 if( zSql==0 ) shell_out_of_memory(); 16679 pStmt = 0; 16680 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 16681 sqlite3_free(zSql); 16682 if( rx!=SQLITE_OK ){ 16683 sqlite3_finalize(pStmt); 16684 pStmt = 0; 16685 zSql = sqlite3_mprintf( 16686 "REPLACE INTO temp.sqlite_parameters(key,value)" 16687 "VALUES(%Q,%Q);", zKey, zValue); 16688 if( zSql==0 ) shell_out_of_memory(); 16689 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 16690 sqlite3_free(zSql); 16691 if( rx!=SQLITE_OK ){ 16692 utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db)); 16693 sqlite3_finalize(pStmt); 16694 pStmt = 0; 16695 rc = 1; 16696 } 16697 } 16698 sqlite3_step(pStmt); 16699 sqlite3_finalize(pStmt); 16700 }else 16701 16702 /* .parameter unset NAME 16703 ** Remove the NAME binding from the parameter binding table, if it 16704 ** exists. 16705 */ 16706 if( nArg==3 && strcmp(azArg[1],"unset")==0 ){ 16707 char *zSql = sqlite3_mprintf( 16708 "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]); 16709 if( zSql==0 ) shell_out_of_memory(); 16710 sqlite3_exec(p->db, zSql, 0, 0, 0); 16711 sqlite3_free(zSql); 16712 }else 16713 /* If no command name matches, show a syntax error */ 16714 parameter_syntax_error: 16715 showHelp(p->out, "parameter"); 16716 }else 16717 16718 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){ 16719 int i; 16720 for(i=1; i<nArg; i++){ 16721 if( i>1 ) raw_printf(p->out, " "); 16722 utf8_printf(p->out, "%s", azArg[i]); 16723 } 16724 raw_printf(p->out, "\n"); 16725 }else 16726 16727 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 16728 if( c=='p' && n>=3 && strncmp(azArg[0], "progress", n)==0 ){ 16729 int i; 16730 int nn = 0; 16731 p->flgProgress = 0; 16732 p->mxProgress = 0; 16733 p->nProgress = 0; 16734 for(i=1; i<nArg; i++){ 16735 const char *z = azArg[i]; 16736 if( z[0]=='-' ){ 16737 z++; 16738 if( z[0]=='-' ) z++; 16739 if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){ 16740 p->flgProgress |= SHELL_PROGRESS_QUIET; 16741 continue; 16742 } 16743 if( strcmp(z,"reset")==0 ){ 16744 p->flgProgress |= SHELL_PROGRESS_RESET; 16745 continue; 16746 } 16747 if( strcmp(z,"once")==0 ){ 16748 p->flgProgress |= SHELL_PROGRESS_ONCE; 16749 continue; 16750 } 16751 if( strcmp(z,"limit")==0 ){ 16752 if( i+1>=nArg ){ 16753 utf8_printf(stderr, "Error: missing argument on --limit\n"); 16754 rc = 1; 16755 goto meta_command_exit; 16756 }else{ 16757 p->mxProgress = (int)integerValue(azArg[++i]); 16758 } 16759 continue; 16760 } 16761 utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]); 16762 rc = 1; 16763 goto meta_command_exit; 16764 }else{ 16765 nn = (int)integerValue(z); 16766 } 16767 } 16768 open_db(p, 0); 16769 sqlite3_progress_handler(p->db, nn, progress_handler, p); 16770 }else 16771 #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 16772 16773 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){ 16774 if( nArg >= 2) { 16775 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); 16776 } 16777 if( nArg >= 3) { 16778 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); 16779 } 16780 }else 16781 16782 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){ 16783 rc = 2; 16784 }else 16785 16786 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){ 16787 FILE *inSaved = p->in; 16788 int savedLineno = p->lineno; 16789 if( nArg!=2 ){ 16790 raw_printf(stderr, "Usage: .read FILE\n"); 16791 rc = 1; 16792 goto meta_command_exit; 16793 } 16794 p->in = fopen(azArg[1], "rb"); 16795 if( p->in==0 ){ 16796 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); 16797 rc = 1; 16798 }else{ 16799 rc = process_input(p); 16800 fclose(p->in); 16801 } 16802 p->in = inSaved; 16803 p->lineno = savedLineno; 16804 }else 16805 16806 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){ 16807 const char *zSrcFile; 16808 const char *zDb; 16809 sqlite3 *pSrc; 16810 sqlite3_backup *pBackup; 16811 int nTimeout = 0; 16812 16813 if( nArg==2 ){ 16814 zSrcFile = azArg[1]; 16815 zDb = "main"; 16816 }else if( nArg==3 ){ 16817 zSrcFile = azArg[2]; 16818 zDb = azArg[1]; 16819 }else{ 16820 raw_printf(stderr, "Usage: .restore ?DB? FILE\n"); 16821 rc = 1; 16822 goto meta_command_exit; 16823 } 16824 rc = sqlite3_open(zSrcFile, &pSrc); 16825 if( rc!=SQLITE_OK ){ 16826 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); 16827 close_db(pSrc); 16828 return 1; 16829 } 16830 open_db(p, 0); 16831 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); 16832 if( pBackup==0 ){ 16833 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 16834 close_db(pSrc); 16835 return 1; 16836 } 16837 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK 16838 || rc==SQLITE_BUSY ){ 16839 if( rc==SQLITE_BUSY ){ 16840 if( nTimeout++ >= 3 ) break; 16841 sqlite3_sleep(100); 16842 } 16843 } 16844 sqlite3_backup_finish(pBackup); 16845 if( rc==SQLITE_DONE ){ 16846 rc = 0; 16847 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ 16848 raw_printf(stderr, "Error: source database is busy\n"); 16849 rc = 1; 16850 }else{ 16851 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 16852 rc = 1; 16853 } 16854 close_db(pSrc); 16855 }else 16856 16857 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){ 16858 if( nArg==2 ){ 16859 p->scanstatsOn = (u8)booleanValue(azArg[1]); 16860 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS 16861 raw_printf(stderr, "Warning: .scanstats not available in this build.\n"); 16862 #endif 16863 }else{ 16864 raw_printf(stderr, "Usage: .scanstats on|off\n"); 16865 rc = 1; 16866 } 16867 }else 16868 16869 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){ 16870 ShellText sSelect; 16871 ShellState data; 16872 char *zErrMsg = 0; 16873 const char *zDiv = "("; 16874 const char *zName = 0; 16875 int iSchema = 0; 16876 int bDebug = 0; 16877 int ii; 16878 16879 open_db(p, 0); 16880 memcpy(&data, p, sizeof(data)); 16881 data.showHeader = 0; 16882 data.cMode = data.mode = MODE_Semi; 16883 initText(&sSelect); 16884 for(ii=1; ii<nArg; ii++){ 16885 if( optionMatch(azArg[ii],"indent") ){ 16886 data.cMode = data.mode = MODE_Pretty; 16887 }else if( optionMatch(azArg[ii],"debug") ){ 16888 bDebug = 1; 16889 }else if( zName==0 ){ 16890 zName = azArg[ii]; 16891 }else{ 16892 raw_printf(stderr, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n"); 16893 rc = 1; 16894 goto meta_command_exit; 16895 } 16896 } 16897 if( zName!=0 ){ 16898 int isMaster = sqlite3_strlike(zName, "sqlite_master", '\\')==0; 16899 if( isMaster || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0 ){ 16900 char *new_argv[2], *new_colv[2]; 16901 new_argv[0] = sqlite3_mprintf( 16902 "CREATE TABLE %s (\n" 16903 " type text,\n" 16904 " name text,\n" 16905 " tbl_name text,\n" 16906 " rootpage integer,\n" 16907 " sql text\n" 16908 ")", isMaster ? "sqlite_master" : "sqlite_temp_master"); 16909 new_argv[1] = 0; 16910 new_colv[0] = "sql"; 16911 new_colv[1] = 0; 16912 callback(&data, 1, new_argv, new_colv); 16913 sqlite3_free(new_argv[0]); 16914 } 16915 } 16916 if( zDiv ){ 16917 sqlite3_stmt *pStmt = 0; 16918 rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list", 16919 -1, &pStmt, 0); 16920 if( rc ){ 16921 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 16922 sqlite3_finalize(pStmt); 16923 rc = 1; 16924 goto meta_command_exit; 16925 } 16926 appendText(&sSelect, "SELECT sql FROM", 0); 16927 iSchema = 0; 16928 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 16929 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0); 16930 char zScNum[30]; 16931 sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema); 16932 appendText(&sSelect, zDiv, 0); 16933 zDiv = " UNION ALL "; 16934 appendText(&sSelect, "SELECT shell_add_schema(sql,", 0); 16935 if( sqlite3_stricmp(zDb, "main")!=0 ){ 16936 appendText(&sSelect, zDb, '"'); 16937 }else{ 16938 appendText(&sSelect, "NULL", 0); 16939 } 16940 appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0); 16941 appendText(&sSelect, zScNum, 0); 16942 appendText(&sSelect, " AS snum, ", 0); 16943 appendText(&sSelect, zDb, '\''); 16944 appendText(&sSelect, " AS sname FROM ", 0); 16945 appendText(&sSelect, zDb, '"'); 16946 appendText(&sSelect, ".sqlite_master", 0); 16947 } 16948 sqlite3_finalize(pStmt); 16949 #ifdef SQLITE_INTROSPECTION_PRAGMAS 16950 if( zName ){ 16951 appendText(&sSelect, 16952 " UNION ALL SELECT shell_module_schema(name)," 16953 " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list", 0); 16954 } 16955 #endif 16956 appendText(&sSelect, ") WHERE ", 0); 16957 if( zName ){ 16958 char *zQarg = sqlite3_mprintf("%Q", zName); 16959 int bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 || 16960 strchr(zName, '[') != 0; 16961 if( strchr(zName, '.') ){ 16962 appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0); 16963 }else{ 16964 appendText(&sSelect, "lower(tbl_name)", 0); 16965 } 16966 appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0); 16967 appendText(&sSelect, zQarg, 0); 16968 if( !bGlob ){ 16969 appendText(&sSelect, " ESCAPE '\\' ", 0); 16970 } 16971 appendText(&sSelect, " AND ", 0); 16972 sqlite3_free(zQarg); 16973 } 16974 appendText(&sSelect, "type!='meta' AND sql IS NOT NULL" 16975 " ORDER BY snum, rowid", 0); 16976 if( bDebug ){ 16977 utf8_printf(p->out, "SQL: %s;\n", sSelect.z); 16978 }else{ 16979 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg); 16980 } 16981 freeText(&sSelect); 16982 } 16983 if( zErrMsg ){ 16984 utf8_printf(stderr,"Error: %s\n", zErrMsg); 16985 sqlite3_free(zErrMsg); 16986 rc = 1; 16987 }else if( rc != SQLITE_OK ){ 16988 raw_printf(stderr,"Error: querying schema information\n"); 16989 rc = 1; 16990 }else{ 16991 rc = 0; 16992 } 16993 }else 16994 16995 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) 16996 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){ 16997 sqlite3SelectTrace = (int)integerValue(azArg[1]); 16998 }else 16999 #endif 17000 17001 #if defined(SQLITE_ENABLE_SESSION) 17002 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){ 17003 OpenSession *pSession = &p->aSession[0]; 17004 char **azCmd = &azArg[1]; 17005 int iSes = 0; 17006 int nCmd = nArg - 1; 17007 int i; 17008 if( nArg<=1 ) goto session_syntax_error; 17009 open_db(p, 0); 17010 if( nArg>=3 ){ 17011 for(iSes=0; iSes<p->nSession; iSes++){ 17012 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break; 17013 } 17014 if( iSes<p->nSession ){ 17015 pSession = &p->aSession[iSes]; 17016 azCmd++; 17017 nCmd--; 17018 }else{ 17019 pSession = &p->aSession[0]; 17020 iSes = 0; 17021 } 17022 } 17023 17024 /* .session attach TABLE 17025 ** Invoke the sqlite3session_attach() interface to attach a particular 17026 ** table so that it is never filtered. 17027 */ 17028 if( strcmp(azCmd[0],"attach")==0 ){ 17029 if( nCmd!=2 ) goto session_syntax_error; 17030 if( pSession->p==0 ){ 17031 session_not_open: 17032 raw_printf(stderr, "ERROR: No sessions are open\n"); 17033 }else{ 17034 rc = sqlite3session_attach(pSession->p, azCmd[1]); 17035 if( rc ){ 17036 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc); 17037 rc = 0; 17038 } 17039 } 17040 }else 17041 17042 /* .session changeset FILE 17043 ** .session patchset FILE 17044 ** Write a changeset or patchset into a file. The file is overwritten. 17045 */ 17046 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){ 17047 FILE *out = 0; 17048 if( nCmd!=2 ) goto session_syntax_error; 17049 if( pSession->p==0 ) goto session_not_open; 17050 out = fopen(azCmd[1], "wb"); 17051 if( out==0 ){ 17052 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n", azCmd[1]); 17053 }else{ 17054 int szChng; 17055 void *pChng; 17056 if( azCmd[0][0]=='c' ){ 17057 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng); 17058 }else{ 17059 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng); 17060 } 17061 if( rc ){ 17062 printf("Error: error code %d\n", rc); 17063 rc = 0; 17064 } 17065 if( pChng 17066 && fwrite(pChng, szChng, 1, out)!=1 ){ 17067 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n", 17068 szChng); 17069 } 17070 sqlite3_free(pChng); 17071 fclose(out); 17072 } 17073 }else 17074 17075 /* .session close 17076 ** Close the identified session 17077 */ 17078 if( strcmp(azCmd[0], "close")==0 ){ 17079 if( nCmd!=1 ) goto session_syntax_error; 17080 if( p->nSession ){ 17081 session_close(pSession); 17082 p->aSession[iSes] = p->aSession[--p->nSession]; 17083 } 17084 }else 17085 17086 /* .session enable ?BOOLEAN? 17087 ** Query or set the enable flag 17088 */ 17089 if( strcmp(azCmd[0], "enable")==0 ){ 17090 int ii; 17091 if( nCmd>2 ) goto session_syntax_error; 17092 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 17093 if( p->nSession ){ 17094 ii = sqlite3session_enable(pSession->p, ii); 17095 utf8_printf(p->out, "session %s enable flag = %d\n", 17096 pSession->zName, ii); 17097 } 17098 }else 17099 17100 /* .session filter GLOB .... 17101 ** Set a list of GLOB patterns of table names to be excluded. 17102 */ 17103 if( strcmp(azCmd[0], "filter")==0 ){ 17104 int ii, nByte; 17105 if( nCmd<2 ) goto session_syntax_error; 17106 if( p->nSession ){ 17107 for(ii=0; ii<pSession->nFilter; ii++){ 17108 sqlite3_free(pSession->azFilter[ii]); 17109 } 17110 sqlite3_free(pSession->azFilter); 17111 nByte = sizeof(pSession->azFilter[0])*(nCmd-1); 17112 pSession->azFilter = sqlite3_malloc( nByte ); 17113 if( pSession->azFilter==0 ){ 17114 raw_printf(stderr, "Error: out or memory\n"); 17115 exit(1); 17116 } 17117 for(ii=1; ii<nCmd; ii++){ 17118 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]); 17119 } 17120 pSession->nFilter = ii-1; 17121 } 17122 }else 17123 17124 /* .session indirect ?BOOLEAN? 17125 ** Query or set the indirect flag 17126 */ 17127 if( strcmp(azCmd[0], "indirect")==0 ){ 17128 int ii; 17129 if( nCmd>2 ) goto session_syntax_error; 17130 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 17131 if( p->nSession ){ 17132 ii = sqlite3session_indirect(pSession->p, ii); 17133 utf8_printf(p->out, "session %s indirect flag = %d\n", 17134 pSession->zName, ii); 17135 } 17136 }else 17137 17138 /* .session isempty 17139 ** Determine if the session is empty 17140 */ 17141 if( strcmp(azCmd[0], "isempty")==0 ){ 17142 int ii; 17143 if( nCmd!=1 ) goto session_syntax_error; 17144 if( p->nSession ){ 17145 ii = sqlite3session_isempty(pSession->p); 17146 utf8_printf(p->out, "session %s isempty flag = %d\n", 17147 pSession->zName, ii); 17148 } 17149 }else 17150 17151 /* .session list 17152 ** List all currently open sessions 17153 */ 17154 if( strcmp(azCmd[0],"list")==0 ){ 17155 for(i=0; i<p->nSession; i++){ 17156 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName); 17157 } 17158 }else 17159 17160 /* .session open DB NAME 17161 ** Open a new session called NAME on the attached database DB. 17162 ** DB is normally "main". 17163 */ 17164 if( strcmp(azCmd[0],"open")==0 ){ 17165 char *zName; 17166 if( nCmd!=3 ) goto session_syntax_error; 17167 zName = azCmd[2]; 17168 if( zName[0]==0 ) goto session_syntax_error; 17169 for(i=0; i<p->nSession; i++){ 17170 if( strcmp(p->aSession[i].zName,zName)==0 ){ 17171 utf8_printf(stderr, "Session \"%s\" already exists\n", zName); 17172 goto meta_command_exit; 17173 } 17174 } 17175 if( p->nSession>=ArraySize(p->aSession) ){ 17176 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession)); 17177 goto meta_command_exit; 17178 } 17179 pSession = &p->aSession[p->nSession]; 17180 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p); 17181 if( rc ){ 17182 raw_printf(stderr, "Cannot open session: error code=%d\n", rc); 17183 rc = 0; 17184 goto meta_command_exit; 17185 } 17186 pSession->nFilter = 0; 17187 sqlite3session_table_filter(pSession->p, session_filter, pSession); 17188 p->nSession++; 17189 pSession->zName = sqlite3_mprintf("%s", zName); 17190 }else 17191 /* If no command name matches, show a syntax error */ 17192 session_syntax_error: 17193 showHelp(p->out, "session"); 17194 }else 17195 #endif 17196 17197 #ifdef SQLITE_DEBUG 17198 /* Undocumented commands for internal testing. Subject to change 17199 ** without notice. */ 17200 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){ 17201 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){ 17202 int i, v; 17203 for(i=1; i<nArg; i++){ 17204 v = booleanValue(azArg[i]); 17205 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v); 17206 } 17207 } 17208 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){ 17209 int i; sqlite3_int64 v; 17210 for(i=1; i<nArg; i++){ 17211 char zBuf[200]; 17212 v = integerValue(azArg[i]); 17213 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v); 17214 utf8_printf(p->out, "%s", zBuf); 17215 } 17216 } 17217 }else 17218 #endif 17219 17220 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){ 17221 int bIsInit = 0; /* True to initialize the SELFTEST table */ 17222 int bVerbose = 0; /* Verbose output */ 17223 int bSelftestExists; /* True if SELFTEST already exists */ 17224 int i, k; /* Loop counters */ 17225 int nTest = 0; /* Number of tests runs */ 17226 int nErr = 0; /* Number of errors seen */ 17227 ShellText str; /* Answer for a query */ 17228 sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */ 17229 17230 open_db(p,0); 17231 for(i=1; i<nArg; i++){ 17232 const char *z = azArg[i]; 17233 if( z[0]=='-' && z[1]=='-' ) z++; 17234 if( strcmp(z,"-init")==0 ){ 17235 bIsInit = 1; 17236 }else 17237 if( strcmp(z,"-v")==0 ){ 17238 bVerbose++; 17239 }else 17240 { 17241 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 17242 azArg[i], azArg[0]); 17243 raw_printf(stderr, "Should be one of: --init -v\n"); 17244 rc = 1; 17245 goto meta_command_exit; 17246 } 17247 } 17248 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0) 17249 != SQLITE_OK ){ 17250 bSelftestExists = 0; 17251 }else{ 17252 bSelftestExists = 1; 17253 } 17254 if( bIsInit ){ 17255 createSelftestTable(p); 17256 bSelftestExists = 1; 17257 } 17258 initText(&str); 17259 appendText(&str, "x", 0); 17260 for(k=bSelftestExists; k>=0; k--){ 17261 if( k==1 ){ 17262 rc = sqlite3_prepare_v2(p->db, 17263 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno", 17264 -1, &pStmt, 0); 17265 }else{ 17266 rc = sqlite3_prepare_v2(p->db, 17267 "VALUES(0,'memo','Missing SELFTEST table - default checks only','')," 17268 " (1,'run','PRAGMA integrity_check','ok')", 17269 -1, &pStmt, 0); 17270 } 17271 if( rc ){ 17272 raw_printf(stderr, "Error querying the selftest table\n"); 17273 rc = 1; 17274 sqlite3_finalize(pStmt); 17275 goto meta_command_exit; 17276 } 17277 for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){ 17278 int tno = sqlite3_column_int(pStmt, 0); 17279 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1); 17280 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2); 17281 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3); 17282 17283 k = 0; 17284 if( bVerbose>0 ){ 17285 char *zQuote = sqlite3_mprintf("%q", zSql); 17286 printf("%d: %s %s\n", tno, zOp, zSql); 17287 sqlite3_free(zQuote); 17288 } 17289 if( strcmp(zOp,"memo")==0 ){ 17290 utf8_printf(p->out, "%s\n", zSql); 17291 }else 17292 if( strcmp(zOp,"run")==0 ){ 17293 char *zErrMsg = 0; 17294 str.n = 0; 17295 str.z[0] = 0; 17296 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg); 17297 nTest++; 17298 if( bVerbose ){ 17299 utf8_printf(p->out, "Result: %s\n", str.z); 17300 } 17301 if( rc || zErrMsg ){ 17302 nErr++; 17303 rc = 1; 17304 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg); 17305 sqlite3_free(zErrMsg); 17306 }else if( strcmp(zAns,str.z)!=0 ){ 17307 nErr++; 17308 rc = 1; 17309 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns); 17310 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z); 17311 } 17312 }else 17313 { 17314 utf8_printf(stderr, 17315 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno); 17316 rc = 1; 17317 break; 17318 } 17319 } /* End loop over rows of content from SELFTEST */ 17320 sqlite3_finalize(pStmt); 17321 } /* End loop over k */ 17322 freeText(&str); 17323 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest); 17324 }else 17325 17326 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){ 17327 if( nArg<2 || nArg>3 ){ 17328 raw_printf(stderr, "Usage: .separator COL ?ROW?\n"); 17329 rc = 1; 17330 } 17331 if( nArg>=2 ){ 17332 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, 17333 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]); 17334 } 17335 if( nArg>=3 ){ 17336 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, 17337 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]); 17338 } 17339 }else 17340 17341 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){ 17342 const char *zLike = 0; /* Which table to checksum. 0 means everything */ 17343 int i; /* Loop counter */ 17344 int bSchema = 0; /* Also hash the schema */ 17345 int bSeparate = 0; /* Hash each table separately */ 17346 int iSize = 224; /* Hash algorithm to use */ 17347 int bDebug = 0; /* Only show the query that would have run */ 17348 sqlite3_stmt *pStmt; /* For querying tables names */ 17349 char *zSql; /* SQL to be run */ 17350 char *zSep; /* Separator */ 17351 ShellText sSql; /* Complete SQL for the query to run the hash */ 17352 ShellText sQuery; /* Set of queries used to read all content */ 17353 open_db(p, 0); 17354 for(i=1; i<nArg; i++){ 17355 const char *z = azArg[i]; 17356 if( z[0]=='-' ){ 17357 z++; 17358 if( z[0]=='-' ) z++; 17359 if( strcmp(z,"schema")==0 ){ 17360 bSchema = 1; 17361 }else 17362 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0 17363 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0 17364 ){ 17365 iSize = atoi(&z[5]); 17366 }else 17367 if( strcmp(z,"debug")==0 ){ 17368 bDebug = 1; 17369 }else 17370 { 17371 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 17372 azArg[i], azArg[0]); 17373 raw_printf(stderr, "Should be one of: --schema" 17374 " --sha3-224 --sha3-256 --sha3-384 --sha3-512\n"); 17375 rc = 1; 17376 goto meta_command_exit; 17377 } 17378 }else if( zLike ){ 17379 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n"); 17380 rc = 1; 17381 goto meta_command_exit; 17382 }else{ 17383 zLike = z; 17384 bSeparate = 1; 17385 if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1; 17386 } 17387 } 17388 if( bSchema ){ 17389 zSql = "SELECT lower(name) FROM sqlite_master" 17390 " WHERE type='table' AND coalesce(rootpage,0)>1" 17391 " UNION ALL SELECT 'sqlite_master'" 17392 " ORDER BY 1 collate nocase"; 17393 }else{ 17394 zSql = "SELECT lower(name) FROM sqlite_master" 17395 " WHERE type='table' AND coalesce(rootpage,0)>1" 17396 " AND name NOT LIKE 'sqlite_%'" 17397 " ORDER BY 1 collate nocase"; 17398 } 17399 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 17400 initText(&sQuery); 17401 initText(&sSql); 17402 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0); 17403 zSep = "VALUES("; 17404 while( SQLITE_ROW==sqlite3_step(pStmt) ){ 17405 const char *zTab = (const char*)sqlite3_column_text(pStmt,0); 17406 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue; 17407 if( strncmp(zTab, "sqlite_",7)!=0 ){ 17408 appendText(&sQuery,"SELECT * FROM ", 0); 17409 appendText(&sQuery,zTab,'"'); 17410 appendText(&sQuery," NOT INDEXED;", 0); 17411 }else if( strcmp(zTab, "sqlite_master")==0 ){ 17412 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master" 17413 " ORDER BY name;", 0); 17414 }else if( strcmp(zTab, "sqlite_sequence")==0 ){ 17415 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence" 17416 " ORDER BY name;", 0); 17417 }else if( strcmp(zTab, "sqlite_stat1")==0 ){ 17418 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1" 17419 " ORDER BY tbl,idx;", 0); 17420 }else if( strcmp(zTab, "sqlite_stat3")==0 17421 || strcmp(zTab, "sqlite_stat4")==0 ){ 17422 appendText(&sQuery, "SELECT * FROM ", 0); 17423 appendText(&sQuery, zTab, 0); 17424 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0); 17425 } 17426 appendText(&sSql, zSep, 0); 17427 appendText(&sSql, sQuery.z, '\''); 17428 sQuery.n = 0; 17429 appendText(&sSql, ",", 0); 17430 appendText(&sSql, zTab, '\''); 17431 zSep = "),("; 17432 } 17433 sqlite3_finalize(pStmt); 17434 if( bSeparate ){ 17435 zSql = sqlite3_mprintf( 17436 "%s))" 17437 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label" 17438 " FROM [sha3sum$query]", 17439 sSql.z, iSize); 17440 }else{ 17441 zSql = sqlite3_mprintf( 17442 "%s))" 17443 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash" 17444 " FROM [sha3sum$query]", 17445 sSql.z, iSize); 17446 } 17447 freeText(&sQuery); 17448 freeText(&sSql); 17449 if( bDebug ){ 17450 utf8_printf(p->out, "%s\n", zSql); 17451 }else{ 17452 shell_exec(p, zSql, 0); 17453 } 17454 sqlite3_free(zSql); 17455 }else 17456 17457 #ifndef SQLITE_NOHAVE_SYSTEM 17458 if( c=='s' 17459 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0) 17460 ){ 17461 char *zCmd; 17462 int i, x; 17463 if( nArg<2 ){ 17464 raw_printf(stderr, "Usage: .system COMMAND\n"); 17465 rc = 1; 17466 goto meta_command_exit; 17467 } 17468 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]); 17469 for(i=2; i<nArg; i++){ 17470 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"", 17471 zCmd, azArg[i]); 17472 } 17473 x = system(zCmd); 17474 sqlite3_free(zCmd); 17475 if( x ) raw_printf(stderr, "System command returns %d\n", x); 17476 }else 17477 #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 17478 17479 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){ 17480 static const char *azBool[] = { "off", "on", "trigger", "full"}; 17481 int i; 17482 if( nArg!=1 ){ 17483 raw_printf(stderr, "Usage: .show\n"); 17484 rc = 1; 17485 goto meta_command_exit; 17486 } 17487 utf8_printf(p->out, "%12.12s: %s\n","echo", 17488 azBool[ShellHasFlag(p, SHFLG_Echo)]); 17489 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]); 17490 utf8_printf(p->out, "%12.12s: %s\n","explain", 17491 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off"); 17492 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]); 17493 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]); 17494 utf8_printf(p->out, "%12.12s: ", "nullvalue"); 17495 output_c_string(p->out, p->nullValue); 17496 raw_printf(p->out, "\n"); 17497 utf8_printf(p->out,"%12.12s: %s\n","output", 17498 strlen30(p->outfile) ? p->outfile : "stdout"); 17499 utf8_printf(p->out,"%12.12s: ", "colseparator"); 17500 output_c_string(p->out, p->colSeparator); 17501 raw_printf(p->out, "\n"); 17502 utf8_printf(p->out,"%12.12s: ", "rowseparator"); 17503 output_c_string(p->out, p->rowSeparator); 17504 raw_printf(p->out, "\n"); 17505 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]); 17506 utf8_printf(p->out, "%12.12s: ", "width"); 17507 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) { 17508 raw_printf(p->out, "%d ", p->colWidth[i]); 17509 } 17510 raw_printf(p->out, "\n"); 17511 utf8_printf(p->out, "%12.12s: %s\n", "filename", 17512 p->zDbFilename ? p->zDbFilename : ""); 17513 }else 17514 17515 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){ 17516 if( nArg==2 ){ 17517 p->statsOn = (u8)booleanValue(azArg[1]); 17518 }else if( nArg==1 ){ 17519 display_stats(p->db, p, 0); 17520 }else{ 17521 raw_printf(stderr, "Usage: .stats ?on|off?\n"); 17522 rc = 1; 17523 } 17524 }else 17525 17526 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0) 17527 || (c=='i' && (strncmp(azArg[0], "indices", n)==0 17528 || strncmp(azArg[0], "indexes", n)==0) ) 17529 ){ 17530 sqlite3_stmt *pStmt; 17531 char **azResult; 17532 int nRow, nAlloc; 17533 int ii; 17534 ShellText s; 17535 initText(&s); 17536 open_db(p, 0); 17537 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); 17538 if( rc ){ 17539 sqlite3_finalize(pStmt); 17540 return shellDatabaseError(p->db); 17541 } 17542 17543 if( nArg>2 && c=='i' ){ 17544 /* It is an historical accident that the .indexes command shows an error 17545 ** when called with the wrong number of arguments whereas the .tables 17546 ** command does not. */ 17547 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n"); 17548 rc = 1; 17549 sqlite3_finalize(pStmt); 17550 goto meta_command_exit; 17551 } 17552 for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){ 17553 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1); 17554 if( zDbName==0 ) continue; 17555 if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0); 17556 if( sqlite3_stricmp(zDbName, "main")==0 ){ 17557 appendText(&s, "SELECT name FROM ", 0); 17558 }else{ 17559 appendText(&s, "SELECT ", 0); 17560 appendText(&s, zDbName, '\''); 17561 appendText(&s, "||'.'||name FROM ", 0); 17562 } 17563 appendText(&s, zDbName, '"'); 17564 appendText(&s, ".sqlite_master ", 0); 17565 if( c=='t' ){ 17566 appendText(&s," WHERE type IN ('table','view')" 17567 " AND name NOT LIKE 'sqlite_%'" 17568 " AND name LIKE ?1", 0); 17569 }else{ 17570 appendText(&s," WHERE type='index'" 17571 " AND tbl_name LIKE ?1", 0); 17572 } 17573 } 17574 rc = sqlite3_finalize(pStmt); 17575 appendText(&s, " ORDER BY 1", 0); 17576 rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0); 17577 freeText(&s); 17578 if( rc ) return shellDatabaseError(p->db); 17579 17580 /* Run the SQL statement prepared by the above block. Store the results 17581 ** as an array of nul-terminated strings in azResult[]. */ 17582 nRow = nAlloc = 0; 17583 azResult = 0; 17584 if( nArg>1 ){ 17585 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT); 17586 }else{ 17587 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC); 17588 } 17589 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 17590 if( nRow>=nAlloc ){ 17591 char **azNew; 17592 int n2 = nAlloc*2 + 10; 17593 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2); 17594 if( azNew==0 ) shell_out_of_memory(); 17595 nAlloc = n2; 17596 azResult = azNew; 17597 } 17598 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0)); 17599 if( 0==azResult[nRow] ) shell_out_of_memory(); 17600 nRow++; 17601 } 17602 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){ 17603 rc = shellDatabaseError(p->db); 17604 } 17605 17606 /* Pretty-print the contents of array azResult[] to the output */ 17607 if( rc==0 && nRow>0 ){ 17608 int len, maxlen = 0; 17609 int i, j; 17610 int nPrintCol, nPrintRow; 17611 for(i=0; i<nRow; i++){ 17612 len = strlen30(azResult[i]); 17613 if( len>maxlen ) maxlen = len; 17614 } 17615 nPrintCol = 80/(maxlen+2); 17616 if( nPrintCol<1 ) nPrintCol = 1; 17617 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; 17618 for(i=0; i<nPrintRow; i++){ 17619 for(j=i; j<nRow; j+=nPrintRow){ 17620 char *zSp = j<nPrintRow ? "" : " "; 17621 utf8_printf(p->out, "%s%-*s", zSp, maxlen, 17622 azResult[j] ? azResult[j]:""); 17623 } 17624 raw_printf(p->out, "\n"); 17625 } 17626 } 17627 17628 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]); 17629 sqlite3_free(azResult); 17630 }else 17631 17632 /* Begin redirecting output to the file "testcase-out.txt" */ 17633 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){ 17634 output_reset(p); 17635 p->out = output_file_open("testcase-out.txt", 0); 17636 if( p->out==0 ){ 17637 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n"); 17638 } 17639 if( nArg>=2 ){ 17640 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]); 17641 }else{ 17642 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?"); 17643 } 17644 }else 17645 17646 #ifndef SQLITE_UNTESTABLE 17647 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 ){ 17648 static const struct { 17649 const char *zCtrlName; /* Name of a test-control option */ 17650 int ctrlCode; /* Integer code for that option */ 17651 const char *zUsage; /* Usage notes */ 17652 } aCtrl[] = { 17653 { "always", SQLITE_TESTCTRL_ALWAYS, "BOOLEAN" }, 17654 { "assert", SQLITE_TESTCTRL_ASSERT, "BOOLEAN" }, 17655 /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, "" },*/ 17656 /*{ "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST, "" },*/ 17657 { "byteorder", SQLITE_TESTCTRL_BYTEORDER, "" }, 17658 /*{ "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL, "" }, */ 17659 { "imposter", SQLITE_TESTCTRL_IMPOSTER, "SCHEMA ON/OFF ROOTPAGE"}, 17660 { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "BOOLEAN" }, 17661 { "localtime_fault", SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN" }, 17662 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN" }, 17663 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK" }, 17664 #ifdef YYCOVERAGE 17665 { "parser_coverage", SQLITE_TESTCTRL_PARSER_COVERAGE, "" }, 17666 #endif 17667 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE, "OFFSET " }, 17668 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET, "" }, 17669 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE, "" }, 17670 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE, "" }, 17671 { "reserve", SQLITE_TESTCTRL_RESERVE, "BYTES-OF-RESERVE" }, 17672 }; 17673 int testctrl = -1; 17674 int iCtrl = -1; 17675 int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */ 17676 int isOk = 0; 17677 int i, n2; 17678 const char *zCmd = 0; 17679 17680 open_db(p, 0); 17681 zCmd = nArg>=2 ? azArg[1] : "help"; 17682 17683 /* The argument can optionally begin with "-" or "--" */ 17684 if( zCmd[0]=='-' && zCmd[1] ){ 17685 zCmd++; 17686 if( zCmd[0]=='-' && zCmd[1] ) zCmd++; 17687 } 17688 17689 /* --help lists all test-controls */ 17690 if( strcmp(zCmd,"help")==0 ){ 17691 utf8_printf(p->out, "Available test-controls:\n"); 17692 for(i=0; i<ArraySize(aCtrl); i++){ 17693 utf8_printf(p->out, " .testctrl %s %s\n", 17694 aCtrl[i].zCtrlName, aCtrl[i].zUsage); 17695 } 17696 rc = 1; 17697 goto meta_command_exit; 17698 } 17699 17700 /* convert testctrl text option to value. allow any unique prefix 17701 ** of the option name, or a numerical value. */ 17702 n2 = strlen30(zCmd); 17703 for(i=0; i<ArraySize(aCtrl); i++){ 17704 if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){ 17705 if( testctrl<0 ){ 17706 testctrl = aCtrl[i].ctrlCode; 17707 iCtrl = i; 17708 }else{ 17709 utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n" 17710 "Use \".testctrl --help\" for help\n", zCmd); 17711 rc = 1; 17712 goto meta_command_exit; 17713 } 17714 } 17715 } 17716 if( testctrl<0 ){ 17717 utf8_printf(stderr,"Error: unknown test-control: %s\n" 17718 "Use \".testctrl --help\" for help\n", zCmd); 17719 }else{ 17720 switch(testctrl){ 17721 17722 /* sqlite3_test_control(int, db, int) */ 17723 case SQLITE_TESTCTRL_OPTIMIZATIONS: 17724 case SQLITE_TESTCTRL_RESERVE: 17725 if( nArg==3 ){ 17726 int opt = (int)strtol(azArg[2], 0, 0); 17727 rc2 = sqlite3_test_control(testctrl, p->db, opt); 17728 isOk = 3; 17729 } 17730 break; 17731 17732 /* sqlite3_test_control(int) */ 17733 case SQLITE_TESTCTRL_PRNG_SAVE: 17734 case SQLITE_TESTCTRL_PRNG_RESTORE: 17735 case SQLITE_TESTCTRL_PRNG_RESET: 17736 case SQLITE_TESTCTRL_BYTEORDER: 17737 if( nArg==2 ){ 17738 rc2 = sqlite3_test_control(testctrl); 17739 isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3; 17740 } 17741 break; 17742 17743 /* sqlite3_test_control(int, uint) */ 17744 case SQLITE_TESTCTRL_PENDING_BYTE: 17745 if( nArg==3 ){ 17746 unsigned int opt = (unsigned int)integerValue(azArg[2]); 17747 rc2 = sqlite3_test_control(testctrl, opt); 17748 isOk = 3; 17749 } 17750 break; 17751 17752 /* sqlite3_test_control(int, int) */ 17753 case SQLITE_TESTCTRL_ASSERT: 17754 case SQLITE_TESTCTRL_ALWAYS: 17755 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: 17756 if( nArg==3 ){ 17757 int opt = booleanValue(azArg[2]); 17758 rc2 = sqlite3_test_control(testctrl, opt); 17759 isOk = 1; 17760 } 17761 break; 17762 17763 /* sqlite3_test_control(int, int) */ 17764 case SQLITE_TESTCTRL_LOCALTIME_FAULT: 17765 case SQLITE_TESTCTRL_NEVER_CORRUPT: 17766 if( nArg==3 ){ 17767 int opt = booleanValue(azArg[2]); 17768 rc2 = sqlite3_test_control(testctrl, opt); 17769 isOk = 3; 17770 } 17771 break; 17772 17773 case SQLITE_TESTCTRL_IMPOSTER: 17774 if( nArg==5 ){ 17775 rc2 = sqlite3_test_control(testctrl, p->db, 17776 azArg[2], 17777 integerValue(azArg[3]), 17778 integerValue(azArg[4])); 17779 isOk = 3; 17780 } 17781 break; 17782 17783 #ifdef YYCOVERAGE 17784 case SQLITE_TESTCTRL_PARSER_COVERAGE: 17785 if( nArg==2 ){ 17786 sqlite3_test_control(testctrl, p->out); 17787 isOk = 3; 17788 } 17789 #endif 17790 } 17791 } 17792 if( isOk==0 && iCtrl>=0 ){ 17793 utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd, aCtrl[iCtrl].zUsage); 17794 rc = 1; 17795 }else if( isOk==1 ){ 17796 raw_printf(p->out, "%d\n", rc2); 17797 }else if( isOk==2 ){ 17798 raw_printf(p->out, "0x%08x\n", rc2); 17799 } 17800 }else 17801 #endif /* !defined(SQLITE_UNTESTABLE) */ 17802 17803 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){ 17804 open_db(p, 0); 17805 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0); 17806 }else 17807 17808 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){ 17809 if( nArg==2 ){ 17810 enableTimer = booleanValue(azArg[1]); 17811 if( enableTimer && !HAS_TIMER ){ 17812 raw_printf(stderr, "Error: timer not available on this system.\n"); 17813 enableTimer = 0; 17814 } 17815 }else{ 17816 raw_printf(stderr, "Usage: .timer on|off\n"); 17817 rc = 1; 17818 } 17819 }else 17820 17821 #ifndef SQLITE_OMIT_TRACE 17822 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){ 17823 int mType = 0; 17824 int jj; 17825 open_db(p, 0); 17826 for(jj=1; jj<nArg; jj++){ 17827 const char *z = azArg[jj]; 17828 if( z[0]=='-' ){ 17829 if( optionMatch(z, "expanded") ){ 17830 p->eTraceType = SHELL_TRACE_EXPANDED; 17831 } 17832 #ifdef SQLITE_ENABLE_NORMALIZE 17833 else if( optionMatch(z, "normalized") ){ 17834 p->eTraceType = SHELL_TRACE_NORMALIZED; 17835 } 17836 #endif 17837 else if( optionMatch(z, "plain") ){ 17838 p->eTraceType = SHELL_TRACE_PLAIN; 17839 } 17840 else if( optionMatch(z, "profile") ){ 17841 mType |= SQLITE_TRACE_PROFILE; 17842 } 17843 else if( optionMatch(z, "row") ){ 17844 mType |= SQLITE_TRACE_ROW; 17845 } 17846 else if( optionMatch(z, "stmt") ){ 17847 mType |= SQLITE_TRACE_STMT; 17848 } 17849 else if( optionMatch(z, "close") ){ 17850 mType |= SQLITE_TRACE_CLOSE; 17851 } 17852 else { 17853 raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z); 17854 rc = 1; 17855 goto meta_command_exit; 17856 } 17857 }else{ 17858 output_file_close(p->traceOut); 17859 p->traceOut = output_file_open(azArg[1], 0); 17860 } 17861 } 17862 if( p->traceOut==0 ){ 17863 sqlite3_trace_v2(p->db, 0, 0, 0); 17864 }else{ 17865 if( mType==0 ) mType = SQLITE_TRACE_STMT; 17866 sqlite3_trace_v2(p->db, mType, sql_trace_callback, p); 17867 } 17868 }else 17869 #endif /* !defined(SQLITE_OMIT_TRACE) */ 17870 17871 #if SQLITE_USER_AUTHENTICATION 17872 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){ 17873 if( nArg<2 ){ 17874 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n"); 17875 rc = 1; 17876 goto meta_command_exit; 17877 } 17878 open_db(p, 0); 17879 if( strcmp(azArg[1],"login")==0 ){ 17880 if( nArg!=4 ){ 17881 raw_printf(stderr, "Usage: .user login USER PASSWORD\n"); 17882 rc = 1; 17883 goto meta_command_exit; 17884 } 17885 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3], strlen30(azArg[3])); 17886 if( rc ){ 17887 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]); 17888 rc = 1; 17889 } 17890 }else if( strcmp(azArg[1],"add")==0 ){ 17891 if( nArg!=5 ){ 17892 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n"); 17893 rc = 1; 17894 goto meta_command_exit; 17895 } 17896 rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 17897 booleanValue(azArg[4])); 17898 if( rc ){ 17899 raw_printf(stderr, "User-Add failed: %d\n", rc); 17900 rc = 1; 17901 } 17902 }else if( strcmp(azArg[1],"edit")==0 ){ 17903 if( nArg!=5 ){ 17904 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n"); 17905 rc = 1; 17906 goto meta_command_exit; 17907 } 17908 rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 17909 booleanValue(azArg[4])); 17910 if( rc ){ 17911 raw_printf(stderr, "User-Edit failed: %d\n", rc); 17912 rc = 1; 17913 } 17914 }else if( strcmp(azArg[1],"delete")==0 ){ 17915 if( nArg!=3 ){ 17916 raw_printf(stderr, "Usage: .user delete USER\n"); 17917 rc = 1; 17918 goto meta_command_exit; 17919 } 17920 rc = sqlite3_user_delete(p->db, azArg[2]); 17921 if( rc ){ 17922 raw_printf(stderr, "User-Delete failed: %d\n", rc); 17923 rc = 1; 17924 } 17925 }else{ 17926 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n"); 17927 rc = 1; 17928 goto meta_command_exit; 17929 } 17930 }else 17931 #endif /* SQLITE_USER_AUTHENTICATION */ 17932 17933 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){ 17934 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/, 17935 sqlite3_libversion(), sqlite3_sourceid()); 17936 #if SQLITE_HAVE_ZLIB 17937 utf8_printf(p->out, "zlib version %s\n", zlibVersion()); 17938 #endif 17939 #define CTIMEOPT_VAL_(opt) #opt 17940 #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) 17941 #if defined(__clang__) && defined(__clang_major__) 17942 utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "." 17943 CTIMEOPT_VAL(__clang_minor__) "." 17944 CTIMEOPT_VAL(__clang_patchlevel__) "\n"); 17945 #elif defined(_MSC_VER) 17946 utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) "\n"); 17947 #elif defined(__GNUC__) && defined(__VERSION__) 17948 utf8_printf(p->out, "gcc-" __VERSION__ "\n"); 17949 #endif 17950 }else 17951 17952 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){ 17953 const char *zDbName = nArg==2 ? azArg[1] : "main"; 17954 sqlite3_vfs *pVfs = 0; 17955 if( p->db ){ 17956 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs); 17957 if( pVfs ){ 17958 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName); 17959 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 17960 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 17961 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 17962 } 17963 } 17964 }else 17965 17966 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){ 17967 sqlite3_vfs *pVfs; 17968 sqlite3_vfs *pCurrent = 0; 17969 if( p->db ){ 17970 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent); 17971 } 17972 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){ 17973 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName, 17974 pVfs==pCurrent ? " <--- CURRENT" : ""); 17975 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 17976 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 17977 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 17978 if( pVfs->pNext ){ 17979 raw_printf(p->out, "-----------------------------------\n"); 17980 } 17981 } 17982 }else 17983 17984 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){ 17985 const char *zDbName = nArg==2 ? azArg[1] : "main"; 17986 char *zVfsName = 0; 17987 if( p->db ){ 17988 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName); 17989 if( zVfsName ){ 17990 utf8_printf(p->out, "%s\n", zVfsName); 17991 sqlite3_free(zVfsName); 17992 } 17993 } 17994 }else 17995 17996 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 17997 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){ 17998 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff; 17999 }else 18000 #endif 18001 18002 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ 18003 int j; 18004 assert( nArg<=ArraySize(azArg) ); 18005 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){ 18006 p->colWidth[j-1] = (int)integerValue(azArg[j]); 18007 } 18008 }else 18009 18010 { 18011 utf8_printf(stderr, "Error: unknown command or invalid arguments: " 18012 " \"%s\". Enter \".help\" for help\n", azArg[0]); 18013 rc = 1; 18014 } 18015 18016 meta_command_exit: 18017 if( p->outCount ){ 18018 p->outCount--; 18019 if( p->outCount==0 ) output_reset(p); 18020 } 18021 return rc; 18022 } 18023 18024 /* 18025 ** Return TRUE if a semicolon occurs anywhere in the first N characters 18026 ** of string z[]. 18027 */ 18028 static int line_contains_semicolon(const char *z, int N){ 18029 int i; 18030 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; } 18031 return 0; 18032 } 18033 18034 /* 18035 ** Test to see if a line consists entirely of whitespace. 18036 */ 18037 static int _all_whitespace(const char *z){ 18038 for(; *z; z++){ 18039 if( IsSpace(z[0]) ) continue; 18040 if( *z=='/' && z[1]=='*' ){ 18041 z += 2; 18042 while( *z && (*z!='*' || z[1]!='/') ){ z++; } 18043 if( *z==0 ) return 0; 18044 z++; 18045 continue; 18046 } 18047 if( *z=='-' && z[1]=='-' ){ 18048 z += 2; 18049 while( *z && *z!='\n' ){ z++; } 18050 if( *z==0 ) return 1; 18051 continue; 18052 } 18053 return 0; 18054 } 18055 return 1; 18056 } 18057 18058 /* 18059 ** Return TRUE if the line typed in is an SQL command terminator other 18060 ** than a semi-colon. The SQL Server style "go" command is understood 18061 ** as is the Oracle "/". 18062 */ 18063 static int line_is_command_terminator(const char *zLine){ 18064 while( IsSpace(zLine[0]) ){ zLine++; }; 18065 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){ 18066 return 1; /* Oracle */ 18067 } 18068 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' 18069 && _all_whitespace(&zLine[2]) ){ 18070 return 1; /* SQL Server */ 18071 } 18072 return 0; 18073 } 18074 18075 /* 18076 ** We need a default sqlite3_complete() implementation to use in case 18077 ** the shell is compiled with SQLITE_OMIT_COMPLETE. The default assumes 18078 ** any arbitrary text is a complete SQL statement. This is not very 18079 ** user-friendly, but it does seem to work. 18080 */ 18081 #ifdef SQLITE_OMIT_COMPLETE 18082 #define sqlite3_complete(x) 1 18083 #endif 18084 18085 /* 18086 ** Return true if zSql is a complete SQL statement. Return false if it 18087 ** ends in the middle of a string literal or C-style comment. 18088 */ 18089 static int line_is_complete(char *zSql, int nSql){ 18090 int rc; 18091 if( zSql==0 ) return 1; 18092 zSql[nSql] = ';'; 18093 zSql[nSql+1] = 0; 18094 rc = sqlite3_complete(zSql); 18095 zSql[nSql] = 0; 18096 return rc; 18097 } 18098 18099 /* 18100 ** Run a single line of SQL. Return the number of errors. 18101 */ 18102 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){ 18103 int rc; 18104 char *zErrMsg = 0; 18105 18106 open_db(p, 0); 18107 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql); 18108 if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 18109 BEGIN_TIMER; 18110 rc = shell_exec(p, zSql, &zErrMsg); 18111 END_TIMER; 18112 if( rc || zErrMsg ){ 18113 char zPrefix[100]; 18114 if( in!=0 || !stdin_is_interactive ){ 18115 sqlite3_snprintf(sizeof(zPrefix), zPrefix, 18116 "Error: near line %d:", startline); 18117 }else{ 18118 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); 18119 } 18120 if( zErrMsg!=0 ){ 18121 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg); 18122 sqlite3_free(zErrMsg); 18123 zErrMsg = 0; 18124 }else{ 18125 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); 18126 } 18127 return 1; 18128 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){ 18129 raw_printf(p->out, "changes: %3d total_changes: %d\n", 18130 sqlite3_changes(p->db), sqlite3_total_changes(p->db)); 18131 } 18132 return 0; 18133 } 18134 18135 18136 /* 18137 ** Read input from *in and process it. If *in==0 then input 18138 ** is interactive - the user is typing it it. Otherwise, input 18139 ** is coming from a file or device. A prompt is issued and history 18140 ** is saved only if input is interactive. An interrupt signal will 18141 ** cause this routine to exit immediately, unless input is interactive. 18142 ** 18143 ** Return the number of errors. 18144 */ 18145 static int process_input(ShellState *p){ 18146 char *zLine = 0; /* A single input line */ 18147 char *zSql = 0; /* Accumulated SQL text */ 18148 int nLine; /* Length of current line */ 18149 int nSql = 0; /* Bytes of zSql[] used */ 18150 int nAlloc = 0; /* Allocated zSql[] space */ 18151 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */ 18152 int rc; /* Error code */ 18153 int errCnt = 0; /* Number of errors seen */ 18154 int startline = 0; /* Line number for start of current input */ 18155 18156 p->lineno = 0; 18157 while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){ 18158 fflush(p->out); 18159 zLine = one_input_line(p->in, zLine, nSql>0); 18160 if( zLine==0 ){ 18161 /* End of input */ 18162 if( p->in==0 && stdin_is_interactive ) printf("\n"); 18163 break; 18164 } 18165 if( seenInterrupt ){ 18166 if( p->in!=0 ) break; 18167 seenInterrupt = 0; 18168 } 18169 p->lineno++; 18170 if( nSql==0 && _all_whitespace(zLine) ){ 18171 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 18172 continue; 18173 } 18174 if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){ 18175 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 18176 if( zLine[0]=='.' ){ 18177 rc = do_meta_command(zLine, p); 18178 if( rc==2 ){ /* exit requested */ 18179 break; 18180 }else if( rc ){ 18181 errCnt++; 18182 } 18183 } 18184 continue; 18185 } 18186 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){ 18187 memcpy(zLine,";",2); 18188 } 18189 nLine = strlen30(zLine); 18190 if( nSql+nLine+2>=nAlloc ){ 18191 nAlloc = nSql+nLine+100; 18192 zSql = realloc(zSql, nAlloc); 18193 if( zSql==0 ) shell_out_of_memory(); 18194 } 18195 nSqlPrior = nSql; 18196 if( nSql==0 ){ 18197 int i; 18198 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){} 18199 assert( nAlloc>0 && zSql!=0 ); 18200 memcpy(zSql, zLine+i, nLine+1-i); 18201 startline = p->lineno; 18202 nSql = nLine-i; 18203 }else{ 18204 zSql[nSql++] = '\n'; 18205 memcpy(zSql+nSql, zLine, nLine+1); 18206 nSql += nLine; 18207 } 18208 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) 18209 && sqlite3_complete(zSql) ){ 18210 errCnt += runOneSqlLine(p, zSql, p->in, startline); 18211 nSql = 0; 18212 if( p->outCount ){ 18213 output_reset(p); 18214 p->outCount = 0; 18215 }else{ 18216 clearTempFile(p); 18217 } 18218 }else if( nSql && _all_whitespace(zSql) ){ 18219 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql); 18220 nSql = 0; 18221 } 18222 } 18223 if( nSql && !_all_whitespace(zSql) ){ 18224 errCnt += runOneSqlLine(p, zSql, p->in, startline); 18225 } 18226 free(zSql); 18227 free(zLine); 18228 return errCnt>0; 18229 } 18230 18231 /* 18232 ** Return a pathname which is the user's home directory. A 18233 ** 0 return indicates an error of some kind. 18234 */ 18235 static char *find_home_dir(int clearFlag){ 18236 static char *home_dir = NULL; 18237 if( clearFlag ){ 18238 free(home_dir); 18239 home_dir = 0; 18240 return 0; 18241 } 18242 if( home_dir ) return home_dir; 18243 18244 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \ 18245 && !defined(__RTP__) && !defined(_WRS_KERNEL) 18246 { 18247 struct passwd *pwent; 18248 uid_t uid = getuid(); 18249 if( (pwent=getpwuid(uid)) != NULL) { 18250 home_dir = pwent->pw_dir; 18251 } 18252 } 18253 #endif 18254 18255 #if defined(_WIN32_WCE) 18256 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() 18257 */ 18258 home_dir = "/"; 18259 #else 18260 18261 #if defined(_WIN32) || defined(WIN32) 18262 if (!home_dir) { 18263 home_dir = getenv("USERPROFILE"); 18264 } 18265 #endif 18266 18267 if (!home_dir) { 18268 home_dir = getenv("HOME"); 18269 } 18270 18271 #if defined(_WIN32) || defined(WIN32) 18272 if (!home_dir) { 18273 char *zDrive, *zPath; 18274 int n; 18275 zDrive = getenv("HOMEDRIVE"); 18276 zPath = getenv("HOMEPATH"); 18277 if( zDrive && zPath ){ 18278 n = strlen30(zDrive) + strlen30(zPath) + 1; 18279 home_dir = malloc( n ); 18280 if( home_dir==0 ) return 0; 18281 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); 18282 return home_dir; 18283 } 18284 home_dir = "c:\\"; 18285 } 18286 #endif 18287 18288 #endif /* !_WIN32_WCE */ 18289 18290 if( home_dir ){ 18291 int n = strlen30(home_dir) + 1; 18292 char *z = malloc( n ); 18293 if( z ) memcpy(z, home_dir, n); 18294 home_dir = z; 18295 } 18296 18297 return home_dir; 18298 } 18299 18300 /* 18301 ** Read input from the file given by sqliterc_override. Or if that 18302 ** parameter is NULL, take input from ~/.sqliterc 18303 ** 18304 ** Returns the number of errors. 18305 */ 18306 static void process_sqliterc( 18307 ShellState *p, /* Configuration data */ 18308 const char *sqliterc_override /* Name of config file. NULL to use default */ 18309 ){ 18310 char *home_dir = NULL; 18311 const char *sqliterc = sqliterc_override; 18312 char *zBuf = 0; 18313 FILE *inSaved = p->in; 18314 int savedLineno = p->lineno; 18315 18316 if (sqliterc == NULL) { 18317 home_dir = find_home_dir(0); 18318 if( home_dir==0 ){ 18319 raw_printf(stderr, "-- warning: cannot find home directory;" 18320 " cannot read ~/.sqliterc\n"); 18321 return; 18322 } 18323 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir); 18324 sqliterc = zBuf; 18325 } 18326 p->in = fopen(sqliterc,"rb"); 18327 if( p->in ){ 18328 if( stdin_is_interactive ){ 18329 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc); 18330 } 18331 process_input(p); 18332 fclose(p->in); 18333 } 18334 p->in = inSaved; 18335 p->lineno = savedLineno; 18336 sqlite3_free(zBuf); 18337 } 18338 18339 /* 18340 ** Show available command line options 18341 */ 18342 static const char zOptions[] = 18343 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 18344 " -A ARGS... run \".archive ARGS\" and exit\n" 18345 #endif 18346 " -append append the database to the end of the file\n" 18347 " -ascii set output mode to 'ascii'\n" 18348 " -bail stop after hitting an error\n" 18349 " -batch force batch I/O\n" 18350 " -column set output mode to 'column'\n" 18351 " -cmd COMMAND run \"COMMAND\" before reading stdin\n" 18352 " -csv set output mode to 'csv'\n" 18353 #if defined(SQLITE_ENABLE_DESERIALIZE) 18354 " -deserialize open the database using sqlite3_deserialize()\n" 18355 #endif 18356 " -echo print commands before execution\n" 18357 " -init FILENAME read/process named file\n" 18358 " -[no]header turn headers on or off\n" 18359 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 18360 " -heap SIZE Size of heap for memsys3 or memsys5\n" 18361 #endif 18362 " -help show this message\n" 18363 " -html set output mode to HTML\n" 18364 " -interactive force interactive I/O\n" 18365 " -line set output mode to 'line'\n" 18366 " -list set output mode to 'list'\n" 18367 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n" 18368 #if defined(SQLITE_ENABLE_DESERIALIZE) 18369 " -maxsize N maximum size for a --deserialize database\n" 18370 #endif 18371 " -memtrace trace all memory allocations and deallocations\n" 18372 " -mmap N default mmap size set to N\n" 18373 #ifdef SQLITE_ENABLE_MULTIPLEX 18374 " -multiplex enable the multiplexor VFS\n" 18375 #endif 18376 " -newline SEP set output row separator. Default: '\\n'\n" 18377 " -nullvalue TEXT set text string for NULL values. Default ''\n" 18378 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n" 18379 " -quote set output mode to 'quote'\n" 18380 " -readonly open the database read-only\n" 18381 " -separator SEP set output column separator. Default: '|'\n" 18382 #ifdef SQLITE_ENABLE_SORTER_REFERENCES 18383 " -sorterref SIZE sorter references threshold size\n" 18384 #endif 18385 " -stats print memory stats before each finalize\n" 18386 " -version show SQLite version\n" 18387 " -vfs NAME use NAME as the default VFS\n" 18388 #ifdef SQLITE_ENABLE_VFSTRACE 18389 " -vfstrace enable tracing of all VFS calls\n" 18390 #endif 18391 #ifdef SQLITE_HAVE_ZLIB 18392 " -zip open the file as a ZIP Archive\n" 18393 #endif 18394 ; 18395 static void usage(int showDetail){ 18396 utf8_printf(stderr, 18397 "Usage: %s [OPTIONS] FILENAME [SQL]\n" 18398 "FILENAME is the name of an SQLite database. A new database is created\n" 18399 "if the file does not previously exist.\n", Argv0); 18400 if( showDetail ){ 18401 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions); 18402 }else{ 18403 raw_printf(stderr, "Use the -help option for additional information\n"); 18404 } 18405 exit(1); 18406 } 18407 18408 /* 18409 ** Internal check: Verify that the SQLite is uninitialized. Print a 18410 ** error message if it is initialized. 18411 */ 18412 static void verify_uninitialized(void){ 18413 if( sqlite3_config(-1)==SQLITE_MISUSE ){ 18414 utf8_printf(stdout, "WARNING: attempt to configure SQLite after" 18415 " initialization.\n"); 18416 } 18417 } 18418 18419 /* 18420 ** Initialize the state information in data 18421 */ 18422 static void main_init(ShellState *data) { 18423 memset(data, 0, sizeof(*data)); 18424 data->normalMode = data->cMode = data->mode = MODE_List; 18425 data->autoExplain = 1; 18426 memcpy(data->colSeparator,SEP_Column, 2); 18427 memcpy(data->rowSeparator,SEP_Row, 2); 18428 data->showHeader = 0; 18429 data->shellFlgs = SHFLG_Lookaside; 18430 verify_uninitialized(); 18431 sqlite3_config(SQLITE_CONFIG_URI, 1); 18432 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); 18433 sqlite3_config(SQLITE_CONFIG_MULTITHREAD); 18434 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); 18435 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); 18436 } 18437 18438 /* 18439 ** Output text to the console in a font that attracts extra attention. 18440 */ 18441 #ifdef _WIN32 18442 static void printBold(const char *zText){ 18443 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); 18444 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo; 18445 GetConsoleScreenBufferInfo(out, &defaultScreenInfo); 18446 SetConsoleTextAttribute(out, 18447 FOREGROUND_RED|FOREGROUND_INTENSITY 18448 ); 18449 printf("%s", zText); 18450 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes); 18451 } 18452 #else 18453 static void printBold(const char *zText){ 18454 printf("\033[1m%s\033[0m", zText); 18455 } 18456 #endif 18457 18458 /* 18459 ** Get the argument to an --option. Throw an error and die if no argument 18460 ** is available. 18461 */ 18462 static char *cmdline_option_value(int argc, char **argv, int i){ 18463 if( i==argc ){ 18464 utf8_printf(stderr, "%s: Error: missing argument to %s\n", 18465 argv[0], argv[argc-1]); 18466 exit(1); 18467 } 18468 return argv[i]; 18469 } 18470 18471 #ifndef SQLITE_SHELL_IS_UTF8 18472 # if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER) 18473 # define SQLITE_SHELL_IS_UTF8 (0) 18474 # else 18475 # define SQLITE_SHELL_IS_UTF8 (1) 18476 # endif 18477 #endif 18478 18479 #if SQLITE_SHELL_IS_UTF8 18480 int SQLITE_CDECL main(int argc, char **argv){ 18481 #else 18482 int SQLITE_CDECL wmain(int argc, wchar_t **wargv){ 18483 char **argv; 18484 #endif 18485 char *zErrMsg = 0; 18486 ShellState data; 18487 const char *zInitFile = 0; 18488 int i; 18489 int rc = 0; 18490 int warnInmemoryDb = 0; 18491 int readStdin = 1; 18492 int nCmd = 0; 18493 char **azCmd = 0; 18494 const char *zVfs = 0; /* Value of -vfs command-line option */ 18495 #if !SQLITE_SHELL_IS_UTF8 18496 char **argvToFree = 0; 18497 int argcToFree = 0; 18498 #endif 18499 18500 setBinaryMode(stdin, 0); 18501 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */ 18502 stdin_is_interactive = isatty(0); 18503 stdout_is_console = isatty(1); 18504 18505 #if !defined(_WIN32_WCE) 18506 if( getenv("SQLITE_DEBUG_BREAK") ){ 18507 if( isatty(0) && isatty(2) ){ 18508 fprintf(stderr, 18509 "attach debugger to process %d and press any key to continue.\n", 18510 GETPID()); 18511 fgetc(stdin); 18512 }else{ 18513 #if defined(_WIN32) || defined(WIN32) 18514 DebugBreak(); 18515 #elif defined(SIGTRAP) 18516 raise(SIGTRAP); 18517 #endif 18518 } 18519 } 18520 #endif 18521 18522 #if USE_SYSTEM_SQLITE+0!=1 18523 if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){ 18524 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n", 18525 sqlite3_sourceid(), SQLITE_SOURCE_ID); 18526 exit(1); 18527 } 18528 #endif 18529 main_init(&data); 18530 18531 /* On Windows, we must translate command-line arguments into UTF-8. 18532 ** The SQLite memory allocator subsystem has to be enabled in order to 18533 ** do this. But we want to run an sqlite3_shutdown() afterwards so that 18534 ** subsequent sqlite3_config() calls will work. So copy all results into 18535 ** memory that does not come from the SQLite memory allocator. 18536 */ 18537 #if !SQLITE_SHELL_IS_UTF8 18538 sqlite3_initialize(); 18539 argvToFree = malloc(sizeof(argv[0])*argc*2); 18540 argcToFree = argc; 18541 argv = argvToFree + argc; 18542 if( argv==0 ) shell_out_of_memory(); 18543 for(i=0; i<argc; i++){ 18544 char *z = sqlite3_win32_unicode_to_utf8(wargv[i]); 18545 int n; 18546 if( z==0 ) shell_out_of_memory(); 18547 n = (int)strlen(z); 18548 argv[i] = malloc( n+1 ); 18549 if( argv[i]==0 ) shell_out_of_memory(); 18550 memcpy(argv[i], z, n+1); 18551 argvToFree[i] = argv[i]; 18552 sqlite3_free(z); 18553 } 18554 sqlite3_shutdown(); 18555 #endif 18556 18557 assert( argc>=1 && argv && argv[0] ); 18558 Argv0 = argv[0]; 18559 18560 /* Make sure we have a valid signal handler early, before anything 18561 ** else is done. 18562 */ 18563 #ifdef SIGINT 18564 signal(SIGINT, interrupt_handler); 18565 #elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 18566 SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE); 18567 #endif 18568 18569 #ifdef SQLITE_SHELL_DBNAME_PROC 18570 { 18571 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name 18572 ** of a C-function that will provide the name of the database file. Use 18573 ** this compile-time option to embed this shell program in larger 18574 ** applications. */ 18575 extern void SQLITE_SHELL_DBNAME_PROC(const char**); 18576 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename); 18577 warnInmemoryDb = 0; 18578 } 18579 #endif 18580 18581 /* Do an initial pass through the command-line argument to locate 18582 ** the name of the database file, the name of the initialization file, 18583 ** the size of the alternative malloc heap, 18584 ** and the first command to execute. 18585 */ 18586 verify_uninitialized(); 18587 for(i=1; i<argc; i++){ 18588 char *z; 18589 z = argv[i]; 18590 if( z[0]!='-' ){ 18591 if( data.zDbFilename==0 ){ 18592 data.zDbFilename = z; 18593 }else{ 18594 /* Excesss arguments are interpreted as SQL (or dot-commands) and 18595 ** mean that nothing is read from stdin */ 18596 readStdin = 0; 18597 nCmd++; 18598 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd); 18599 if( azCmd==0 ) shell_out_of_memory(); 18600 azCmd[nCmd-1] = z; 18601 } 18602 } 18603 if( z[1]=='-' ) z++; 18604 if( strcmp(z,"-separator")==0 18605 || strcmp(z,"-nullvalue")==0 18606 || strcmp(z,"-newline")==0 18607 || strcmp(z,"-cmd")==0 18608 ){ 18609 (void)cmdline_option_value(argc, argv, ++i); 18610 }else if( strcmp(z,"-init")==0 ){ 18611 zInitFile = cmdline_option_value(argc, argv, ++i); 18612 }else if( strcmp(z,"-batch")==0 ){ 18613 /* Need to check for batch mode here to so we can avoid printing 18614 ** informational messages (like from process_sqliterc) before 18615 ** we do the actual processing of arguments later in a second pass. 18616 */ 18617 stdin_is_interactive = 0; 18618 }else if( strcmp(z,"-heap")==0 ){ 18619 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 18620 const char *zSize; 18621 sqlite3_int64 szHeap; 18622 18623 zSize = cmdline_option_value(argc, argv, ++i); 18624 szHeap = integerValue(zSize); 18625 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000; 18626 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64); 18627 #else 18628 (void)cmdline_option_value(argc, argv, ++i); 18629 #endif 18630 }else if( strcmp(z,"-pagecache")==0 ){ 18631 int n, sz; 18632 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 18633 if( sz>70000 ) sz = 70000; 18634 if( sz<0 ) sz = 0; 18635 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 18636 sqlite3_config(SQLITE_CONFIG_PAGECACHE, 18637 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n); 18638 data.shellFlgs |= SHFLG_Pagecache; 18639 }else if( strcmp(z,"-lookaside")==0 ){ 18640 int n, sz; 18641 sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 18642 if( sz<0 ) sz = 0; 18643 n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 18644 if( n<0 ) n = 0; 18645 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n); 18646 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside; 18647 #ifdef SQLITE_ENABLE_VFSTRACE 18648 }else if( strcmp(z,"-vfstrace")==0 ){ 18649 extern int vfstrace_register( 18650 const char *zTraceName, 18651 const char *zOldVfsName, 18652 int (*xOut)(const char*,void*), 18653 void *pOutArg, 18654 int makeDefault 18655 ); 18656 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1); 18657 #endif 18658 #ifdef SQLITE_ENABLE_MULTIPLEX 18659 }else if( strcmp(z,"-multiplex")==0 ){ 18660 extern int sqlite3_multiple_initialize(const char*,int); 18661 sqlite3_multiplex_initialize(0, 1); 18662 #endif 18663 }else if( strcmp(z,"-mmap")==0 ){ 18664 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 18665 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz); 18666 #ifdef SQLITE_ENABLE_SORTER_REFERENCES 18667 }else if( strcmp(z,"-sorterref")==0 ){ 18668 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 18669 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz); 18670 #endif 18671 }else if( strcmp(z,"-vfs")==0 ){ 18672 zVfs = cmdline_option_value(argc, argv, ++i); 18673 #ifdef SQLITE_HAVE_ZLIB 18674 }else if( strcmp(z,"-zip")==0 ){ 18675 data.openMode = SHELL_OPEN_ZIPFILE; 18676 #endif 18677 }else if( strcmp(z,"-append")==0 ){ 18678 data.openMode = SHELL_OPEN_APPENDVFS; 18679 #ifdef SQLITE_ENABLE_DESERIALIZE 18680 }else if( strcmp(z,"-deserialize")==0 ){ 18681 data.openMode = SHELL_OPEN_DESERIALIZE; 18682 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 18683 data.szMax = integerValue(argv[++i]); 18684 #endif 18685 }else if( strcmp(z,"-readonly")==0 ){ 18686 data.openMode = SHELL_OPEN_READONLY; 18687 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 18688 }else if( strncmp(z, "-A",2)==0 ){ 18689 /* All remaining command-line arguments are passed to the ".archive" 18690 ** command, so ignore them */ 18691 break; 18692 #endif 18693 }else if( strcmp(z, "-memtrace")==0 ){ 18694 sqlite3MemTraceActivate(stderr); 18695 } 18696 } 18697 verify_uninitialized(); 18698 18699 18700 #ifdef SQLITE_SHELL_INIT_PROC 18701 { 18702 /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name 18703 ** of a C-function that will perform initialization actions on SQLite that 18704 ** occur just before or after sqlite3_initialize(). Use this compile-time 18705 ** option to embed this shell program in larger applications. */ 18706 extern void SQLITE_SHELL_INIT_PROC(void); 18707 SQLITE_SHELL_INIT_PROC(); 18708 } 18709 #else 18710 /* All the sqlite3_config() calls have now been made. So it is safe 18711 ** to call sqlite3_initialize() and process any command line -vfs option. */ 18712 sqlite3_initialize(); 18713 #endif 18714 18715 if( zVfs ){ 18716 sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs); 18717 if( pVfs ){ 18718 sqlite3_vfs_register(pVfs, 1); 18719 }else{ 18720 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]); 18721 exit(1); 18722 } 18723 } 18724 18725 if( data.zDbFilename==0 ){ 18726 #ifndef SQLITE_OMIT_MEMORYDB 18727 data.zDbFilename = ":memory:"; 18728 warnInmemoryDb = argc==1; 18729 #else 18730 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0); 18731 return 1; 18732 #endif 18733 } 18734 data.out = stdout; 18735 sqlite3_appendvfs_init(0,0,0); 18736 18737 /* Go ahead and open the database file if it already exists. If the 18738 ** file does not exist, delay opening it. This prevents empty database 18739 ** files from being created if a user mistypes the database name argument 18740 ** to the sqlite command-line tool. 18741 */ 18742 if( access(data.zDbFilename, 0)==0 ){ 18743 open_db(&data, 0); 18744 } 18745 18746 /* Process the initialization file if there is one. If no -init option 18747 ** is given on the command line, look for a file named ~/.sqliterc and 18748 ** try to process it. 18749 */ 18750 process_sqliterc(&data,zInitFile); 18751 18752 /* Make a second pass through the command-line argument and set 18753 ** options. This second pass is delayed until after the initialization 18754 ** file is processed so that the command-line arguments will override 18755 ** settings in the initialization file. 18756 */ 18757 for(i=1; i<argc; i++){ 18758 char *z = argv[i]; 18759 if( z[0]!='-' ) continue; 18760 if( z[1]=='-' ){ z++; } 18761 if( strcmp(z,"-init")==0 ){ 18762 i++; 18763 }else if( strcmp(z,"-html")==0 ){ 18764 data.mode = MODE_Html; 18765 }else if( strcmp(z,"-list")==0 ){ 18766 data.mode = MODE_List; 18767 }else if( strcmp(z,"-quote")==0 ){ 18768 data.mode = MODE_Quote; 18769 }else if( strcmp(z,"-line")==0 ){ 18770 data.mode = MODE_Line; 18771 }else if( strcmp(z,"-column")==0 ){ 18772 data.mode = MODE_Column; 18773 }else if( strcmp(z,"-csv")==0 ){ 18774 data.mode = MODE_Csv; 18775 memcpy(data.colSeparator,",",2); 18776 #ifdef SQLITE_HAVE_ZLIB 18777 }else if( strcmp(z,"-zip")==0 ){ 18778 data.openMode = SHELL_OPEN_ZIPFILE; 18779 #endif 18780 }else if( strcmp(z,"-append")==0 ){ 18781 data.openMode = SHELL_OPEN_APPENDVFS; 18782 #ifdef SQLITE_ENABLE_DESERIALIZE 18783 }else if( strcmp(z,"-deserialize")==0 ){ 18784 data.openMode = SHELL_OPEN_DESERIALIZE; 18785 }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 18786 data.szMax = integerValue(argv[++i]); 18787 #endif 18788 }else if( strcmp(z,"-readonly")==0 ){ 18789 data.openMode = SHELL_OPEN_READONLY; 18790 }else if( strcmp(z,"-ascii")==0 ){ 18791 data.mode = MODE_Ascii; 18792 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 18793 SEP_Unit); 18794 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 18795 SEP_Record); 18796 }else if( strcmp(z,"-separator")==0 ){ 18797 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 18798 "%s",cmdline_option_value(argc,argv,++i)); 18799 }else if( strcmp(z,"-newline")==0 ){ 18800 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 18801 "%s",cmdline_option_value(argc,argv,++i)); 18802 }else if( strcmp(z,"-nullvalue")==0 ){ 18803 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue, 18804 "%s",cmdline_option_value(argc,argv,++i)); 18805 }else if( strcmp(z,"-header")==0 ){ 18806 data.showHeader = 1; 18807 }else if( strcmp(z,"-noheader")==0 ){ 18808 data.showHeader = 0; 18809 }else if( strcmp(z,"-echo")==0 ){ 18810 ShellSetFlag(&data, SHFLG_Echo); 18811 }else if( strcmp(z,"-eqp")==0 ){ 18812 data.autoEQP = AUTOEQP_on; 18813 }else if( strcmp(z,"-eqpfull")==0 ){ 18814 data.autoEQP = AUTOEQP_full; 18815 }else if( strcmp(z,"-stats")==0 ){ 18816 data.statsOn = 1; 18817 }else if( strcmp(z,"-scanstats")==0 ){ 18818 data.scanstatsOn = 1; 18819 }else if( strcmp(z,"-backslash")==0 ){ 18820 /* Undocumented command-line option: -backslash 18821 ** Causes C-style backslash escapes to be evaluated in SQL statements 18822 ** prior to sending the SQL into SQLite. Useful for injecting 18823 ** crazy bytes in the middle of SQL statements for testing and debugging. 18824 */ 18825 ShellSetFlag(&data, SHFLG_Backslash); 18826 }else if( strcmp(z,"-bail")==0 ){ 18827 bail_on_error = 1; 18828 }else if( strcmp(z,"-version")==0 ){ 18829 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid()); 18830 return 0; 18831 }else if( strcmp(z,"-interactive")==0 ){ 18832 stdin_is_interactive = 1; 18833 }else if( strcmp(z,"-batch")==0 ){ 18834 stdin_is_interactive = 0; 18835 }else if( strcmp(z,"-heap")==0 ){ 18836 i++; 18837 }else if( strcmp(z,"-pagecache")==0 ){ 18838 i+=2; 18839 }else if( strcmp(z,"-lookaside")==0 ){ 18840 i+=2; 18841 }else if( strcmp(z,"-mmap")==0 ){ 18842 i++; 18843 }else if( strcmp(z,"-memtrace")==0 ){ 18844 i++; 18845 #ifdef SQLITE_ENABLE_SORTER_REFERENCES 18846 }else if( strcmp(z,"-sorterref")==0 ){ 18847 i++; 18848 #endif 18849 }else if( strcmp(z,"-vfs")==0 ){ 18850 i++; 18851 #ifdef SQLITE_ENABLE_VFSTRACE 18852 }else if( strcmp(z,"-vfstrace")==0 ){ 18853 i++; 18854 #endif 18855 #ifdef SQLITE_ENABLE_MULTIPLEX 18856 }else if( strcmp(z,"-multiplex")==0 ){ 18857 i++; 18858 #endif 18859 }else if( strcmp(z,"-help")==0 ){ 18860 usage(1); 18861 }else if( strcmp(z,"-cmd")==0 ){ 18862 /* Run commands that follow -cmd first and separately from commands 18863 ** that simply appear on the command-line. This seems goofy. It would 18864 ** be better if all commands ran in the order that they appear. But 18865 ** we retain the goofy behavior for historical compatibility. */ 18866 if( i==argc-1 ) break; 18867 z = cmdline_option_value(argc,argv,++i); 18868 if( z[0]=='.' ){ 18869 rc = do_meta_command(z, &data); 18870 if( rc && bail_on_error ) return rc==2 ? 0 : rc; 18871 }else{ 18872 open_db(&data, 0); 18873 rc = shell_exec(&data, z, &zErrMsg); 18874 if( zErrMsg!=0 ){ 18875 utf8_printf(stderr,"Error: %s\n", zErrMsg); 18876 if( bail_on_error ) return rc!=0 ? rc : 1; 18877 }else if( rc!=0 ){ 18878 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z); 18879 if( bail_on_error ) return rc; 18880 } 18881 } 18882 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 18883 }else if( strncmp(z, "-A", 2)==0 ){ 18884 if( nCmd>0 ){ 18885 utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands" 18886 " with \"%s\"\n", z); 18887 return 1; 18888 } 18889 open_db(&data, OPEN_DB_ZIPFILE); 18890 if( z[2] ){ 18891 argv[i] = &z[2]; 18892 arDotCommand(&data, 1, argv+(i-1), argc-(i-1)); 18893 }else{ 18894 arDotCommand(&data, 1, argv+i, argc-i); 18895 } 18896 readStdin = 0; 18897 break; 18898 #endif 18899 }else{ 18900 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z); 18901 raw_printf(stderr,"Use -help for a list of options.\n"); 18902 return 1; 18903 } 18904 data.cMode = data.mode; 18905 } 18906 18907 if( !readStdin ){ 18908 /* Run all arguments that do not begin with '-' as if they were separate 18909 ** command-line inputs, except for the argToSkip argument which contains 18910 ** the database filename. 18911 */ 18912 for(i=0; i<nCmd; i++){ 18913 if( azCmd[i][0]=='.' ){ 18914 rc = do_meta_command(azCmd[i], &data); 18915 if( rc ) return rc==2 ? 0 : rc; 18916 }else{ 18917 open_db(&data, 0); 18918 rc = shell_exec(&data, azCmd[i], &zErrMsg); 18919 if( zErrMsg!=0 ){ 18920 utf8_printf(stderr,"Error: %s\n", zErrMsg); 18921 return rc!=0 ? rc : 1; 18922 }else if( rc!=0 ){ 18923 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]); 18924 return rc; 18925 } 18926 } 18927 } 18928 free(azCmd); 18929 }else{ 18930 /* Run commands received from standard input 18931 */ 18932 if( stdin_is_interactive ){ 18933 char *zHome; 18934 char *zHistory; 18935 int nHistory; 18936 printf( 18937 "SQLite version %s %.19s\n" /*extra-version-info*/ 18938 "Enter \".help\" for usage hints.\n", 18939 sqlite3_libversion(), sqlite3_sourceid() 18940 ); 18941 if( warnInmemoryDb ){ 18942 printf("Connected to a "); 18943 printBold("transient in-memory database"); 18944 printf(".\nUse \".open FILENAME\" to reopen on a " 18945 "persistent database.\n"); 18946 } 18947 zHistory = getenv("SQLITE_HISTORY"); 18948 if( zHistory ){ 18949 zHistory = strdup(zHistory); 18950 }else if( (zHome = find_home_dir(0))!=0 ){ 18951 nHistory = strlen30(zHome) + 20; 18952 if( (zHistory = malloc(nHistory))!=0 ){ 18953 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome); 18954 } 18955 } 18956 if( zHistory ){ shell_read_history(zHistory); } 18957 #if HAVE_READLINE || HAVE_EDITLINE 18958 rl_attempted_completion_function = readline_completion; 18959 #elif HAVE_LINENOISE 18960 linenoiseSetCompletionCallback(linenoise_completion); 18961 #endif 18962 data.in = 0; 18963 rc = process_input(&data); 18964 if( zHistory ){ 18965 shell_stifle_history(2000); 18966 shell_write_history(zHistory); 18967 free(zHistory); 18968 } 18969 }else{ 18970 data.in = stdin; 18971 rc = process_input(&data); 18972 } 18973 } 18974 set_table_name(&data, 0); 18975 if( data.db ){ 18976 session_close_all(&data); 18977 close_db(data.db); 18978 } 18979 sqlite3_free(data.zFreeOnClose); 18980 find_home_dir(1); 18981 output_reset(&data); 18982 data.doXdgOpen = 0; 18983 clearTempFile(&data); 18984 #if !SQLITE_SHELL_IS_UTF8 18985 for(i=0; i<argcToFree; i++) free(argvToFree[i]); 18986 free(argvToFree); 18987 #endif 18988 /* Clear the global data structure so that valgrind will detect memory 18989 ** leaks */ 18990 memset(&data, 0, sizeof(data)); 18991 return rc; 18992 } 18993