Return to shell.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / elwix / files / sqlite / dist |
1.5 misho 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: */ 1.2 misho 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: /* 1.5 misho 39: ** Determine if we are dealing with WinRT, which provides only a subset of 40: ** the full Win32 API. 1.4 misho 41: */ 1.5 misho 42: #if !defined(SQLITE_OS_WINRT) 43: # define SQLITE_OS_WINRT 0 1.4 misho 44: #endif 45: 46: /* 1.5 misho 47: ** Warning pragmas copied from msvc.h in the core. 48: */ 49: #if defined(_MSC_VER) 50: #pragma warning(disable : 4054) 51: #pragma warning(disable : 4055) 52: #pragma warning(disable : 4100) 53: #pragma warning(disable : 4127) 54: #pragma warning(disable : 4130) 55: #pragma warning(disable : 4152) 56: #pragma warning(disable : 4189) 57: #pragma warning(disable : 4206) 58: #pragma warning(disable : 4210) 59: #pragma warning(disable : 4232) 60: #pragma warning(disable : 4244) 61: #pragma warning(disable : 4305) 62: #pragma warning(disable : 4306) 63: #pragma warning(disable : 4702) 64: #pragma warning(disable : 4706) 65: #endif /* defined(_MSC_VER) */ 66: 67: /* 1.4 misho 68: ** No support for loadable extensions in VxWorks. 69: */ 70: #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION 71: # define SQLITE_OMIT_LOAD_EXTENSION 1 72: #endif 73: 74: /* 1.2 misho 75: ** Enable large-file support for fopen() and friends on unix. 76: */ 77: #ifndef SQLITE_DISABLE_LFS 78: # define _LARGE_FILE 1 79: # ifndef _FILE_OFFSET_BITS 80: # define _FILE_OFFSET_BITS 64 81: # endif 82: # define _LARGEFILE_SOURCE 1 83: #endif 84: 85: #include <stdlib.h> 86: #include <string.h> 87: #include <stdio.h> 88: #include <assert.h> 89: #include "sqlite3.h" 1.5 misho 90: typedef sqlite3_int64 i64; 91: typedef sqlite3_uint64 u64; 92: typedef unsigned char u8; 1.4 misho 93: #if SQLITE_USER_AUTHENTICATION 94: # include "sqlite3userauth.h" 95: #endif 1.2 misho 96: #include <ctype.h> 97: #include <stdarg.h> 98: 1.3 misho 99: #if !defined(_WIN32) && !defined(WIN32) 1.2 misho 100: # include <signal.h> 101: # if !defined(__RTP__) && !defined(_WRS_KERNEL) 102: # include <pwd.h> 103: # endif 1.5 misho 104: #endif 105: #if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__) 1.2 misho 106: # include <unistd.h> 1.5 misho 107: # include <dirent.h> 108: # define GETPID getpid 109: # if defined(__MINGW32__) 110: # define DIRENT dirent 111: # ifndef S_ISLNK 112: # define S_ISLNK(mode) (0) 113: # endif 114: # endif 115: #else 116: # define GETPID (int)GetCurrentProcessId 1.2 misho 117: #endif 1.5 misho 118: #include <sys/types.h> 119: #include <sys/stat.h> 1.2 misho 120: 1.4 misho 121: #if HAVE_READLINE 1.2 misho 122: # include <readline/readline.h> 123: # include <readline/history.h> 124: #endif 1.4 misho 125: 126: #if HAVE_EDITLINE 127: # include <editline/readline.h> 128: #endif 129: 130: #if HAVE_EDITLINE || HAVE_READLINE 131: 132: # define shell_add_history(X) add_history(X) 133: # define shell_read_history(X) read_history(X) 134: # define shell_write_history(X) write_history(X) 135: # define shell_stifle_history(X) stifle_history(X) 136: # define shell_readline(X) readline(X) 137: 138: #elif HAVE_LINENOISE 139: 140: # include "linenoise.h" 141: # define shell_add_history(X) linenoiseHistoryAdd(X) 142: # define shell_read_history(X) linenoiseHistoryLoad(X) 143: # define shell_write_history(X) linenoiseHistorySave(X) 144: # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X) 145: # define shell_readline(X) linenoise(X) 146: 147: #else 148: 149: # define shell_read_history(X) 150: # define shell_write_history(X) 151: # define shell_stifle_history(X) 152: 153: # define SHELL_USE_LOCAL_GETLINE 1 1.2 misho 154: #endif 155: 1.4 misho 156: 1.2 misho 157: #if defined(_WIN32) || defined(WIN32) 1.5 misho 158: # if SQLITE_OS_WINRT 159: # define SQLITE_OMIT_POPEN 1 160: # else 161: # include <io.h> 162: # include <fcntl.h> 163: # define isatty(h) _isatty(h) 164: # ifndef access 165: # define access(f,m) _access((f),(m)) 166: # endif 167: # ifndef unlink 168: # define unlink _unlink 169: # endif 170: # ifndef strdup 171: # define strdup _strdup 172: # endif 173: # undef popen 174: # define popen _popen 175: # undef pclose 176: # define pclose _pclose 1.4 misho 177: # endif 1.2 misho 178: #else 1.4 misho 179: /* Make sure isatty() has a prototype. */ 180: extern int isatty(int); 181: 182: # if !defined(__RTP__) && !defined(_WRS_KERNEL) 183: /* popen and pclose are not C89 functions and so are 184: ** sometimes omitted from the <stdio.h> header */ 185: extern FILE *popen(const char*,const char*); 186: extern int pclose(FILE*); 187: # else 188: # define SQLITE_OMIT_POPEN 1 189: # endif 1.2 misho 190: #endif 191: 192: #if defined(_WIN32_WCE) 193: /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() 194: * thus we always assume that we have a console. That can be 195: * overridden with the -batch command line option. 196: */ 197: #define isatty(x) 1 198: #endif 199: 200: /* ctype macros that work with signed characters */ 201: #define IsSpace(X) isspace((unsigned char)X) 202: #define IsDigit(X) isdigit((unsigned char)X) 203: #define ToLower(X) (char)tolower((unsigned char)X) 204: 1.4 misho 205: #if defined(_WIN32) || defined(WIN32) 1.5 misho 206: #if SQLITE_OS_WINRT 207: #include <intrin.h> 208: #endif 1.4 misho 209: #include <windows.h> 210: 211: /* string conversion routines only needed on Win32 */ 212: extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR); 213: extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int); 214: extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int); 1.5 misho 215: extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText); 1.4 misho 216: #endif 217: 218: /* On Windows, we normally run with output mode of TEXT so that \n characters 219: ** are automatically translated into \r\n. However, this behavior needs 220: ** to be disabled in some cases (ex: when generating CSV output and when 221: ** rendering quoted strings that contain \n characters). The following 222: ** routines take care of that. 223: */ 1.5 misho 224: #if (defined(_WIN32) || defined(WIN32)) && !SQLITE_OS_WINRT 1.4 misho 225: static void setBinaryMode(FILE *file, int isOutput){ 226: if( isOutput ) fflush(file); 227: _setmode(_fileno(file), _O_BINARY); 228: } 229: static void setTextMode(FILE *file, int isOutput){ 230: if( isOutput ) fflush(file); 231: _setmode(_fileno(file), _O_TEXT); 232: } 233: #else 234: # define setBinaryMode(X,Y) 235: # define setTextMode(X,Y) 236: #endif 237: 238: 239: /* True if the timer is enabled */ 240: static int enableTimer = 0; 241: 242: /* Return the current wall-clock time */ 243: static sqlite3_int64 timeOfDay(void){ 244: static sqlite3_vfs *clockVfs = 0; 245: sqlite3_int64 t; 246: if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0); 247: if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){ 248: clockVfs->xCurrentTimeInt64(clockVfs, &t); 249: }else{ 250: double r; 251: clockVfs->xCurrentTime(clockVfs, &r); 252: t = (sqlite3_int64)(r*86400000.0); 253: } 254: return t; 255: } 256: 257: #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux) 1.2 misho 258: #include <sys/time.h> 259: #include <sys/resource.h> 260: 1.4 misho 261: /* VxWorks does not support getrusage() as far as we can determine */ 262: #if defined(_WRS_KERNEL) || defined(__RTP__) 263: struct rusage { 264: struct timeval ru_utime; /* user CPU time used */ 265: struct timeval ru_stime; /* system CPU time used */ 266: }; 267: #define getrusage(A,B) memset(B,0,sizeof(*B)) 268: #endif 269: 1.2 misho 270: /* Saved resource information for the beginning of an operation */ 1.4 misho 271: static struct rusage sBegin; /* CPU time at start */ 272: static sqlite3_int64 iBegin; /* Wall-clock time at start */ 1.2 misho 273: 274: /* 275: ** Begin timing an operation 276: */ 277: static void beginTimer(void){ 278: if( enableTimer ){ 279: getrusage(RUSAGE_SELF, &sBegin); 1.4 misho 280: iBegin = timeOfDay(); 1.2 misho 281: } 282: } 283: 284: /* Return the difference of two time_structs in seconds */ 285: static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ 1.4 misho 286: return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + 1.2 misho 287: (double)(pEnd->tv_sec - pStart->tv_sec); 288: } 289: 290: /* 291: ** Print the timing results. 292: */ 293: static void endTimer(void){ 294: if( enableTimer ){ 1.4 misho 295: sqlite3_int64 iEnd = timeOfDay(); 1.2 misho 296: struct rusage sEnd; 297: getrusage(RUSAGE_SELF, &sEnd); 1.4 misho 298: printf("Run Time: real %.3f user %f sys %f\n", 299: (iEnd - iBegin)*0.001, 1.2 misho 300: timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), 301: timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); 302: } 303: } 304: 305: #define BEGIN_TIMER beginTimer() 306: #define END_TIMER endTimer() 307: #define HAS_TIMER 1 308: 309: #elif (defined(_WIN32) || defined(WIN32)) 310: 311: /* Saved resource information for the beginning of an operation */ 312: static HANDLE hProcess; 313: static FILETIME ftKernelBegin; 314: static FILETIME ftUserBegin; 1.4 misho 315: static sqlite3_int64 ftWallBegin; 316: typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, 317: LPFILETIME, LPFILETIME); 1.2 misho 318: static GETPROCTIMES getProcessTimesAddr = NULL; 319: 320: /* 321: ** Check to see if we have timer support. Return 1 if necessary 322: ** support found (or found previously). 323: */ 324: static int hasTimer(void){ 325: if( getProcessTimesAddr ){ 326: return 1; 327: } else { 1.5 misho 328: #if !SQLITE_OS_WINRT 1.4 misho 329: /* GetProcessTimes() isn't supported in WIN95 and some other Windows 330: ** versions. See if the version we are running on has it, and if it 331: ** does, save off a pointer to it and the current process handle. 1.2 misho 332: */ 333: hProcess = GetCurrentProcess(); 334: if( hProcess ){ 335: HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); 336: if( NULL != hinstLib ){ 1.4 misho 337: getProcessTimesAddr = 338: (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); 1.2 misho 339: if( NULL != getProcessTimesAddr ){ 340: return 1; 341: } 1.4 misho 342: FreeLibrary(hinstLib); 1.2 misho 343: } 344: } 1.5 misho 345: #endif 1.2 misho 346: } 347: return 0; 348: } 349: 350: /* 351: ** Begin timing an operation 352: */ 353: static void beginTimer(void){ 354: if( enableTimer && getProcessTimesAddr ){ 355: FILETIME ftCreation, ftExit; 1.4 misho 356: getProcessTimesAddr(hProcess,&ftCreation,&ftExit, 357: &ftKernelBegin,&ftUserBegin); 358: ftWallBegin = timeOfDay(); 1.2 misho 359: } 360: } 361: 362: /* Return the difference of two FILETIME structs in seconds */ 363: static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ 364: sqlite_int64 i64Start = *((sqlite_int64 *) pStart); 365: sqlite_int64 i64End = *((sqlite_int64 *) pEnd); 366: return (double) ((i64End - i64Start) / 10000000.0); 367: } 368: 369: /* 370: ** Print the timing results. 371: */ 372: static void endTimer(void){ 373: if( enableTimer && getProcessTimesAddr){ 374: FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; 1.4 misho 375: sqlite3_int64 ftWallEnd = timeOfDay(); 376: getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd); 377: printf("Run Time: real %.3f user %f sys %f\n", 378: (ftWallEnd - ftWallBegin)*0.001, 1.2 misho 379: timeDiff(&ftUserBegin, &ftUserEnd), 380: timeDiff(&ftKernelBegin, &ftKernelEnd)); 381: } 382: } 383: 384: #define BEGIN_TIMER beginTimer() 385: #define END_TIMER endTimer() 386: #define HAS_TIMER hasTimer() 387: 388: #else 1.4 misho 389: #define BEGIN_TIMER 1.2 misho 390: #define END_TIMER 391: #define HAS_TIMER 0 392: #endif 393: 394: /* 395: ** Used to prevent warnings about unused parameters 396: */ 397: #define UNUSED_PARAMETER(x) (void)(x) 398: 399: /* 1.5 misho 400: ** Number of elements in an array 401: */ 402: #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) 403: 404: /* 1.2 misho 405: ** If the following flag is set, then command execution stops 406: ** at an error if we are not interactive. 407: */ 408: static int bail_on_error = 0; 409: 410: /* 411: ** Threat stdin as an interactive input if the following variable 412: ** is true. Otherwise, assume stdin is connected to a file or pipe. 413: */ 414: static int stdin_is_interactive = 1; 415: 416: /* 1.4 misho 417: ** On Windows systems we have to know if standard output is a console 418: ** in order to translate UTF-8 into MBCS. The following variable is 419: ** true if translation is required. 420: */ 421: static int stdout_is_console = 1; 422: 423: /* 1.2 misho 424: ** The following is the open SQLite database. We make a pointer 425: ** to this database a static variable so that it can be accessed 426: ** by the SIGINT handler to interrupt database processing. 427: */ 1.4 misho 428: static sqlite3 *globalDb = 0; 1.2 misho 429: 430: /* 431: ** True if an interrupt (Control-C) has been received. 432: */ 433: static volatile int seenInterrupt = 0; 434: 1.5 misho 435: #ifdef SQLITE_DEBUG 436: /* 437: ** Out-of-memory simulator variables 438: */ 439: static unsigned int oomCounter = 0; /* Simulate OOM when equals 1 */ 440: static unsigned int oomRepeat = 0; /* Number of OOMs in a row */ 441: static void*(*defaultMalloc)(int) = 0; /* The low-level malloc routine */ 442: #endif /* SQLITE_DEBUG */ 443: 1.2 misho 444: /* 445: ** This is the name of our program. It is set in main(), used 446: ** in a number of other places, mostly for error messages. 447: */ 448: static char *Argv0; 449: 450: /* 451: ** Prompt strings. Initialized in main. Settable with 452: ** .prompt main continue 453: */ 454: static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ 455: static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ 456: 457: /* 1.4 misho 458: ** Render output like fprintf(). Except, if the output is going to the 459: ** console and if this is running on a Windows machine, translate the 460: ** output from UTF-8 into MBCS. 461: */ 462: #if defined(_WIN32) || defined(WIN32) 463: void utf8_printf(FILE *out, const char *zFormat, ...){ 464: va_list ap; 465: va_start(ap, zFormat); 466: if( stdout_is_console && (out==stdout || out==stderr) ){ 467: char *z1 = sqlite3_vmprintf(zFormat, ap); 468: char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0); 469: sqlite3_free(z1); 470: fputs(z2, out); 471: sqlite3_free(z2); 472: }else{ 473: vfprintf(out, zFormat, ap); 474: } 475: va_end(ap); 476: } 477: #elif !defined(utf8_printf) 478: # define utf8_printf fprintf 479: #endif 480: 481: /* 482: ** Render output like fprintf(). This should not be used on anything that 483: ** includes string formatting (e.g. "%s"). 484: */ 485: #if !defined(raw_printf) 486: # define raw_printf fprintf 487: #endif 488: 1.5 misho 489: /* Indicate out-of-memory and exit. */ 490: static void shell_out_of_memory(void){ 491: raw_printf(stderr,"Error: out of memory\n"); 492: exit(1); 493: } 494: 495: #ifdef SQLITE_DEBUG 496: /* This routine is called when a simulated OOM occurs. It is broken 497: ** out as a separate routine to make it easy to set a breakpoint on 498: ** the OOM 499: */ 500: void shellOomFault(void){ 501: if( oomRepeat>0 ){ 502: oomRepeat--; 503: }else{ 504: oomCounter--; 505: } 506: } 507: #endif /* SQLITE_DEBUG */ 508: 509: #ifdef SQLITE_DEBUG 510: /* This routine is a replacement malloc() that is used to simulate 511: ** Out-Of-Memory (OOM) errors for testing purposes. 512: */ 513: static void *oomMalloc(int nByte){ 514: if( oomCounter ){ 515: if( oomCounter==1 ){ 516: shellOomFault(); 517: return 0; 518: }else{ 519: oomCounter--; 520: } 521: } 522: return defaultMalloc(nByte); 523: } 524: #endif /* SQLITE_DEBUG */ 525: 526: #ifdef SQLITE_DEBUG 527: /* Register the OOM simulator. This must occur before any memory 528: ** allocations */ 529: static void registerOomSimulator(void){ 530: sqlite3_mem_methods mem; 531: sqlite3_config(SQLITE_CONFIG_GETMALLOC, &mem); 532: defaultMalloc = mem.xMalloc; 533: mem.xMalloc = oomMalloc; 534: sqlite3_config(SQLITE_CONFIG_MALLOC, &mem); 535: } 536: #endif 537: 1.4 misho 538: /* 1.2 misho 539: ** Write I/O traces to the following stream. 540: */ 541: #ifdef SQLITE_ENABLE_IOTRACE 542: static FILE *iotrace = 0; 543: #endif 544: 545: /* 546: ** This routine works like printf in that its first argument is a 547: ** format string and subsequent arguments are values to be substituted 548: ** in place of % fields. The result of formatting this string 549: ** is written to iotrace. 550: */ 551: #ifdef SQLITE_ENABLE_IOTRACE 1.4 misho 552: static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){ 1.2 misho 553: va_list ap; 554: char *z; 555: if( iotrace==0 ) return; 556: va_start(ap, zFormat); 557: z = sqlite3_vmprintf(zFormat, ap); 558: va_end(ap); 1.4 misho 559: utf8_printf(iotrace, "%s", z); 1.2 misho 560: sqlite3_free(z); 561: } 562: #endif 563: 1.5 misho 564: /* 565: ** Output string zUtf to stream pOut as w characters. If w is negative, 566: ** then right-justify the text. W is the width in UTF-8 characters, not 567: ** in bytes. This is different from the %*.*s specification in printf 568: ** since with %*.*s the width is measured in bytes, not characters. 569: */ 570: static void utf8_width_print(FILE *pOut, int w, const char *zUtf){ 571: int i; 572: int n; 573: int aw = w<0 ? -w : w; 574: for(i=n=0; zUtf[i]; i++){ 575: if( (zUtf[i]&0xc0)!=0x80 ){ 576: n++; 577: if( n==aw ){ 578: do{ i++; }while( (zUtf[i]&0xc0)==0x80 ); 579: break; 580: } 581: } 582: } 583: if( n>=aw ){ 584: utf8_printf(pOut, "%.*s", i, zUtf); 585: }else if( w<0 ){ 586: utf8_printf(pOut, "%*s%s", aw-n, "", zUtf); 587: }else{ 588: utf8_printf(pOut, "%s%*s", zUtf, aw-n, ""); 589: } 590: } 591: 1.2 misho 592: 593: /* 594: ** Determines if a string is a number of not. 595: */ 596: static int isNumber(const char *z, int *realnum){ 597: if( *z=='-' || *z=='+' ) z++; 598: if( !IsDigit(*z) ){ 599: return 0; 600: } 601: z++; 602: if( realnum ) *realnum = 0; 603: while( IsDigit(*z) ){ z++; } 604: if( *z=='.' ){ 605: z++; 606: if( !IsDigit(*z) ) return 0; 607: while( IsDigit(*z) ){ z++; } 608: if( realnum ) *realnum = 1; 609: } 610: if( *z=='e' || *z=='E' ){ 611: z++; 612: if( *z=='+' || *z=='-' ) z++; 613: if( !IsDigit(*z) ) return 0; 614: while( IsDigit(*z) ){ z++; } 615: if( realnum ) *realnum = 1; 616: } 617: return *z==0; 618: } 619: 620: /* 1.4 misho 621: ** Compute a string length that is limited to what can be stored in 622: ** lower 30 bits of a 32-bit signed integer. 623: */ 624: static int strlen30(const char *z){ 625: const char *z2 = z; 626: while( *z2 ){ z2++; } 627: return 0x3fffffff & (int)(z2 - z); 628: } 629: 630: /* 1.5 misho 631: ** Return the length of a string in characters. Multibyte UTF8 characters 632: ** count as a single character. 633: */ 634: static int strlenChar(const char *z){ 635: int n = 0; 636: while( *z ){ 637: if( (0xc0&*(z++))!=0x80 ) n++; 638: } 639: return n; 640: } 641: 642: /* 643: ** Return true if zFile does not exist or if it is not an ordinary file. 644: */ 645: #ifdef _WIN32 646: # define notNormalFile(X) 0 647: #else 648: static int notNormalFile(const char *zFile){ 649: struct stat x; 650: int rc; 651: memset(&x, 0, sizeof(x)); 652: rc = stat(zFile, &x); 653: return rc || !S_ISREG(x.st_mode); 654: } 655: #endif 656: 657: /* 1.2 misho 658: ** This routine reads a line of text from FILE in, stores 659: ** the text in memory obtained from malloc() and returns a pointer 660: ** to the text. NULL is returned at end of file, or if malloc() 661: ** fails. 662: ** 1.4 misho 663: ** If zLine is not NULL then it is a malloced buffer returned from 664: ** a previous call to this routine that may be reused. 1.2 misho 665: */ 1.4 misho 666: static char *local_getline(char *zLine, FILE *in){ 667: int nLine = zLine==0 ? 0 : 100; 668: int n = 0; 1.2 misho 669: 670: while( 1 ){ 671: if( n+100>nLine ){ 672: nLine = nLine*2 + 100; 673: zLine = realloc(zLine, nLine); 1.5 misho 674: if( zLine==0 ) shell_out_of_memory(); 1.2 misho 675: } 676: if( fgets(&zLine[n], nLine - n, in)==0 ){ 677: if( n==0 ){ 678: free(zLine); 679: return 0; 680: } 681: zLine[n] = 0; 682: break; 683: } 1.4 misho 684: while( zLine[n] ) n++; 685: if( n>0 && zLine[n-1]=='\n' ){ 1.2 misho 686: n--; 687: if( n>0 && zLine[n-1]=='\r' ) n--; 688: zLine[n] = 0; 689: break; 690: } 691: } 1.4 misho 692: #if defined(_WIN32) || defined(WIN32) 693: /* For interactive input on Windows systems, translate the 694: ** multi-byte characterset characters into UTF-8. */ 695: if( stdin_is_interactive && in==stdin ){ 696: char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0); 697: if( zTrans ){ 698: int nTrans = strlen30(zTrans)+1; 699: if( nTrans>nLine ){ 700: zLine = realloc(zLine, nTrans); 1.5 misho 701: if( zLine==0 ) shell_out_of_memory(); 1.4 misho 702: } 703: memcpy(zLine, zTrans, nTrans); 704: sqlite3_free(zTrans); 705: } 706: } 707: #endif /* defined(_WIN32) || defined(WIN32) */ 1.2 misho 708: return zLine; 709: } 710: 711: /* 712: ** Retrieve a single line of input text. 713: ** 1.4 misho 714: ** If in==0 then read from standard input and prompt before each line. 715: ** If isContinuation is true, then a continuation prompt is appropriate. 716: ** If isContinuation is zero, then the main prompt should be used. 717: ** 718: ** If zPrior is not NULL then it is a buffer from a prior call to this 719: ** routine that can be reused. 720: ** 721: ** The result is stored in space obtained from malloc() and must either 722: ** be freed by the caller or else passed back into this routine via the 723: ** zPrior argument for reuse. 1.2 misho 724: */ 1.4 misho 725: static char *one_input_line(FILE *in, char *zPrior, int isContinuation){ 1.2 misho 726: char *zPrompt; 727: char *zResult; 728: if( in!=0 ){ 1.4 misho 729: zResult = local_getline(zPrior, in); 1.2 misho 730: }else{ 1.4 misho 731: zPrompt = isContinuation ? continuePrompt : mainPrompt; 732: #if SHELL_USE_LOCAL_GETLINE 733: printf("%s", zPrompt); 734: fflush(stdout); 735: zResult = local_getline(zPrior, stdin); 736: #else 737: free(zPrior); 738: zResult = shell_readline(zPrompt); 739: if( zResult && *zResult ) shell_add_history(zResult); 740: #endif 1.2 misho 741: } 742: return zResult; 743: } 744: 1.5 misho 745: 1.4 misho 746: /* 1.5 misho 747: ** Return the value of a hexadecimal digit. Return -1 if the input 748: ** is not a hex digit. 1.4 misho 749: */ 1.5 misho 750: static int hexDigitValue(char c){ 751: if( c>='0' && c<='9' ) return c - '0'; 752: if( c>='a' && c<='f' ) return c - 'a' + 10; 753: if( c>='A' && c<='F' ) return c - 'A' + 10; 754: return -1; 755: } 1.4 misho 756: 757: /* 1.5 misho 758: ** Interpret zArg as an integer value, possibly with suffixes. 1.4 misho 759: */ 1.5 misho 760: static sqlite3_int64 integerValue(const char *zArg){ 761: sqlite3_int64 v = 0; 762: static const struct { char *zSuffix; int iMult; } aMult[] = { 763: { "KiB", 1024 }, 764: { "MiB", 1024*1024 }, 765: { "GiB", 1024*1024*1024 }, 766: { "KB", 1000 }, 767: { "MB", 1000000 }, 768: { "GB", 1000000000 }, 769: { "K", 1000 }, 770: { "M", 1000000 }, 771: { "G", 1000000000 }, 772: }; 773: int i; 774: int isNeg = 0; 775: if( zArg[0]=='-' ){ 776: isNeg = 1; 777: zArg++; 778: }else if( zArg[0]=='+' ){ 779: zArg++; 780: } 781: if( zArg[0]=='0' && zArg[1]=='x' ){ 782: int x; 783: zArg += 2; 784: while( (x = hexDigitValue(zArg[0]))>=0 ){ 785: v = (v<<4) + x; 786: zArg++; 787: } 788: }else{ 789: while( IsDigit(zArg[0]) ){ 790: v = v*10 + zArg[0] - '0'; 791: zArg++; 792: } 793: } 794: for(i=0; i<ArraySize(aMult); i++){ 795: if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){ 796: v *= aMult[i].iMult; 797: break; 798: } 799: } 800: return isNeg? -v : v; 801: } 1.2 misho 802: 803: /* 1.5 misho 804: ** A variable length string to which one can append text. 1.2 misho 805: */ 1.5 misho 806: typedef struct ShellText ShellText; 807: struct ShellText { 808: char *z; 809: int n; 810: int nAlloc; 1.2 misho 811: }; 812: 813: /* 1.5 misho 814: ** Initialize and destroy a ShellText object 1.4 misho 815: */ 1.5 misho 816: static void initText(ShellText *p){ 817: memset(p, 0, sizeof(*p)); 818: } 819: static void freeText(ShellText *p){ 820: free(p->z); 821: initText(p); 822: } 1.4 misho 823: 1.5 misho 824: /* zIn is either a pointer to a NULL-terminated string in memory obtained 825: ** from malloc(), or a NULL pointer. The string pointed to by zAppend is 826: ** added to zIn, and the result returned in memory obtained from malloc(). 827: ** zIn, if it was not NULL, is freed. 828: ** 829: ** If the third argument, quote, is not '\0', then it is used as a 830: ** quote character for zAppend. 1.2 misho 831: */ 1.5 misho 832: static void appendText(ShellText *p, char const *zAppend, char quote){ 833: int len; 834: int i; 835: int nAppend = strlen30(zAppend); 836: 837: len = nAppend+p->n+1; 838: if( quote ){ 839: len += 2; 840: for(i=0; i<nAppend; i++){ 841: if( zAppend[i]==quote ) len++; 842: } 843: } 1.2 misho 844: 1.5 misho 845: if( p->n+len>=p->nAlloc ){ 846: p->nAlloc = p->nAlloc*2 + len + 20; 847: p->z = realloc(p->z, p->nAlloc); 848: if( p->z==0 ) shell_out_of_memory(); 849: } 1.2 misho 850: 1.5 misho 851: if( quote ){ 852: char *zCsr = p->z+p->n; 853: *zCsr++ = quote; 854: for(i=0; i<nAppend; i++){ 855: *zCsr++ = zAppend[i]; 856: if( zAppend[i]==quote ) *zCsr++ = quote; 857: } 858: *zCsr++ = quote; 859: p->n = (int)(zCsr - p->z); 860: *zCsr = '\0'; 861: }else{ 862: memcpy(p->z+p->n, zAppend, nAppend); 863: p->n += nAppend; 864: p->z[p->n] = '\0'; 865: } 866: } 1.2 misho 867: 868: /* 1.5 misho 869: ** Attempt to determine if identifier zName needs to be quoted, either 870: ** because it contains non-alphanumeric characters, or because it is an 871: ** SQLite keyword. Be conservative in this estimate: When in doubt assume 872: ** that quoting is required. 873: ** 874: ** Return '"' if quoting is required. Return 0 if no quoting is required. 1.2 misho 875: */ 1.5 misho 876: static char quoteChar(const char *zName){ 877: int i; 878: if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"'; 879: for(i=0; zName[i]; i++){ 880: if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"'; 881: } 882: return sqlite3_keyword_check(zName, i) ? '"' : 0; 883: } 1.2 misho 884: 885: /* 1.5 misho 886: ** Construct a fake object name and column list to describe the structure 887: ** of the view, virtual table, or table valued function zSchema.zName. 1.2 misho 888: */ 1.5 misho 889: static char *shellFakeSchema( 890: sqlite3 *db, /* The database connection containing the vtab */ 891: const char *zSchema, /* Schema of the database holding the vtab */ 892: const char *zName /* The name of the virtual table */ 893: ){ 894: sqlite3_stmt *pStmt = 0; 895: char *zSql; 896: ShellText s; 897: char cQuote; 898: char *zDiv = "("; 899: int nRow = 0; 900: 901: zSql = sqlite3_mprintf("PRAGMA \"%w\".table_info=%Q;", 902: zSchema ? zSchema : "main", zName); 903: sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 904: sqlite3_free(zSql); 905: initText(&s); 906: if( zSchema ){ 907: cQuote = quoteChar(zSchema); 908: if( cQuote && sqlite3_stricmp(zSchema,"temp")==0 ) cQuote = 0; 909: appendText(&s, zSchema, cQuote); 910: appendText(&s, ".", 0); 911: } 912: cQuote = quoteChar(zName); 913: appendText(&s, zName, cQuote); 914: while( sqlite3_step(pStmt)==SQLITE_ROW ){ 915: const char *zCol = (const char*)sqlite3_column_text(pStmt, 1); 916: nRow++; 917: appendText(&s, zDiv, 0); 918: zDiv = ","; 919: cQuote = quoteChar(zCol); 920: appendText(&s, zCol, cQuote); 921: } 922: appendText(&s, ")", 0); 923: sqlite3_finalize(pStmt); 924: if( nRow==0 ){ 925: freeText(&s); 926: s.z = 0; 927: } 928: return s.z; 1.2 misho 929: } 930: 931: /* 1.5 misho 932: ** SQL function: shell_module_schema(X) 933: ** 934: ** Return a fake schema for the table-valued function or eponymous virtual 935: ** table X. 1.2 misho 936: */ 1.5 misho 937: static void shellModuleSchema( 938: sqlite3_context *pCtx, 939: int nVal, 940: sqlite3_value **apVal 941: ){ 942: const char *zName = (const char*)sqlite3_value_text(apVal[0]); 943: char *zFake = shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName); 944: UNUSED_PARAMETER(nVal); 945: if( zFake ){ 946: sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake), 947: -1, sqlite3_free); 948: free(zFake); 949: } 1.2 misho 950: } 951: 952: /* 1.5 misho 953: ** SQL function: shell_add_schema(S,X) 954: ** 955: ** Add the schema name X to the CREATE statement in S and return the result. 956: ** Examples: 957: ** 958: ** CREATE TABLE t1(x) -> CREATE TABLE xyz.t1(x); 959: ** 960: ** Also works on 961: ** 962: ** CREATE INDEX 963: ** CREATE UNIQUE INDEX 964: ** CREATE VIEW 965: ** CREATE TRIGGER 966: ** CREATE VIRTUAL TABLE 967: ** 968: ** This UDF is used by the .schema command to insert the schema name of 969: ** attached databases into the middle of the sqlite_schema.sql field. 1.2 misho 970: */ 1.5 misho 971: static void shellAddSchemaName( 972: sqlite3_context *pCtx, 973: int nVal, 974: sqlite3_value **apVal 975: ){ 976: static const char *aPrefix[] = { 977: "TABLE", 978: "INDEX", 979: "UNIQUE INDEX", 980: "VIEW", 981: "TRIGGER", 982: "VIRTUAL TABLE" 983: }; 984: int i = 0; 985: const char *zIn = (const char*)sqlite3_value_text(apVal[0]); 986: const char *zSchema = (const char*)sqlite3_value_text(apVal[1]); 987: const char *zName = (const char*)sqlite3_value_text(apVal[2]); 988: sqlite3 *db = sqlite3_context_db_handle(pCtx); 989: UNUSED_PARAMETER(nVal); 990: if( zIn!=0 && strncmp(zIn, "CREATE ", 7)==0 ){ 991: for(i=0; i<(int)(sizeof(aPrefix)/sizeof(aPrefix[0])); i++){ 992: int n = strlen30(aPrefix[i]); 993: if( strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){ 994: char *z = 0; 995: char *zFake = 0; 996: if( zSchema ){ 997: char cQuote = quoteChar(zSchema); 998: if( cQuote && sqlite3_stricmp(zSchema,"temp")!=0 ){ 999: z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8); 1000: }else{ 1001: z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8); 1002: } 1003: } 1004: if( zName 1005: && aPrefix[i][0]=='V' 1006: && (zFake = shellFakeSchema(db, zSchema, zName))!=0 1007: ){ 1008: if( z==0 ){ 1009: z = sqlite3_mprintf("%s\n/* %s */", zIn, zFake); 1010: }else{ 1011: z = sqlite3_mprintf("%z\n/* %s */", z, zFake); 1012: } 1013: free(zFake); 1014: } 1015: if( z ){ 1016: sqlite3_result_text(pCtx, z, -1, sqlite3_free); 1017: return; 1018: } 1.2 misho 1019: } 1020: } 1021: } 1.5 misho 1022: sqlite3_result_value(pCtx, apVal[0]); 1.2 misho 1023: } 1024: 1025: /* 1.5 misho 1026: ** The source code for several run-time loadable extensions is inserted 1027: ** below by the ../tool/mkshellc.tcl script. Before processing that included 1028: ** code, we need to override some macros to make the included program code 1029: ** work here in the middle of this regular program. 1030: */ 1031: #define SQLITE_EXTENSION_INIT1 1032: #define SQLITE_EXTENSION_INIT2(X) (void)(X) 1033: 1034: #if defined(_WIN32) && defined(_MSC_VER) 1035: /************************* Begin test_windirent.h ******************/ 1036: /* 1037: ** 2015 November 30 1038: ** 1039: ** The author disclaims copyright to this source code. In place of 1040: ** a legal notice, here is a blessing: 1041: ** 1042: ** May you do good and not evil. 1043: ** May you find forgiveness for yourself and forgive others. 1044: ** May you share freely, never taking more than you give. 1045: ** 1046: ************************************************************************* 1047: ** This file contains declarations for most of the opendir() family of 1048: ** POSIX functions on Win32 using the MSVCRT. 1049: */ 1050: 1051: #if defined(_WIN32) && defined(_MSC_VER) && !defined(SQLITE_WINDIRENT_H) 1052: #define SQLITE_WINDIRENT_H 1053: 1054: /* 1055: ** We need several data types from the Windows SDK header. 1056: */ 1057: 1058: #ifndef WIN32_LEAN_AND_MEAN 1059: #define WIN32_LEAN_AND_MEAN 1060: #endif 1061: 1062: #include "windows.h" 1063: 1064: /* 1065: ** We need several support functions from the SQLite core. 1.2 misho 1066: */ 1.5 misho 1067: 1068: /* #include "sqlite3.h" */ 1.2 misho 1069: 1070: /* 1.5 misho 1071: ** We need several things from the ANSI and MSVCRT headers. 1.2 misho 1072: */ 1.5 misho 1073: 1074: #include <stdio.h> 1075: #include <stdlib.h> 1076: #include <errno.h> 1077: #include <io.h> 1078: #include <limits.h> 1079: #include <sys/types.h> 1080: #include <sys/stat.h> 1.2 misho 1081: 1082: /* 1.5 misho 1083: ** We may need several defines that should have been in "sys/stat.h". 1.2 misho 1084: */ 1.5 misho 1085: 1086: #ifndef S_ISREG 1087: #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) 1088: #endif 1089: 1090: #ifndef S_ISDIR 1091: #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) 1092: #endif 1093: 1094: #ifndef S_ISLNK 1095: #define S_ISLNK(mode) (0) 1096: #endif 1.2 misho 1097: 1098: /* 1.5 misho 1099: ** We may need to provide the "mode_t" type. 1.2 misho 1100: */ 1101: 1.5 misho 1102: #ifndef MODE_T_DEFINED 1103: #define MODE_T_DEFINED 1104: typedef unsigned short mode_t; 1105: #endif 1106: 1.2 misho 1107: /* 1.5 misho 1108: ** We may need to provide the "ino_t" type. 1.2 misho 1109: */ 1.5 misho 1110: 1111: #ifndef INO_T_DEFINED 1112: #define INO_T_DEFINED 1113: typedef unsigned short ino_t; 1.2 misho 1114: #endif 1115: 1116: /* 1.5 misho 1117: ** We need to define "NAME_MAX" if it was not present in "limits.h". 1.4 misho 1118: */ 1.5 misho 1119: 1120: #ifndef NAME_MAX 1121: # ifdef FILENAME_MAX 1122: # define NAME_MAX (FILENAME_MAX) 1123: # else 1124: # define NAME_MAX (260) 1125: # endif 1126: #endif 1.4 misho 1127: 1128: /* 1.5 misho 1129: ** We need to define "NULL_INTPTR_T" and "BAD_INTPTR_T". 1.2 misho 1130: */ 1131: 1.5 misho 1132: #ifndef NULL_INTPTR_T 1133: # define NULL_INTPTR_T ((intptr_t)(0)) 1134: #endif 1135: 1136: #ifndef BAD_INTPTR_T 1137: # define BAD_INTPTR_T ((intptr_t)(-1)) 1138: #endif 1139: 1140: /* 1141: ** We need to provide the necessary structures and related types. 1142: */ 1143: 1144: #ifndef DIRENT_DEFINED 1145: #define DIRENT_DEFINED 1146: typedef struct DIRENT DIRENT; 1147: typedef DIRENT *LPDIRENT; 1148: struct DIRENT { 1149: ino_t d_ino; /* Sequence number, do not use. */ 1150: unsigned d_attributes; /* Win32 file attributes. */ 1151: char d_name[NAME_MAX + 1]; /* Name within the directory. */ 1152: }; 1153: #endif 1154: 1155: #ifndef DIR_DEFINED 1156: #define DIR_DEFINED 1157: typedef struct DIR DIR; 1158: typedef DIR *LPDIR; 1159: struct DIR { 1160: intptr_t d_handle; /* Value returned by "_findfirst". */ 1161: DIRENT d_first; /* DIRENT constructed based on "_findfirst". */ 1162: DIRENT d_next; /* DIRENT constructed based on "_findnext". */ 1163: }; 1164: #endif 1165: 1166: /* 1167: ** Provide a macro, for use by the implementation, to determine if a 1168: ** particular directory entry should be skipped over when searching for 1169: ** the next directory entry that should be returned by the readdir() or 1170: ** readdir_r() functions. 1171: */ 1172: 1173: #ifndef is_filtered 1174: # define is_filtered(a) ((((a).attrib)&_A_HIDDEN) || (((a).attrib)&_A_SYSTEM)) 1175: #endif 1176: 1177: /* 1178: ** Provide the function prototype for the POSIX compatiable getenv() 1179: ** function. This function is not thread-safe. 1180: */ 1181: 1182: extern const char *windirent_getenv(const char *name); 1183: 1184: /* 1185: ** Finally, we can provide the function prototypes for the opendir(), 1186: ** readdir(), readdir_r(), and closedir() POSIX functions. 1187: */ 1188: 1189: extern LPDIR opendir(const char *dirname); 1190: extern LPDIRENT readdir(LPDIR dirp); 1191: extern INT readdir_r(LPDIR dirp, LPDIRENT entry, LPDIRENT *result); 1192: extern INT closedir(LPDIR dirp); 1193: 1194: #endif /* defined(WIN32) && defined(_MSC_VER) */ 1195: 1196: /************************* End test_windirent.h ********************/ 1197: /************************* Begin test_windirent.c ******************/ 1198: /* 1199: ** 2015 November 30 1200: ** 1201: ** The author disclaims copyright to this source code. In place of 1202: ** a legal notice, here is a blessing: 1203: ** 1204: ** May you do good and not evil. 1205: ** May you find forgiveness for yourself and forgive others. 1206: ** May you share freely, never taking more than you give. 1207: ** 1208: ************************************************************************* 1209: ** This file contains code to implement most of the opendir() family of 1210: ** POSIX functions on Win32 using the MSVCRT. 1211: */ 1212: 1213: #if defined(_WIN32) && defined(_MSC_VER) 1214: /* #include "test_windirent.h" */ 1215: 1216: /* 1217: ** Implementation of the POSIX getenv() function using the Win32 API. 1218: ** This function is not thread-safe. 1219: */ 1220: const char *windirent_getenv( 1221: const char *name 1222: ){ 1223: static char value[32768]; /* Maximum length, per MSDN */ 1224: DWORD dwSize = sizeof(value) / sizeof(char); /* Size in chars */ 1225: DWORD dwRet; /* Value returned by GetEnvironmentVariableA() */ 1226: 1227: memset(value, 0, sizeof(value)); 1228: dwRet = GetEnvironmentVariableA(name, value, dwSize); 1229: if( dwRet==0 || dwRet>dwSize ){ 1230: /* 1231: ** The function call to GetEnvironmentVariableA() failed -OR- 1232: ** the buffer is not large enough. Either way, return NULL. 1233: */ 1234: return 0; 1235: }else{ 1236: /* 1237: ** The function call to GetEnvironmentVariableA() succeeded 1238: ** -AND- the buffer contains the entire value. 1239: */ 1240: return value; 1241: } 1242: } 1243: 1244: /* 1245: ** Implementation of the POSIX opendir() function using the MSVCRT. 1246: */ 1247: LPDIR opendir( 1248: const char *dirname 1249: ){ 1250: struct _finddata_t data; 1251: LPDIR dirp = (LPDIR)sqlite3_malloc(sizeof(DIR)); 1252: SIZE_T namesize = sizeof(data.name) / sizeof(data.name[0]); 1253: 1254: if( dirp==NULL ) return NULL; 1255: memset(dirp, 0, sizeof(DIR)); 1256: 1257: /* TODO: Remove this if Unix-style root paths are not used. */ 1258: if( sqlite3_stricmp(dirname, "/")==0 ){ 1259: dirname = windirent_getenv("SystemDrive"); 1260: } 1261: 1262: memset(&data, 0, sizeof(struct _finddata_t)); 1263: _snprintf(data.name, namesize, "%s\\*", dirname); 1264: dirp->d_handle = _findfirst(data.name, &data); 1265: 1266: if( dirp->d_handle==BAD_INTPTR_T ){ 1267: closedir(dirp); 1268: return NULL; 1269: } 1270: 1271: /* TODO: Remove this block to allow hidden and/or system files. */ 1272: if( is_filtered(data) ){ 1273: next: 1274: 1275: memset(&data, 0, sizeof(struct _finddata_t)); 1276: if( _findnext(dirp->d_handle, &data)==-1 ){ 1277: closedir(dirp); 1278: return NULL; 1279: } 1280: 1281: /* TODO: Remove this block to allow hidden and/or system files. */ 1282: if( is_filtered(data) ) goto next; 1283: } 1284: 1285: dirp->d_first.d_attributes = data.attrib; 1286: strncpy(dirp->d_first.d_name, data.name, NAME_MAX); 1287: dirp->d_first.d_name[NAME_MAX] = '\0'; 1288: 1289: return dirp; 1290: } 1291: 1292: /* 1293: ** Implementation of the POSIX readdir() function using the MSVCRT. 1294: */ 1295: LPDIRENT readdir( 1296: LPDIR dirp 1297: ){ 1298: struct _finddata_t data; 1299: 1300: if( dirp==NULL ) return NULL; 1301: 1302: if( dirp->d_first.d_ino==0 ){ 1303: dirp->d_first.d_ino++; 1304: dirp->d_next.d_ino++; 1305: 1306: return &dirp->d_first; 1307: } 1308: 1309: next: 1310: 1311: memset(&data, 0, sizeof(struct _finddata_t)); 1312: if( _findnext(dirp->d_handle, &data)==-1 ) return NULL; 1313: 1314: /* TODO: Remove this block to allow hidden and/or system files. */ 1315: if( is_filtered(data) ) goto next; 1316: 1317: dirp->d_next.d_ino++; 1318: dirp->d_next.d_attributes = data.attrib; 1319: strncpy(dirp->d_next.d_name, data.name, NAME_MAX); 1320: dirp->d_next.d_name[NAME_MAX] = '\0'; 1321: 1322: return &dirp->d_next; 1323: } 1324: 1325: /* 1326: ** Implementation of the POSIX readdir_r() function using the MSVCRT. 1327: */ 1328: INT readdir_r( 1329: LPDIR dirp, 1330: LPDIRENT entry, 1331: LPDIRENT *result 1332: ){ 1333: struct _finddata_t data; 1334: 1335: if( dirp==NULL ) return EBADF; 1336: 1337: if( dirp->d_first.d_ino==0 ){ 1338: dirp->d_first.d_ino++; 1339: dirp->d_next.d_ino++; 1340: 1341: entry->d_ino = dirp->d_first.d_ino; 1342: entry->d_attributes = dirp->d_first.d_attributes; 1343: strncpy(entry->d_name, dirp->d_first.d_name, NAME_MAX); 1344: entry->d_name[NAME_MAX] = '\0'; 1345: 1346: *result = entry; 1347: return 0; 1348: } 1349: 1350: next: 1351: 1352: memset(&data, 0, sizeof(struct _finddata_t)); 1353: if( _findnext(dirp->d_handle, &data)==-1 ){ 1354: *result = NULL; 1355: return ENOENT; 1356: } 1357: 1358: /* TODO: Remove this block to allow hidden and/or system files. */ 1359: if( is_filtered(data) ) goto next; 1360: 1361: entry->d_ino = (ino_t)-1; /* not available */ 1362: entry->d_attributes = data.attrib; 1363: strncpy(entry->d_name, data.name, NAME_MAX); 1364: entry->d_name[NAME_MAX] = '\0'; 1365: 1366: *result = entry; 1367: return 0; 1368: } 1369: 1370: /* 1371: ** Implementation of the POSIX closedir() function using the MSVCRT. 1372: */ 1373: INT closedir( 1374: LPDIR dirp 1375: ){ 1376: INT result = 0; 1377: 1378: if( dirp==NULL ) return EINVAL; 1379: 1380: if( dirp->d_handle!=NULL_INTPTR_T && dirp->d_handle!=BAD_INTPTR_T ){ 1381: result = _findclose(dirp->d_handle); 1382: } 1383: 1384: sqlite3_free(dirp); 1385: return result; 1386: } 1387: 1388: #endif /* defined(WIN32) && defined(_MSC_VER) */ 1389: 1390: /************************* End test_windirent.c ********************/ 1391: #define dirent DIRENT 1392: #endif 1393: /************************* Begin ../ext/misc/shathree.c ******************/ 1394: /* 1395: ** 2017-03-08 1396: ** 1397: ** The author disclaims copyright to this source code. In place of 1398: ** a legal notice, here is a blessing: 1399: ** 1400: ** May you do good and not evil. 1401: ** May you find forgiveness for yourself and forgive others. 1402: ** May you share freely, never taking more than you give. 1403: ** 1404: ****************************************************************************** 1405: ** 1406: ** This SQLite extension implements functions that compute SHA3 hashes. 1407: ** Two SQL functions are implemented: 1408: ** 1409: ** sha3(X,SIZE) 1410: ** sha3_query(Y,SIZE) 1411: ** 1412: ** The sha3(X) function computes the SHA3 hash of the input X, or NULL if 1413: ** X is NULL. 1414: ** 1415: ** The sha3_query(Y) function evalutes all queries in the SQL statements of Y 1416: ** and returns a hash of their results. 1417: ** 1418: ** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm 1419: ** is used. If SIZE is included it must be one of the integers 224, 256, 1420: ** 384, or 512, to determine SHA3 hash variant that is computed. 1421: */ 1422: /* #include "sqlite3ext.h" */ 1423: SQLITE_EXTENSION_INIT1 1424: #include <assert.h> 1425: #include <string.h> 1426: #include <stdarg.h> 1.6 ! misho 1427: ! 1428: #ifndef SQLITE_AMALGAMATION 1.5 misho 1429: /* typedef sqlite3_uint64 u64; */ 1.6 ! misho 1430: #endif /* SQLITE_AMALGAMATION */ 1.5 misho 1431: 1432: /****************************************************************************** 1433: ** The Hash Engine 1434: */ 1435: /* 1436: ** Macros to determine whether the machine is big or little endian, 1437: ** and whether or not that determination is run-time or compile-time. 1438: ** 1439: ** For best performance, an attempt is made to guess at the byte-order 1440: ** using C-preprocessor macros. If that is unsuccessful, or if 1441: ** -DSHA3_BYTEORDER=0 is set, then byte-order is determined 1442: ** at run-time. 1443: */ 1444: #ifndef SHA3_BYTEORDER 1445: # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ 1446: defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ 1447: defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ 1448: defined(__arm__) 1449: # define SHA3_BYTEORDER 1234 1450: # elif defined(sparc) || defined(__ppc__) 1451: # define SHA3_BYTEORDER 4321 1452: # else 1453: # define SHA3_BYTEORDER 0 1454: # endif 1455: #endif 1456: 1457: 1458: /* 1459: ** State structure for a SHA3 hash in progress 1460: */ 1461: typedef struct SHA3Context SHA3Context; 1462: struct SHA3Context { 1463: union { 1464: u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */ 1465: unsigned char x[1600]; /* ... or 1600 bytes */ 1466: } u; 1467: unsigned nRate; /* Bytes of input accepted per Keccak iteration */ 1468: unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */ 1469: unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */ 1470: }; 1471: 1472: /* 1473: ** A single step of the Keccak mixing function for a 1600-bit state 1474: */ 1475: static void KeccakF1600Step(SHA3Context *p){ 1476: int i; 1477: u64 b0, b1, b2, b3, b4; 1478: u64 c0, c1, c2, c3, c4; 1479: u64 d0, d1, d2, d3, d4; 1480: static const u64 RC[] = { 1481: 0x0000000000000001ULL, 0x0000000000008082ULL, 1482: 0x800000000000808aULL, 0x8000000080008000ULL, 1483: 0x000000000000808bULL, 0x0000000080000001ULL, 1484: 0x8000000080008081ULL, 0x8000000000008009ULL, 1485: 0x000000000000008aULL, 0x0000000000000088ULL, 1486: 0x0000000080008009ULL, 0x000000008000000aULL, 1487: 0x000000008000808bULL, 0x800000000000008bULL, 1488: 0x8000000000008089ULL, 0x8000000000008003ULL, 1489: 0x8000000000008002ULL, 0x8000000000000080ULL, 1490: 0x000000000000800aULL, 0x800000008000000aULL, 1491: 0x8000000080008081ULL, 0x8000000000008080ULL, 1492: 0x0000000080000001ULL, 0x8000000080008008ULL 1493: }; 1494: # define a00 (p->u.s[0]) 1495: # define a01 (p->u.s[1]) 1496: # define a02 (p->u.s[2]) 1497: # define a03 (p->u.s[3]) 1498: # define a04 (p->u.s[4]) 1499: # define a10 (p->u.s[5]) 1500: # define a11 (p->u.s[6]) 1501: # define a12 (p->u.s[7]) 1502: # define a13 (p->u.s[8]) 1503: # define a14 (p->u.s[9]) 1504: # define a20 (p->u.s[10]) 1505: # define a21 (p->u.s[11]) 1506: # define a22 (p->u.s[12]) 1507: # define a23 (p->u.s[13]) 1508: # define a24 (p->u.s[14]) 1509: # define a30 (p->u.s[15]) 1510: # define a31 (p->u.s[16]) 1511: # define a32 (p->u.s[17]) 1512: # define a33 (p->u.s[18]) 1513: # define a34 (p->u.s[19]) 1514: # define a40 (p->u.s[20]) 1515: # define a41 (p->u.s[21]) 1516: # define a42 (p->u.s[22]) 1517: # define a43 (p->u.s[23]) 1518: # define a44 (p->u.s[24]) 1519: # define ROL64(a,x) ((a<<x)|(a>>(64-x))) 1520: 1521: for(i=0; i<24; i+=4){ 1522: c0 = a00^a10^a20^a30^a40; 1523: c1 = a01^a11^a21^a31^a41; 1524: c2 = a02^a12^a22^a32^a42; 1525: c3 = a03^a13^a23^a33^a43; 1526: c4 = a04^a14^a24^a34^a44; 1527: d0 = c4^ROL64(c1, 1); 1528: d1 = c0^ROL64(c2, 1); 1529: d2 = c1^ROL64(c3, 1); 1530: d3 = c2^ROL64(c4, 1); 1531: d4 = c3^ROL64(c0, 1); 1532: 1533: b0 = (a00^d0); 1534: b1 = ROL64((a11^d1), 44); 1535: b2 = ROL64((a22^d2), 43); 1536: b3 = ROL64((a33^d3), 21); 1537: b4 = ROL64((a44^d4), 14); 1538: a00 = b0 ^((~b1)& b2 ); 1539: a00 ^= RC[i]; 1540: a11 = b1 ^((~b2)& b3 ); 1541: a22 = b2 ^((~b3)& b4 ); 1542: a33 = b3 ^((~b4)& b0 ); 1543: a44 = b4 ^((~b0)& b1 ); 1544: 1545: b2 = ROL64((a20^d0), 3); 1546: b3 = ROL64((a31^d1), 45); 1547: b4 = ROL64((a42^d2), 61); 1548: b0 = ROL64((a03^d3), 28); 1549: b1 = ROL64((a14^d4), 20); 1550: a20 = b0 ^((~b1)& b2 ); 1551: a31 = b1 ^((~b2)& b3 ); 1552: a42 = b2 ^((~b3)& b4 ); 1553: a03 = b3 ^((~b4)& b0 ); 1554: a14 = b4 ^((~b0)& b1 ); 1555: 1556: b4 = ROL64((a40^d0), 18); 1557: b0 = ROL64((a01^d1), 1); 1558: b1 = ROL64((a12^d2), 6); 1559: b2 = ROL64((a23^d3), 25); 1560: b3 = ROL64((a34^d4), 8); 1561: a40 = b0 ^((~b1)& b2 ); 1562: a01 = b1 ^((~b2)& b3 ); 1563: a12 = b2 ^((~b3)& b4 ); 1564: a23 = b3 ^((~b4)& b0 ); 1565: a34 = b4 ^((~b0)& b1 ); 1566: 1567: b1 = ROL64((a10^d0), 36); 1568: b2 = ROL64((a21^d1), 10); 1569: b3 = ROL64((a32^d2), 15); 1570: b4 = ROL64((a43^d3), 56); 1571: b0 = ROL64((a04^d4), 27); 1572: a10 = b0 ^((~b1)& b2 ); 1573: a21 = b1 ^((~b2)& b3 ); 1574: a32 = b2 ^((~b3)& b4 ); 1575: a43 = b3 ^((~b4)& b0 ); 1576: a04 = b4 ^((~b0)& b1 ); 1577: 1578: b3 = ROL64((a30^d0), 41); 1579: b4 = ROL64((a41^d1), 2); 1580: b0 = ROL64((a02^d2), 62); 1581: b1 = ROL64((a13^d3), 55); 1582: b2 = ROL64((a24^d4), 39); 1583: a30 = b0 ^((~b1)& b2 ); 1584: a41 = b1 ^((~b2)& b3 ); 1585: a02 = b2 ^((~b3)& b4 ); 1586: a13 = b3 ^((~b4)& b0 ); 1587: a24 = b4 ^((~b0)& b1 ); 1588: 1589: c0 = a00^a20^a40^a10^a30; 1590: c1 = a11^a31^a01^a21^a41; 1591: c2 = a22^a42^a12^a32^a02; 1592: c3 = a33^a03^a23^a43^a13; 1593: c4 = a44^a14^a34^a04^a24; 1594: d0 = c4^ROL64(c1, 1); 1595: d1 = c0^ROL64(c2, 1); 1596: d2 = c1^ROL64(c3, 1); 1597: d3 = c2^ROL64(c4, 1); 1598: d4 = c3^ROL64(c0, 1); 1599: 1600: b0 = (a00^d0); 1601: b1 = ROL64((a31^d1), 44); 1602: b2 = ROL64((a12^d2), 43); 1603: b3 = ROL64((a43^d3), 21); 1604: b4 = ROL64((a24^d4), 14); 1605: a00 = b0 ^((~b1)& b2 ); 1606: a00 ^= RC[i+1]; 1607: a31 = b1 ^((~b2)& b3 ); 1608: a12 = b2 ^((~b3)& b4 ); 1609: a43 = b3 ^((~b4)& b0 ); 1610: a24 = b4 ^((~b0)& b1 ); 1611: 1612: b2 = ROL64((a40^d0), 3); 1613: b3 = ROL64((a21^d1), 45); 1614: b4 = ROL64((a02^d2), 61); 1615: b0 = ROL64((a33^d3), 28); 1616: b1 = ROL64((a14^d4), 20); 1617: a40 = b0 ^((~b1)& b2 ); 1618: a21 = b1 ^((~b2)& b3 ); 1619: a02 = b2 ^((~b3)& b4 ); 1620: a33 = b3 ^((~b4)& b0 ); 1621: a14 = b4 ^((~b0)& b1 ); 1622: 1623: b4 = ROL64((a30^d0), 18); 1624: b0 = ROL64((a11^d1), 1); 1625: b1 = ROL64((a42^d2), 6); 1626: b2 = ROL64((a23^d3), 25); 1627: b3 = ROL64((a04^d4), 8); 1628: a30 = b0 ^((~b1)& b2 ); 1629: a11 = b1 ^((~b2)& b3 ); 1630: a42 = b2 ^((~b3)& b4 ); 1631: a23 = b3 ^((~b4)& b0 ); 1632: a04 = b4 ^((~b0)& b1 ); 1633: 1634: b1 = ROL64((a20^d0), 36); 1635: b2 = ROL64((a01^d1), 10); 1636: b3 = ROL64((a32^d2), 15); 1637: b4 = ROL64((a13^d3), 56); 1638: b0 = ROL64((a44^d4), 27); 1639: a20 = b0 ^((~b1)& b2 ); 1640: a01 = b1 ^((~b2)& b3 ); 1641: a32 = b2 ^((~b3)& b4 ); 1642: a13 = b3 ^((~b4)& b0 ); 1643: a44 = b4 ^((~b0)& b1 ); 1644: 1645: b3 = ROL64((a10^d0), 41); 1646: b4 = ROL64((a41^d1), 2); 1647: b0 = ROL64((a22^d2), 62); 1648: b1 = ROL64((a03^d3), 55); 1649: b2 = ROL64((a34^d4), 39); 1650: a10 = b0 ^((~b1)& b2 ); 1651: a41 = b1 ^((~b2)& b3 ); 1652: a22 = b2 ^((~b3)& b4 ); 1653: a03 = b3 ^((~b4)& b0 ); 1654: a34 = b4 ^((~b0)& b1 ); 1655: 1656: c0 = a00^a40^a30^a20^a10; 1657: c1 = a31^a21^a11^a01^a41; 1658: c2 = a12^a02^a42^a32^a22; 1659: c3 = a43^a33^a23^a13^a03; 1660: c4 = a24^a14^a04^a44^a34; 1661: d0 = c4^ROL64(c1, 1); 1662: d1 = c0^ROL64(c2, 1); 1663: d2 = c1^ROL64(c3, 1); 1664: d3 = c2^ROL64(c4, 1); 1665: d4 = c3^ROL64(c0, 1); 1666: 1667: b0 = (a00^d0); 1668: b1 = ROL64((a21^d1), 44); 1669: b2 = ROL64((a42^d2), 43); 1670: b3 = ROL64((a13^d3), 21); 1671: b4 = ROL64((a34^d4), 14); 1672: a00 = b0 ^((~b1)& b2 ); 1673: a00 ^= RC[i+2]; 1674: a21 = b1 ^((~b2)& b3 ); 1675: a42 = b2 ^((~b3)& b4 ); 1676: a13 = b3 ^((~b4)& b0 ); 1677: a34 = b4 ^((~b0)& b1 ); 1678: 1679: b2 = ROL64((a30^d0), 3); 1680: b3 = ROL64((a01^d1), 45); 1681: b4 = ROL64((a22^d2), 61); 1682: b0 = ROL64((a43^d3), 28); 1683: b1 = ROL64((a14^d4), 20); 1684: a30 = b0 ^((~b1)& b2 ); 1685: a01 = b1 ^((~b2)& b3 ); 1686: a22 = b2 ^((~b3)& b4 ); 1687: a43 = b3 ^((~b4)& b0 ); 1688: a14 = b4 ^((~b0)& b1 ); 1689: 1690: b4 = ROL64((a10^d0), 18); 1691: b0 = ROL64((a31^d1), 1); 1692: b1 = ROL64((a02^d2), 6); 1693: b2 = ROL64((a23^d3), 25); 1694: b3 = ROL64((a44^d4), 8); 1695: a10 = b0 ^((~b1)& b2 ); 1696: a31 = b1 ^((~b2)& b3 ); 1697: a02 = b2 ^((~b3)& b4 ); 1698: a23 = b3 ^((~b4)& b0 ); 1699: a44 = b4 ^((~b0)& b1 ); 1700: 1701: b1 = ROL64((a40^d0), 36); 1702: b2 = ROL64((a11^d1), 10); 1703: b3 = ROL64((a32^d2), 15); 1704: b4 = ROL64((a03^d3), 56); 1705: b0 = ROL64((a24^d4), 27); 1706: a40 = b0 ^((~b1)& b2 ); 1707: a11 = b1 ^((~b2)& b3 ); 1708: a32 = b2 ^((~b3)& b4 ); 1709: a03 = b3 ^((~b4)& b0 ); 1710: a24 = b4 ^((~b0)& b1 ); 1711: 1712: b3 = ROL64((a20^d0), 41); 1713: b4 = ROL64((a41^d1), 2); 1714: b0 = ROL64((a12^d2), 62); 1715: b1 = ROL64((a33^d3), 55); 1716: b2 = ROL64((a04^d4), 39); 1717: a20 = b0 ^((~b1)& b2 ); 1718: a41 = b1 ^((~b2)& b3 ); 1719: a12 = b2 ^((~b3)& b4 ); 1720: a33 = b3 ^((~b4)& b0 ); 1721: a04 = b4 ^((~b0)& b1 ); 1722: 1723: c0 = a00^a30^a10^a40^a20; 1724: c1 = a21^a01^a31^a11^a41; 1725: c2 = a42^a22^a02^a32^a12; 1726: c3 = a13^a43^a23^a03^a33; 1727: c4 = a34^a14^a44^a24^a04; 1728: d0 = c4^ROL64(c1, 1); 1729: d1 = c0^ROL64(c2, 1); 1730: d2 = c1^ROL64(c3, 1); 1731: d3 = c2^ROL64(c4, 1); 1732: d4 = c3^ROL64(c0, 1); 1733: 1734: b0 = (a00^d0); 1735: b1 = ROL64((a01^d1), 44); 1736: b2 = ROL64((a02^d2), 43); 1737: b3 = ROL64((a03^d3), 21); 1738: b4 = ROL64((a04^d4), 14); 1739: a00 = b0 ^((~b1)& b2 ); 1740: a00 ^= RC[i+3]; 1741: a01 = b1 ^((~b2)& b3 ); 1742: a02 = b2 ^((~b3)& b4 ); 1743: a03 = b3 ^((~b4)& b0 ); 1744: a04 = b4 ^((~b0)& b1 ); 1745: 1746: b2 = ROL64((a10^d0), 3); 1747: b3 = ROL64((a11^d1), 45); 1748: b4 = ROL64((a12^d2), 61); 1749: b0 = ROL64((a13^d3), 28); 1750: b1 = ROL64((a14^d4), 20); 1751: a10 = b0 ^((~b1)& b2 ); 1752: a11 = b1 ^((~b2)& b3 ); 1753: a12 = b2 ^((~b3)& b4 ); 1754: a13 = b3 ^((~b4)& b0 ); 1755: a14 = b4 ^((~b0)& b1 ); 1756: 1757: b4 = ROL64((a20^d0), 18); 1758: b0 = ROL64((a21^d1), 1); 1759: b1 = ROL64((a22^d2), 6); 1760: b2 = ROL64((a23^d3), 25); 1761: b3 = ROL64((a24^d4), 8); 1762: a20 = b0 ^((~b1)& b2 ); 1763: a21 = b1 ^((~b2)& b3 ); 1764: a22 = b2 ^((~b3)& b4 ); 1765: a23 = b3 ^((~b4)& b0 ); 1766: a24 = b4 ^((~b0)& b1 ); 1767: 1768: b1 = ROL64((a30^d0), 36); 1769: b2 = ROL64((a31^d1), 10); 1770: b3 = ROL64((a32^d2), 15); 1771: b4 = ROL64((a33^d3), 56); 1772: b0 = ROL64((a34^d4), 27); 1773: a30 = b0 ^((~b1)& b2 ); 1774: a31 = b1 ^((~b2)& b3 ); 1775: a32 = b2 ^((~b3)& b4 ); 1776: a33 = b3 ^((~b4)& b0 ); 1777: a34 = b4 ^((~b0)& b1 ); 1778: 1779: b3 = ROL64((a40^d0), 41); 1780: b4 = ROL64((a41^d1), 2); 1781: b0 = ROL64((a42^d2), 62); 1782: b1 = ROL64((a43^d3), 55); 1783: b2 = ROL64((a44^d4), 39); 1784: a40 = b0 ^((~b1)& b2 ); 1785: a41 = b1 ^((~b2)& b3 ); 1786: a42 = b2 ^((~b3)& b4 ); 1787: a43 = b3 ^((~b4)& b0 ); 1788: a44 = b4 ^((~b0)& b1 ); 1789: } 1790: } 1791: 1792: /* 1793: ** Initialize a new hash. iSize determines the size of the hash 1794: ** in bits and should be one of 224, 256, 384, or 512. Or iSize 1795: ** can be zero to use the default hash size of 256 bits. 1796: */ 1797: static void SHA3Init(SHA3Context *p, int iSize){ 1798: memset(p, 0, sizeof(*p)); 1799: if( iSize>=128 && iSize<=512 ){ 1800: p->nRate = (1600 - ((iSize + 31)&~31)*2)/8; 1801: }else{ 1802: p->nRate = (1600 - 2*256)/8; 1803: } 1804: #if SHA3_BYTEORDER==1234 1805: /* Known to be little-endian at compile-time. No-op */ 1806: #elif SHA3_BYTEORDER==4321 1807: p->ixMask = 7; /* Big-endian */ 1808: #else 1809: { 1810: static unsigned int one = 1; 1811: if( 1==*(unsigned char*)&one ){ 1812: /* Little endian. No byte swapping. */ 1813: p->ixMask = 0; 1814: }else{ 1815: /* Big endian. Byte swap. */ 1816: p->ixMask = 7; 1817: } 1818: } 1819: #endif 1820: } 1821: 1822: /* 1823: ** Make consecutive calls to the SHA3Update function to add new content 1824: ** to the hash 1825: */ 1826: static void SHA3Update( 1827: SHA3Context *p, 1828: const unsigned char *aData, 1829: unsigned int nData 1830: ){ 1831: unsigned int i = 0; 1832: #if SHA3_BYTEORDER==1234 1833: if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){ 1834: for(; i+7<nData; i+=8){ 1835: p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i]; 1836: p->nLoaded += 8; 1837: if( p->nLoaded>=p->nRate ){ 1838: KeccakF1600Step(p); 1839: p->nLoaded = 0; 1.2 misho 1840: } 1841: } 1.5 misho 1842: } 1843: #endif 1844: for(; i<nData; i++){ 1845: #if SHA3_BYTEORDER==1234 1846: p->u.x[p->nLoaded] ^= aData[i]; 1847: #elif SHA3_BYTEORDER==4321 1848: p->u.x[p->nLoaded^0x07] ^= aData[i]; 1849: #else 1850: p->u.x[p->nLoaded^p->ixMask] ^= aData[i]; 1851: #endif 1852: p->nLoaded++; 1853: if( p->nLoaded==p->nRate ){ 1854: KeccakF1600Step(p); 1855: p->nLoaded = 0; 1856: } 1857: } 1858: } 1859: 1860: /* 1861: ** After all content has been added, invoke SHA3Final() to compute 1862: ** the final hash. The function returns a pointer to the binary 1863: ** hash value. 1864: */ 1865: static unsigned char *SHA3Final(SHA3Context *p){ 1866: unsigned int i; 1867: if( p->nLoaded==p->nRate-1 ){ 1868: const unsigned char c1 = 0x86; 1869: SHA3Update(p, &c1, 1); 1870: }else{ 1871: const unsigned char c2 = 0x06; 1872: const unsigned char c3 = 0x80; 1873: SHA3Update(p, &c2, 1); 1874: p->nLoaded = p->nRate - 1; 1875: SHA3Update(p, &c3, 1); 1876: } 1877: for(i=0; i<p->nRate; i++){ 1878: p->u.x[i+p->nRate] = p->u.x[i^p->ixMask]; 1879: } 1880: return &p->u.x[p->nRate]; 1881: } 1882: /* End of the hashing logic 1883: *****************************************************************************/ 1884: 1885: /* 1886: ** Implementation of the sha3(X,SIZE) function. 1887: ** 1888: ** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default 1889: ** size is 256. If X is a BLOB, it is hashed as is. 1890: ** For all other non-NULL types of input, X is converted into a UTF-8 string 1891: ** and the string is hashed without the trailing 0x00 terminator. The hash 1892: ** of a NULL value is NULL. 1893: */ 1894: static void sha3Func( 1895: sqlite3_context *context, 1896: int argc, 1897: sqlite3_value **argv 1898: ){ 1899: SHA3Context cx; 1900: int eType = sqlite3_value_type(argv[0]); 1901: int nByte = sqlite3_value_bytes(argv[0]); 1902: int iSize; 1903: if( argc==1 ){ 1904: iSize = 256; 1905: }else{ 1906: iSize = sqlite3_value_int(argv[1]); 1907: if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ 1908: sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " 1909: "384 512", -1); 1910: return; 1911: } 1912: } 1913: if( eType==SQLITE_NULL ) return; 1914: SHA3Init(&cx, iSize); 1915: if( eType==SQLITE_BLOB ){ 1916: SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte); 1917: }else{ 1918: SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte); 1919: } 1920: sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); 1921: } 1922: 1923: /* Compute a string using sqlite3_vsnprintf() with a maximum length 1924: ** of 50 bytes and add it to the hash. 1925: */ 1926: static void hash_step_vformat( 1927: SHA3Context *p, /* Add content to this context */ 1928: const char *zFormat, 1929: ... 1930: ){ 1931: va_list ap; 1932: int n; 1933: char zBuf[50]; 1934: va_start(ap, zFormat); 1935: sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap); 1936: va_end(ap); 1937: n = (int)strlen(zBuf); 1938: SHA3Update(p, (unsigned char*)zBuf, n); 1939: } 1940: 1941: /* 1942: ** Implementation of the sha3_query(SQL,SIZE) function. 1943: ** 1944: ** This function compiles and runs the SQL statement(s) given in the 1945: ** argument. The results are hashed using a SIZE-bit SHA3. The default 1946: ** size is 256. 1947: ** 1948: ** The format of the byte stream that is hashed is summarized as follows: 1949: ** 1950: ** S<n>:<sql> 1951: ** R 1952: ** N 1953: ** I<int> 1954: ** F<ieee-float> 1955: ** B<size>:<bytes> 1956: ** T<size>:<text> 1957: ** 1958: ** <sql> is the original SQL text for each statement run and <n> is 1959: ** the size of that text. The SQL text is UTF-8. A single R character 1960: ** occurs before the start of each row. N means a NULL value. 1961: ** I mean an 8-byte little-endian integer <int>. F is a floating point 1962: ** number with an 8-byte little-endian IEEE floating point value <ieee-float>. 1963: ** B means blobs of <size> bytes. T means text rendered as <size> 1964: ** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII 1965: ** text integers. 1966: ** 1967: ** For each SQL statement in the X input, there is one S segment. Each 1968: ** S segment is followed by zero or more R segments, one for each row in the 1969: ** result set. After each R, there are one or more N, I, F, B, or T segments, 1970: ** one for each column in the result set. Segments are concatentated directly 1971: ** with no delimiters of any kind. 1972: */ 1973: static void sha3QueryFunc( 1974: sqlite3_context *context, 1975: int argc, 1976: sqlite3_value **argv 1977: ){ 1978: sqlite3 *db = sqlite3_context_db_handle(context); 1979: const char *zSql = (const char*)sqlite3_value_text(argv[0]); 1980: sqlite3_stmt *pStmt = 0; 1981: int nCol; /* Number of columns in the result set */ 1982: int i; /* Loop counter */ 1983: int rc; 1984: int n; 1985: const char *z; 1986: SHA3Context cx; 1987: int iSize; 1988: 1989: if( argc==1 ){ 1990: iSize = 256; 1991: }else{ 1992: iSize = sqlite3_value_int(argv[1]); 1993: if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ 1994: sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " 1995: "384 512", -1); 1996: return; 1997: } 1998: } 1999: if( zSql==0 ) return; 2000: SHA3Init(&cx, iSize); 2001: while( zSql[0] ){ 2002: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql); 2003: if( rc ){ 2004: char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s", 2005: zSql, sqlite3_errmsg(db)); 2006: sqlite3_finalize(pStmt); 2007: sqlite3_result_error(context, zMsg, -1); 2008: sqlite3_free(zMsg); 2009: return; 2010: } 2011: if( !sqlite3_stmt_readonly(pStmt) ){ 2012: char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt)); 2013: sqlite3_finalize(pStmt); 2014: sqlite3_result_error(context, zMsg, -1); 2015: sqlite3_free(zMsg); 2016: return; 2017: } 2018: nCol = sqlite3_column_count(pStmt); 2019: z = sqlite3_sql(pStmt); 1.6 ! misho 2020: if( z ){ ! 2021: n = (int)strlen(z); ! 2022: hash_step_vformat(&cx,"S%d:",n); ! 2023: SHA3Update(&cx,(unsigned char*)z,n); ! 2024: } 1.5 misho 2025: 2026: /* Compute a hash over the result of the query */ 2027: while( SQLITE_ROW==sqlite3_step(pStmt) ){ 2028: SHA3Update(&cx,(const unsigned char*)"R",1); 2029: for(i=0; i<nCol; i++){ 2030: switch( sqlite3_column_type(pStmt,i) ){ 2031: case SQLITE_NULL: { 2032: SHA3Update(&cx, (const unsigned char*)"N",1); 2033: break; 1.2 misho 2034: } 1.5 misho 2035: case SQLITE_INTEGER: { 2036: sqlite3_uint64 u; 2037: int j; 2038: unsigned char x[9]; 2039: sqlite3_int64 v = sqlite3_column_int64(pStmt,i); 2040: memcpy(&u, &v, 8); 2041: for(j=8; j>=1; j--){ 2042: x[j] = u & 0xff; 2043: u >>= 8; 1.3 misho 2044: } 1.5 misho 2045: x[0] = 'I'; 2046: SHA3Update(&cx, x, 9); 2047: break; 1.2 misho 2048: } 1.5 misho 2049: case SQLITE_FLOAT: { 2050: sqlite3_uint64 u; 2051: int j; 2052: unsigned char x[9]; 2053: double r = sqlite3_column_double(pStmt,i); 2054: memcpy(&u, &r, 8); 2055: for(j=8; j>=1; j--){ 2056: x[j] = u & 0xff; 2057: u >>= 8; 1.2 misho 2058: } 1.5 misho 2059: x[0] = 'F'; 2060: SHA3Update(&cx,x,9); 2061: break; 2062: } 2063: case SQLITE_TEXT: { 2064: int n2 = sqlite3_column_bytes(pStmt, i); 2065: const unsigned char *z2 = sqlite3_column_text(pStmt, i); 2066: hash_step_vformat(&cx,"T%d:",n2); 2067: SHA3Update(&cx, z2, n2); 2068: break; 2069: } 2070: case SQLITE_BLOB: { 2071: int n2 = sqlite3_column_bytes(pStmt, i); 2072: const unsigned char *z2 = sqlite3_column_blob(pStmt, i); 2073: hash_step_vformat(&cx,"B%d:",n2); 2074: SHA3Update(&cx, z2, n2); 2075: break; 1.2 misho 2076: } 2077: } 2078: } 1.5 misho 2079: } 2080: sqlite3_finalize(pStmt); 2081: } 2082: sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); 2083: } 2084: 2085: 2086: #ifdef _WIN32 2087: 2088: #endif 2089: int sqlite3_shathree_init( 2090: sqlite3 *db, 2091: char **pzErrMsg, 2092: const sqlite3_api_routines *pApi 2093: ){ 2094: int rc = SQLITE_OK; 2095: SQLITE_EXTENSION_INIT2(pApi); 2096: (void)pzErrMsg; /* Unused parameter */ 2097: rc = sqlite3_create_function(db, "sha3", 1, 2098: SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, 2099: 0, sha3Func, 0, 0); 2100: if( rc==SQLITE_OK ){ 2101: rc = sqlite3_create_function(db, "sha3", 2, 2102: SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, 2103: 0, sha3Func, 0, 0); 2104: } 2105: if( rc==SQLITE_OK ){ 2106: rc = sqlite3_create_function(db, "sha3_query", 1, 2107: SQLITE_UTF8 | SQLITE_DIRECTONLY, 2108: 0, sha3QueryFunc, 0, 0); 2109: } 2110: if( rc==SQLITE_OK ){ 2111: rc = sqlite3_create_function(db, "sha3_query", 2, 2112: SQLITE_UTF8 | SQLITE_DIRECTONLY, 2113: 0, sha3QueryFunc, 0, 0); 2114: } 2115: return rc; 2116: } 2117: 2118: /************************* End ../ext/misc/shathree.c ********************/ 2119: /************************* Begin ../ext/misc/fileio.c ******************/ 2120: /* 2121: ** 2014-06-13 2122: ** 2123: ** The author disclaims copyright to this source code. In place of 2124: ** a legal notice, here is a blessing: 2125: ** 2126: ** May you do good and not evil. 2127: ** May you find forgiveness for yourself and forgive others. 2128: ** May you share freely, never taking more than you give. 2129: ** 2130: ****************************************************************************** 2131: ** 2132: ** This SQLite extension implements SQL functions readfile() and 2133: ** writefile(), and eponymous virtual type "fsdir". 2134: ** 2135: ** WRITEFILE(FILE, DATA [, MODE [, MTIME]]): 2136: ** 2137: ** If neither of the optional arguments is present, then this UDF 2138: ** function writes blob DATA to file FILE. If successful, the number 2139: ** of bytes written is returned. If an error occurs, NULL is returned. 2140: ** 2141: ** If the first option argument - MODE - is present, then it must 2142: ** be passed an integer value that corresponds to a POSIX mode 2143: ** value (file type + permissions, as returned in the stat.st_mode 2144: ** field by the stat() system call). Three types of files may 2145: ** be written/created: 2146: ** 2147: ** regular files: (mode & 0170000)==0100000 2148: ** symbolic links: (mode & 0170000)==0120000 2149: ** directories: (mode & 0170000)==0040000 2150: ** 2151: ** For a directory, the DATA is ignored. For a symbolic link, it is 2152: ** interpreted as text and used as the target of the link. For a 2153: ** regular file, it is interpreted as a blob and written into the 2154: ** named file. Regardless of the type of file, its permissions are 2155: ** set to (mode & 0777) before returning. 2156: ** 2157: ** If the optional MTIME argument is present, then it is interpreted 2158: ** as an integer - the number of seconds since the unix epoch. The 2159: ** modification-time of the target file is set to this value before 2160: ** returning. 2161: ** 2162: ** If three or more arguments are passed to this function and an 2163: ** error is encountered, an exception is raised. 2164: ** 2165: ** READFILE(FILE): 2166: ** 2167: ** Read and return the contents of file FILE (type blob) from disk. 2168: ** 2169: ** FSDIR: 2170: ** 2171: ** Used as follows: 2172: ** 2173: ** SELECT * FROM fsdir($path [, $dir]); 2174: ** 2175: ** Parameter $path is an absolute or relative pathname. If the file that it 2176: ** refers to does not exist, it is an error. If the path refers to a regular 2177: ** file or symbolic link, it returns a single row. Or, if the path refers 2178: ** to a directory, it returns one row for the directory, and one row for each 2179: ** file within the hierarchy rooted at $path. 2180: ** 2181: ** Each row has the following columns: 2182: ** 2183: ** name: Path to file or directory (text value). 2184: ** mode: Value of stat.st_mode for directory entry (an integer). 2185: ** mtime: Value of stat.st_mtime for directory entry (an integer). 2186: ** data: For a regular file, a blob containing the file data. For a 2187: ** symlink, a text value containing the text of the link. For a 2188: ** directory, NULL. 2189: ** 2190: ** If a non-NULL value is specified for the optional $dir parameter and 2191: ** $path is a relative path, then $path is interpreted relative to $dir. 2192: ** And the paths returned in the "name" column of the table are also 2193: ** relative to directory $dir. 2194: */ 2195: /* #include "sqlite3ext.h" */ 2196: SQLITE_EXTENSION_INIT1 2197: #include <stdio.h> 2198: #include <string.h> 2199: #include <assert.h> 2200: 2201: #include <sys/types.h> 2202: #include <sys/stat.h> 2203: #include <fcntl.h> 2204: #if !defined(_WIN32) && !defined(WIN32) 2205: # include <unistd.h> 2206: # include <dirent.h> 2207: # include <utime.h> 2208: # include <sys/time.h> 2209: #else 2210: # include "windows.h" 2211: # include <io.h> 2212: # include <direct.h> 2213: /* # include "test_windirent.h" */ 2214: # define dirent DIRENT 2215: # ifndef chmod 2216: # define chmod _chmod 2217: # endif 2218: # ifndef stat 2219: # define stat _stat 2220: # endif 2221: # define mkdir(path,mode) _mkdir(path) 2222: # define lstat(path,buf) stat(path,buf) 2223: #endif 2224: #include <time.h> 2225: #include <errno.h> 2226: 2227: 2228: /* 2229: ** Structure of the fsdir() table-valued function 2230: */ 2231: /* 0 1 2 3 4 5 */ 2232: #define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)" 2233: #define FSDIR_COLUMN_NAME 0 /* Name of the file */ 2234: #define FSDIR_COLUMN_MODE 1 /* Access mode */ 2235: #define FSDIR_COLUMN_MTIME 2 /* Last modification time */ 2236: #define FSDIR_COLUMN_DATA 3 /* File content */ 2237: #define FSDIR_COLUMN_PATH 4 /* Path to top of search */ 2238: #define FSDIR_COLUMN_DIR 5 /* Path is relative to this directory */ 2239: 2240: 2241: /* 2242: ** Set the result stored by context ctx to a blob containing the 2243: ** contents of file zName. Or, leave the result unchanged (NULL) 2244: ** if the file does not exist or is unreadable. 2245: ** 2246: ** If the file exceeds the SQLite blob size limit, through an 2247: ** SQLITE_TOOBIG error. 2248: ** 2249: ** Throw an SQLITE_IOERR if there are difficulties pulling the file 2250: ** off of disk. 2251: */ 2252: static void readFileContents(sqlite3_context *ctx, const char *zName){ 2253: FILE *in; 2254: sqlite3_int64 nIn; 2255: void *pBuf; 2256: sqlite3 *db; 2257: int mxBlob; 2258: 2259: in = fopen(zName, "rb"); 2260: if( in==0 ){ 2261: /* File does not exist or is unreadable. Leave the result set to NULL. */ 2262: return; 2263: } 2264: fseek(in, 0, SEEK_END); 2265: nIn = ftell(in); 2266: rewind(in); 2267: db = sqlite3_context_db_handle(ctx); 2268: mxBlob = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1); 2269: if( nIn>mxBlob ){ 2270: sqlite3_result_error_code(ctx, SQLITE_TOOBIG); 2271: fclose(in); 2272: return; 2273: } 2274: pBuf = sqlite3_malloc64( nIn ? nIn : 1 ); 2275: if( pBuf==0 ){ 2276: sqlite3_result_error_nomem(ctx); 2277: fclose(in); 2278: return; 2279: } 2280: if( nIn==(sqlite3_int64)fread(pBuf, 1, (size_t)nIn, in) ){ 2281: sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free); 2282: }else{ 2283: sqlite3_result_error_code(ctx, SQLITE_IOERR); 2284: sqlite3_free(pBuf); 2285: } 2286: fclose(in); 2287: } 2288: 2289: /* 2290: ** Implementation of the "readfile(X)" SQL function. The entire content 2291: ** of the file named X is read and returned as a BLOB. NULL is returned 2292: ** if the file does not exist or is unreadable. 2293: */ 2294: static void readfileFunc( 2295: sqlite3_context *context, 2296: int argc, 2297: sqlite3_value **argv 2298: ){ 2299: const char *zName; 2300: (void)(argc); /* Unused parameter */ 2301: zName = (const char*)sqlite3_value_text(argv[0]); 2302: if( zName==0 ) return; 2303: readFileContents(context, zName); 2304: } 2305: 2306: /* 2307: ** Set the error message contained in context ctx to the results of 2308: ** vprintf(zFmt, ...). 2309: */ 2310: static void ctxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){ 2311: char *zMsg = 0; 2312: va_list ap; 2313: va_start(ap, zFmt); 2314: zMsg = sqlite3_vmprintf(zFmt, ap); 2315: sqlite3_result_error(ctx, zMsg, -1); 2316: sqlite3_free(zMsg); 2317: va_end(ap); 2318: } 2319: 2320: #if defined(_WIN32) 2321: /* 2322: ** This function is designed to convert a Win32 FILETIME structure into the 2323: ** number of seconds since the Unix Epoch (1970-01-01 00:00:00 UTC). 2324: */ 2325: static sqlite3_uint64 fileTimeToUnixTime( 2326: LPFILETIME pFileTime 2327: ){ 2328: SYSTEMTIME epochSystemTime; 2329: ULARGE_INTEGER epochIntervals; 2330: FILETIME epochFileTime; 2331: ULARGE_INTEGER fileIntervals; 2332: 2333: memset(&epochSystemTime, 0, sizeof(SYSTEMTIME)); 2334: epochSystemTime.wYear = 1970; 2335: epochSystemTime.wMonth = 1; 2336: epochSystemTime.wDay = 1; 2337: SystemTimeToFileTime(&epochSystemTime, &epochFileTime); 2338: epochIntervals.LowPart = epochFileTime.dwLowDateTime; 2339: epochIntervals.HighPart = epochFileTime.dwHighDateTime; 2340: 2341: fileIntervals.LowPart = pFileTime->dwLowDateTime; 2342: fileIntervals.HighPart = pFileTime->dwHighDateTime; 2343: 2344: return (fileIntervals.QuadPart - epochIntervals.QuadPart) / 10000000; 2345: } 2346: 2347: /* 2348: ** This function attempts to normalize the time values found in the stat() 2349: ** buffer to UTC. This is necessary on Win32, where the runtime library 2350: ** appears to return these values as local times. 2351: */ 2352: static void statTimesToUtc( 2353: const char *zPath, 2354: struct stat *pStatBuf 2355: ){ 2356: HANDLE hFindFile; 2357: WIN32_FIND_DATAW fd; 2358: LPWSTR zUnicodeName; 2359: extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); 2360: zUnicodeName = sqlite3_win32_utf8_to_unicode(zPath); 2361: if( zUnicodeName ){ 2362: memset(&fd, 0, sizeof(WIN32_FIND_DATAW)); 2363: hFindFile = FindFirstFileW(zUnicodeName, &fd); 2364: if( hFindFile!=NULL ){ 2365: pStatBuf->st_ctime = (time_t)fileTimeToUnixTime(&fd.ftCreationTime); 2366: pStatBuf->st_atime = (time_t)fileTimeToUnixTime(&fd.ftLastAccessTime); 2367: pStatBuf->st_mtime = (time_t)fileTimeToUnixTime(&fd.ftLastWriteTime); 2368: FindClose(hFindFile); 2369: } 2370: sqlite3_free(zUnicodeName); 2371: } 2372: } 2373: #endif 2374: 2375: /* 2376: ** This function is used in place of stat(). On Windows, special handling 2377: ** is required in order for the included time to be returned as UTC. On all 2378: ** other systems, this function simply calls stat(). 2379: */ 2380: static int fileStat( 2381: const char *zPath, 2382: struct stat *pStatBuf 2383: ){ 2384: #if defined(_WIN32) 2385: int rc = stat(zPath, pStatBuf); 2386: if( rc==0 ) statTimesToUtc(zPath, pStatBuf); 2387: return rc; 2388: #else 2389: return stat(zPath, pStatBuf); 2390: #endif 2391: } 2392: 2393: /* 2394: ** This function is used in place of lstat(). On Windows, special handling 2395: ** is required in order for the included time to be returned as UTC. On all 2396: ** other systems, this function simply calls lstat(). 2397: */ 2398: static int fileLinkStat( 2399: const char *zPath, 2400: struct stat *pStatBuf 2401: ){ 2402: #if defined(_WIN32) 2403: int rc = lstat(zPath, pStatBuf); 2404: if( rc==0 ) statTimesToUtc(zPath, pStatBuf); 2405: return rc; 2406: #else 2407: return lstat(zPath, pStatBuf); 2408: #endif 2409: } 2410: 2411: /* 2412: ** Argument zFile is the name of a file that will be created and/or written 2413: ** by SQL function writefile(). This function ensures that the directory 2414: ** zFile will be written to exists, creating it if required. The permissions 2415: ** for any path components created by this function are set in accordance 2416: ** with the current umask. 2417: ** 2418: ** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise, 2419: ** SQLITE_OK is returned if the directory is successfully created, or 2420: ** SQLITE_ERROR otherwise. 2421: */ 2422: static int makeDirectory( 2423: const char *zFile 2424: ){ 2425: char *zCopy = sqlite3_mprintf("%s", zFile); 2426: int rc = SQLITE_OK; 2427: 2428: if( zCopy==0 ){ 2429: rc = SQLITE_NOMEM; 2430: }else{ 2431: int nCopy = (int)strlen(zCopy); 2432: int i = 1; 2433: 2434: while( rc==SQLITE_OK ){ 2435: struct stat sStat; 2436: int rc2; 2437: 2438: for(; zCopy[i]!='/' && i<nCopy; i++); 2439: if( i==nCopy ) break; 2440: zCopy[i] = '\0'; 2441: 2442: rc2 = fileStat(zCopy, &sStat); 2443: if( rc2!=0 ){ 2444: if( mkdir(zCopy, 0777) ) rc = SQLITE_ERROR; 2445: }else{ 2446: if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR; 2447: } 2448: zCopy[i] = '/'; 2449: i++; 2450: } 2451: 2452: sqlite3_free(zCopy); 2453: } 2454: 2455: return rc; 2456: } 2457: 2458: /* 2459: ** This function does the work for the writefile() UDF. Refer to 2460: ** header comments at the top of this file for details. 2461: */ 2462: static int writeFile( 2463: sqlite3_context *pCtx, /* Context to return bytes written in */ 2464: const char *zFile, /* File to write */ 2465: sqlite3_value *pData, /* Data to write */ 2466: mode_t mode, /* MODE parameter passed to writefile() */ 2467: sqlite3_int64 mtime /* MTIME parameter (or -1 to not set time) */ 2468: ){ 2469: #if !defined(_WIN32) && !defined(WIN32) 2470: if( S_ISLNK(mode) ){ 2471: const char *zTo = (const char*)sqlite3_value_text(pData); 2472: if( symlink(zTo, zFile)<0 ) return 1; 2473: }else 2474: #endif 2475: { 2476: if( S_ISDIR(mode) ){ 2477: if( mkdir(zFile, mode) ){ 2478: /* The mkdir() call to create the directory failed. This might not 2479: ** be an error though - if there is already a directory at the same 2480: ** path and either the permissions already match or can be changed 2481: ** to do so using chmod(), it is not an error. */ 2482: struct stat sStat; 2483: if( errno!=EEXIST 2484: || 0!=fileStat(zFile, &sStat) 2485: || !S_ISDIR(sStat.st_mode) 2486: || ((sStat.st_mode&0777)!=(mode&0777) && 0!=chmod(zFile, mode&0777)) 2487: ){ 2488: return 1; 1.2 misho 2489: } 1.5 misho 2490: } 2491: }else{ 2492: sqlite3_int64 nWrite = 0; 2493: const char *z; 2494: int rc = 0; 2495: FILE *out = fopen(zFile, "wb"); 2496: if( out==0 ) return 1; 2497: z = (const char*)sqlite3_value_blob(pData); 2498: if( z ){ 2499: sqlite3_int64 n = fwrite(z, 1, sqlite3_value_bytes(pData), out); 2500: nWrite = sqlite3_value_bytes(pData); 2501: if( nWrite!=n ){ 2502: rc = 1; 1.2 misho 2503: } 1.5 misho 2504: } 2505: fclose(out); 2506: if( rc==0 && mode && chmod(zFile, mode & 0777) ){ 2507: rc = 1; 2508: } 2509: if( rc ) return 2; 2510: sqlite3_result_int64(pCtx, nWrite); 2511: } 2512: } 2513: 2514: if( mtime>=0 ){ 2515: #if defined(_WIN32) 2516: #if !SQLITE_OS_WINRT 2517: /* Windows */ 2518: FILETIME lastAccess; 2519: FILETIME lastWrite; 2520: SYSTEMTIME currentTime; 2521: LONGLONG intervals; 2522: HANDLE hFile; 2523: LPWSTR zUnicodeName; 2524: extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); 2525: 2526: GetSystemTime(¤tTime); 2527: SystemTimeToFileTime(¤tTime, &lastAccess); 2528: intervals = Int32x32To64(mtime, 10000000) + 116444736000000000; 2529: lastWrite.dwLowDateTime = (DWORD)intervals; 2530: lastWrite.dwHighDateTime = intervals >> 32; 2531: zUnicodeName = sqlite3_win32_utf8_to_unicode(zFile); 2532: if( zUnicodeName==0 ){ 2533: return 1; 2534: } 2535: hFile = CreateFileW( 2536: zUnicodeName, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, 2537: FILE_FLAG_BACKUP_SEMANTICS, NULL 2538: ); 2539: sqlite3_free(zUnicodeName); 2540: if( hFile!=INVALID_HANDLE_VALUE ){ 2541: BOOL bResult = SetFileTime(hFile, NULL, &lastAccess, &lastWrite); 2542: CloseHandle(hFile); 2543: return !bResult; 2544: }else{ 2545: return 1; 2546: } 2547: #endif 2548: #elif defined(AT_FDCWD) && 0 /* utimensat() is not universally available */ 2549: /* Recent unix */ 2550: struct timespec times[2]; 2551: times[0].tv_nsec = times[1].tv_nsec = 0; 2552: times[0].tv_sec = time(0); 2553: times[1].tv_sec = mtime; 2554: if( utimensat(AT_FDCWD, zFile, times, AT_SYMLINK_NOFOLLOW) ){ 2555: return 1; 2556: } 2557: #else 2558: /* Legacy unix */ 2559: struct timeval times[2]; 2560: times[0].tv_usec = times[1].tv_usec = 0; 2561: times[0].tv_sec = time(0); 2562: times[1].tv_sec = mtime; 2563: if( utimes(zFile, times) ){ 2564: return 1; 2565: } 2566: #endif 2567: } 2568: 2569: return 0; 2570: } 2571: 2572: /* 2573: ** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function. 2574: ** Refer to header comments at the top of this file for details. 2575: */ 2576: static void writefileFunc( 2577: sqlite3_context *context, 2578: int argc, 2579: sqlite3_value **argv 2580: ){ 2581: const char *zFile; 2582: mode_t mode = 0; 2583: int res; 2584: sqlite3_int64 mtime = -1; 2585: 2586: if( argc<2 || argc>4 ){ 2587: sqlite3_result_error(context, 2588: "wrong number of arguments to function writefile()", -1 2589: ); 2590: return; 2591: } 2592: 2593: zFile = (const char*)sqlite3_value_text(argv[0]); 2594: if( zFile==0 ) return; 2595: if( argc>=3 ){ 2596: mode = (mode_t)sqlite3_value_int(argv[2]); 2597: } 2598: if( argc==4 ){ 2599: mtime = sqlite3_value_int64(argv[3]); 2600: } 2601: 2602: res = writeFile(context, zFile, argv[1], mode, mtime); 2603: if( res==1 && errno==ENOENT ){ 2604: if( makeDirectory(zFile)==SQLITE_OK ){ 2605: res = writeFile(context, zFile, argv[1], mode, mtime); 2606: } 2607: } 2608: 2609: if( argc>2 && res!=0 ){ 2610: if( S_ISLNK(mode) ){ 2611: ctxErrorMsg(context, "failed to create symlink: %s", zFile); 2612: }else if( S_ISDIR(mode) ){ 2613: ctxErrorMsg(context, "failed to create directory: %s", zFile); 2614: }else{ 2615: ctxErrorMsg(context, "failed to write file: %s", zFile); 2616: } 2617: } 2618: } 2619: 2620: /* 2621: ** SQL function: lsmode(MODE) 2622: ** 2623: ** Given a numberic st_mode from stat(), convert it into a human-readable 2624: ** text string in the style of "ls -l". 2625: */ 2626: static void lsModeFunc( 2627: sqlite3_context *context, 2628: int argc, 2629: sqlite3_value **argv 2630: ){ 2631: int i; 2632: int iMode = sqlite3_value_int(argv[0]); 2633: char z[16]; 2634: (void)argc; 2635: if( S_ISLNK(iMode) ){ 2636: z[0] = 'l'; 2637: }else if( S_ISREG(iMode) ){ 2638: z[0] = '-'; 2639: }else if( S_ISDIR(iMode) ){ 2640: z[0] = 'd'; 2641: }else{ 2642: z[0] = '?'; 2643: } 2644: for(i=0; i<3; i++){ 2645: int m = (iMode >> ((2-i)*3)); 2646: char *a = &z[1 + i*3]; 2647: a[0] = (m & 0x4) ? 'r' : '-'; 2648: a[1] = (m & 0x2) ? 'w' : '-'; 2649: a[2] = (m & 0x1) ? 'x' : '-'; 2650: } 2651: z[10] = '\0'; 2652: sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT); 2653: } 2654: 2655: #ifndef SQLITE_OMIT_VIRTUALTABLE 2656: 2657: /* 2658: ** Cursor type for recursively iterating through a directory structure. 2659: */ 2660: typedef struct fsdir_cursor fsdir_cursor; 2661: typedef struct FsdirLevel FsdirLevel; 2662: 2663: struct FsdirLevel { 2664: DIR *pDir; /* From opendir() */ 2665: char *zDir; /* Name of directory (nul-terminated) */ 2666: }; 2667: 2668: struct fsdir_cursor { 2669: sqlite3_vtab_cursor base; /* Base class - must be first */ 2670: 2671: int nLvl; /* Number of entries in aLvl[] array */ 2672: int iLvl; /* Index of current entry */ 2673: FsdirLevel *aLvl; /* Hierarchy of directories being traversed */ 2674: 2675: const char *zBase; 2676: int nBase; 2677: 2678: struct stat sStat; /* Current lstat() results */ 2679: char *zPath; /* Path to current entry */ 2680: sqlite3_int64 iRowid; /* Current rowid */ 2681: }; 2682: 2683: typedef struct fsdir_tab fsdir_tab; 2684: struct fsdir_tab { 2685: sqlite3_vtab base; /* Base class - must be first */ 2686: }; 2687: 2688: /* 2689: ** Construct a new fsdir virtual table object. 2690: */ 2691: static int fsdirConnect( 2692: sqlite3 *db, 2693: void *pAux, 2694: int argc, const char *const*argv, 2695: sqlite3_vtab **ppVtab, 2696: char **pzErr 2697: ){ 2698: fsdir_tab *pNew = 0; 2699: int rc; 2700: (void)pAux; 2701: (void)argc; 2702: (void)argv; 2703: (void)pzErr; 2704: rc = sqlite3_declare_vtab(db, "CREATE TABLE x" FSDIR_SCHEMA); 2705: if( rc==SQLITE_OK ){ 2706: pNew = (fsdir_tab*)sqlite3_malloc( sizeof(*pNew) ); 2707: if( pNew==0 ) return SQLITE_NOMEM; 2708: memset(pNew, 0, sizeof(*pNew)); 2709: sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY); 2710: } 2711: *ppVtab = (sqlite3_vtab*)pNew; 2712: return rc; 2713: } 2714: 2715: /* 2716: ** This method is the destructor for fsdir vtab objects. 2717: */ 2718: static int fsdirDisconnect(sqlite3_vtab *pVtab){ 2719: sqlite3_free(pVtab); 2720: return SQLITE_OK; 2721: } 2722: 2723: /* 2724: ** Constructor for a new fsdir_cursor object. 2725: */ 2726: static int fsdirOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 2727: fsdir_cursor *pCur; 2728: (void)p; 2729: pCur = sqlite3_malloc( sizeof(*pCur) ); 2730: if( pCur==0 ) return SQLITE_NOMEM; 2731: memset(pCur, 0, sizeof(*pCur)); 2732: pCur->iLvl = -1; 2733: *ppCursor = &pCur->base; 2734: return SQLITE_OK; 2735: } 2736: 2737: /* 2738: ** Reset a cursor back to the state it was in when first returned 2739: ** by fsdirOpen(). 2740: */ 2741: static void fsdirResetCursor(fsdir_cursor *pCur){ 2742: int i; 2743: for(i=0; i<=pCur->iLvl; i++){ 2744: FsdirLevel *pLvl = &pCur->aLvl[i]; 2745: if( pLvl->pDir ) closedir(pLvl->pDir); 2746: sqlite3_free(pLvl->zDir); 2747: } 2748: sqlite3_free(pCur->zPath); 2749: sqlite3_free(pCur->aLvl); 2750: pCur->aLvl = 0; 2751: pCur->zPath = 0; 2752: pCur->zBase = 0; 2753: pCur->nBase = 0; 2754: pCur->nLvl = 0; 2755: pCur->iLvl = -1; 2756: pCur->iRowid = 1; 2757: } 2758: 2759: /* 2760: ** Destructor for an fsdir_cursor. 2761: */ 2762: static int fsdirClose(sqlite3_vtab_cursor *cur){ 2763: fsdir_cursor *pCur = (fsdir_cursor*)cur; 2764: 2765: fsdirResetCursor(pCur); 2766: sqlite3_free(pCur); 2767: return SQLITE_OK; 2768: } 2769: 2770: /* 2771: ** Set the error message for the virtual table associated with cursor 2772: ** pCur to the results of vprintf(zFmt, ...). 2773: */ 2774: static void fsdirSetErrmsg(fsdir_cursor *pCur, const char *zFmt, ...){ 2775: va_list ap; 2776: va_start(ap, zFmt); 2777: pCur->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap); 2778: va_end(ap); 2779: } 2780: 2781: 2782: /* 2783: ** Advance an fsdir_cursor to its next row of output. 2784: */ 2785: static int fsdirNext(sqlite3_vtab_cursor *cur){ 2786: fsdir_cursor *pCur = (fsdir_cursor*)cur; 2787: mode_t m = pCur->sStat.st_mode; 2788: 2789: pCur->iRowid++; 2790: if( S_ISDIR(m) ){ 2791: /* Descend into this directory */ 2792: int iNew = pCur->iLvl + 1; 2793: FsdirLevel *pLvl; 2794: if( iNew>=pCur->nLvl ){ 2795: int nNew = iNew+1; 2796: sqlite3_int64 nByte = nNew*sizeof(FsdirLevel); 2797: FsdirLevel *aNew = (FsdirLevel*)sqlite3_realloc64(pCur->aLvl, nByte); 2798: if( aNew==0 ) return SQLITE_NOMEM; 2799: memset(&aNew[pCur->nLvl], 0, sizeof(FsdirLevel)*(nNew-pCur->nLvl)); 2800: pCur->aLvl = aNew; 2801: pCur->nLvl = nNew; 2802: } 2803: pCur->iLvl = iNew; 2804: pLvl = &pCur->aLvl[iNew]; 2805: 2806: pLvl->zDir = pCur->zPath; 2807: pCur->zPath = 0; 2808: pLvl->pDir = opendir(pLvl->zDir); 2809: if( pLvl->pDir==0 ){ 2810: fsdirSetErrmsg(pCur, "cannot read directory: %s", pCur->zPath); 2811: return SQLITE_ERROR; 2812: } 2813: } 2814: 2815: while( pCur->iLvl>=0 ){ 2816: FsdirLevel *pLvl = &pCur->aLvl[pCur->iLvl]; 2817: struct dirent *pEntry = readdir(pLvl->pDir); 2818: if( pEntry ){ 2819: if( pEntry->d_name[0]=='.' ){ 2820: if( pEntry->d_name[1]=='.' && pEntry->d_name[2]=='\0' ) continue; 2821: if( pEntry->d_name[1]=='\0' ) continue; 2822: } 2823: sqlite3_free(pCur->zPath); 2824: pCur->zPath = sqlite3_mprintf("%s/%s", pLvl->zDir, pEntry->d_name); 2825: if( pCur->zPath==0 ) return SQLITE_NOMEM; 2826: if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ 2827: fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); 2828: return SQLITE_ERROR; 2829: } 2830: return SQLITE_OK; 2831: } 2832: closedir(pLvl->pDir); 2833: sqlite3_free(pLvl->zDir); 2834: pLvl->pDir = 0; 2835: pLvl->zDir = 0; 2836: pCur->iLvl--; 2837: } 2838: 2839: /* EOF */ 2840: sqlite3_free(pCur->zPath); 2841: pCur->zPath = 0; 2842: return SQLITE_OK; 2843: } 2844: 2845: /* 2846: ** Return values of columns for the row at which the series_cursor 2847: ** is currently pointing. 2848: */ 2849: static int fsdirColumn( 2850: sqlite3_vtab_cursor *cur, /* The cursor */ 2851: sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 2852: int i /* Which column to return */ 2853: ){ 2854: fsdir_cursor *pCur = (fsdir_cursor*)cur; 2855: switch( i ){ 2856: case FSDIR_COLUMN_NAME: { 2857: sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT); 2858: break; 2859: } 2860: 2861: case FSDIR_COLUMN_MODE: 2862: sqlite3_result_int64(ctx, pCur->sStat.st_mode); 2863: break; 2864: 2865: case FSDIR_COLUMN_MTIME: 2866: sqlite3_result_int64(ctx, pCur->sStat.st_mtime); 2867: break; 2868: 2869: case FSDIR_COLUMN_DATA: { 2870: mode_t m = pCur->sStat.st_mode; 2871: if( S_ISDIR(m) ){ 2872: sqlite3_result_null(ctx); 2873: #if !defined(_WIN32) && !defined(WIN32) 2874: }else if( S_ISLNK(m) ){ 2875: char aStatic[64]; 2876: char *aBuf = aStatic; 2877: sqlite3_int64 nBuf = 64; 2878: int n; 2879: 2880: while( 1 ){ 2881: n = readlink(pCur->zPath, aBuf, nBuf); 2882: if( n<nBuf ) break; 2883: if( aBuf!=aStatic ) sqlite3_free(aBuf); 2884: nBuf = nBuf*2; 2885: aBuf = sqlite3_malloc64(nBuf); 2886: if( aBuf==0 ){ 2887: sqlite3_result_error_nomem(ctx); 2888: return SQLITE_NOMEM; 2889: } 2890: } 2891: 2892: sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT); 2893: if( aBuf!=aStatic ) sqlite3_free(aBuf); 2894: #endif 2895: }else{ 2896: readFileContents(ctx, pCur->zPath); 2897: } 2898: } 2899: case FSDIR_COLUMN_PATH: 2900: default: { 2901: /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters. 2902: ** always return their values as NULL */ 2903: break; 2904: } 2905: } 2906: return SQLITE_OK; 2907: } 2908: 2909: /* 2910: ** Return the rowid for the current row. In this implementation, the 2911: ** first row returned is assigned rowid value 1, and each subsequent 2912: ** row a value 1 more than that of the previous. 2913: */ 2914: static int fsdirRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 2915: fsdir_cursor *pCur = (fsdir_cursor*)cur; 2916: *pRowid = pCur->iRowid; 2917: return SQLITE_OK; 2918: } 2919: 2920: /* 2921: ** Return TRUE if the cursor has been moved off of the last 2922: ** row of output. 2923: */ 2924: static int fsdirEof(sqlite3_vtab_cursor *cur){ 2925: fsdir_cursor *pCur = (fsdir_cursor*)cur; 2926: return (pCur->zPath==0); 2927: } 2928: 2929: /* 2930: ** xFilter callback. 2931: ** 2932: ** idxNum==1 PATH parameter only 2933: ** idxNum==2 Both PATH and DIR supplied 2934: */ 2935: static int fsdirFilter( 2936: sqlite3_vtab_cursor *cur, 2937: int idxNum, const char *idxStr, 2938: int argc, sqlite3_value **argv 2939: ){ 2940: const char *zDir = 0; 2941: fsdir_cursor *pCur = (fsdir_cursor*)cur; 2942: (void)idxStr; 2943: fsdirResetCursor(pCur); 2944: 2945: if( idxNum==0 ){ 2946: fsdirSetErrmsg(pCur, "table function fsdir requires an argument"); 2947: return SQLITE_ERROR; 2948: } 2949: 2950: assert( argc==idxNum && (argc==1 || argc==2) ); 2951: zDir = (const char*)sqlite3_value_text(argv[0]); 2952: if( zDir==0 ){ 2953: fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument"); 2954: return SQLITE_ERROR; 2955: } 2956: if( argc==2 ){ 2957: pCur->zBase = (const char*)sqlite3_value_text(argv[1]); 2958: } 2959: if( pCur->zBase ){ 2960: pCur->nBase = (int)strlen(pCur->zBase)+1; 2961: pCur->zPath = sqlite3_mprintf("%s/%s", pCur->zBase, zDir); 2962: }else{ 2963: pCur->zPath = sqlite3_mprintf("%s", zDir); 2964: } 2965: 2966: if( pCur->zPath==0 ){ 2967: return SQLITE_NOMEM; 2968: } 2969: if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ 2970: fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); 2971: return SQLITE_ERROR; 2972: } 2973: 2974: return SQLITE_OK; 2975: } 2976: 2977: /* 2978: ** SQLite will invoke this method one or more times while planning a query 2979: ** that uses the generate_series virtual table. This routine needs to create 2980: ** a query plan for each invocation and compute an estimated cost for that 2981: ** plan. 2982: ** 2983: ** In this implementation idxNum is used to represent the 2984: ** query plan. idxStr is unused. 2985: ** 2986: ** The query plan is represented by values of idxNum: 2987: ** 2988: ** (1) The path value is supplied by argv[0] 2989: ** (2) Path is in argv[0] and dir is in argv[1] 2990: */ 2991: static int fsdirBestIndex( 2992: sqlite3_vtab *tab, 2993: sqlite3_index_info *pIdxInfo 2994: ){ 2995: int i; /* Loop over constraints */ 2996: int idxPath = -1; /* Index in pIdxInfo->aConstraint of PATH= */ 2997: int idxDir = -1; /* Index in pIdxInfo->aConstraint of DIR= */ 2998: int seenPath = 0; /* True if an unusable PATH= constraint is seen */ 2999: int seenDir = 0; /* True if an unusable DIR= constraint is seen */ 3000: const struct sqlite3_index_constraint *pConstraint; 3001: 3002: (void)tab; 3003: pConstraint = pIdxInfo->aConstraint; 3004: for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 3005: if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 3006: switch( pConstraint->iColumn ){ 3007: case FSDIR_COLUMN_PATH: { 3008: if( pConstraint->usable ){ 3009: idxPath = i; 3010: seenPath = 0; 3011: }else if( idxPath<0 ){ 3012: seenPath = 1; 3013: } 3014: break; 3015: } 3016: case FSDIR_COLUMN_DIR: { 3017: if( pConstraint->usable ){ 3018: idxDir = i; 3019: seenDir = 0; 3020: }else if( idxDir<0 ){ 3021: seenDir = 1; 3022: } 3023: break; 3024: } 3025: } 3026: } 3027: if( seenPath || seenDir ){ 3028: /* If input parameters are unusable, disallow this plan */ 3029: return SQLITE_CONSTRAINT; 3030: } 3031: 3032: if( idxPath<0 ){ 3033: pIdxInfo->idxNum = 0; 3034: /* The pIdxInfo->estimatedCost should have been initialized to a huge 3035: ** number. Leave it unchanged. */ 3036: pIdxInfo->estimatedRows = 0x7fffffff; 3037: }else{ 3038: pIdxInfo->aConstraintUsage[idxPath].omit = 1; 3039: pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1; 3040: if( idxDir>=0 ){ 3041: pIdxInfo->aConstraintUsage[idxDir].omit = 1; 3042: pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2; 3043: pIdxInfo->idxNum = 2; 3044: pIdxInfo->estimatedCost = 10.0; 3045: }else{ 3046: pIdxInfo->idxNum = 1; 3047: pIdxInfo->estimatedCost = 100.0; 3048: } 3049: } 3050: 3051: return SQLITE_OK; 3052: } 3053: 3054: /* 3055: ** Register the "fsdir" virtual table. 3056: */ 3057: static int fsdirRegister(sqlite3 *db){ 3058: static sqlite3_module fsdirModule = { 3059: 0, /* iVersion */ 3060: 0, /* xCreate */ 3061: fsdirConnect, /* xConnect */ 3062: fsdirBestIndex, /* xBestIndex */ 3063: fsdirDisconnect, /* xDisconnect */ 3064: 0, /* xDestroy */ 3065: fsdirOpen, /* xOpen - open a cursor */ 3066: fsdirClose, /* xClose - close a cursor */ 3067: fsdirFilter, /* xFilter - configure scan constraints */ 3068: fsdirNext, /* xNext - advance a cursor */ 3069: fsdirEof, /* xEof - check for end of scan */ 3070: fsdirColumn, /* xColumn - read data */ 3071: fsdirRowid, /* xRowid - read data */ 3072: 0, /* xUpdate */ 3073: 0, /* xBegin */ 3074: 0, /* xSync */ 3075: 0, /* xCommit */ 3076: 0, /* xRollback */ 3077: 0, /* xFindMethod */ 3078: 0, /* xRename */ 3079: 0, /* xSavepoint */ 3080: 0, /* xRelease */ 3081: 0, /* xRollbackTo */ 3082: 0, /* xShadowName */ 3083: }; 3084: 3085: int rc = sqlite3_create_module(db, "fsdir", &fsdirModule, 0); 3086: return rc; 3087: } 3088: #else /* SQLITE_OMIT_VIRTUALTABLE */ 3089: # define fsdirRegister(x) SQLITE_OK 3090: #endif 3091: 3092: #ifdef _WIN32 3093: 3094: #endif 3095: int sqlite3_fileio_init( 3096: sqlite3 *db, 3097: char **pzErrMsg, 3098: const sqlite3_api_routines *pApi 3099: ){ 3100: int rc = SQLITE_OK; 3101: SQLITE_EXTENSION_INIT2(pApi); 3102: (void)pzErrMsg; /* Unused parameter */ 3103: rc = sqlite3_create_function(db, "readfile", 1, 3104: SQLITE_UTF8|SQLITE_DIRECTONLY, 0, 3105: readfileFunc, 0, 0); 3106: if( rc==SQLITE_OK ){ 3107: rc = sqlite3_create_function(db, "writefile", -1, 3108: SQLITE_UTF8|SQLITE_DIRECTONLY, 0, 3109: writefileFunc, 0, 0); 3110: } 3111: if( rc==SQLITE_OK ){ 3112: rc = sqlite3_create_function(db, "lsmode", 1, SQLITE_UTF8, 0, 3113: lsModeFunc, 0, 0); 3114: } 3115: if( rc==SQLITE_OK ){ 3116: rc = fsdirRegister(db); 3117: } 3118: return rc; 3119: } 3120: 3121: /************************* End ../ext/misc/fileio.c ********************/ 3122: /************************* Begin ../ext/misc/completion.c ******************/ 3123: /* 3124: ** 2017-07-10 3125: ** 3126: ** The author disclaims copyright to this source code. In place of 3127: ** a legal notice, here is a blessing: 3128: ** 3129: ** May you do good and not evil. 3130: ** May you find forgiveness for yourself and forgive others. 3131: ** May you share freely, never taking more than you give. 3132: ** 3133: ************************************************************************* 3134: ** 3135: ** This file implements an eponymous virtual table that returns suggested 3136: ** completions for a partial SQL input. 3137: ** 3138: ** Suggested usage: 3139: ** 3140: ** SELECT DISTINCT candidate COLLATE nocase 3141: ** FROM completion($prefix,$wholeline) 3142: ** ORDER BY 1; 3143: ** 3144: ** The two query parameters are optional. $prefix is the text of the 3145: ** current word being typed and that is to be completed. $wholeline is 3146: ** the complete input line, used for context. 3147: ** 3148: ** The raw completion() table might return the same candidate multiple 3149: ** times, for example if the same column name is used to two or more 3150: ** tables. And the candidates are returned in an arbitrary order. Hence, 3151: ** the DISTINCT and ORDER BY are recommended. 3152: ** 3153: ** This virtual table operates at the speed of human typing, and so there 3154: ** is no attempt to make it fast. Even a slow implementation will be much 3155: ** faster than any human can type. 3156: ** 3157: */ 3158: /* #include "sqlite3ext.h" */ 3159: SQLITE_EXTENSION_INIT1 3160: #include <assert.h> 3161: #include <string.h> 3162: #include <ctype.h> 3163: 3164: #ifndef SQLITE_OMIT_VIRTUALTABLE 3165: 3166: /* completion_vtab is a subclass of sqlite3_vtab which will 3167: ** serve as the underlying representation of a completion virtual table 3168: */ 3169: typedef struct completion_vtab completion_vtab; 3170: struct completion_vtab { 3171: sqlite3_vtab base; /* Base class - must be first */ 3172: sqlite3 *db; /* Database connection for this completion vtab */ 3173: }; 3174: 3175: /* completion_cursor is a subclass of sqlite3_vtab_cursor which will 3176: ** serve as the underlying representation of a cursor that scans 3177: ** over rows of the result 3178: */ 3179: typedef struct completion_cursor completion_cursor; 3180: struct completion_cursor { 3181: sqlite3_vtab_cursor base; /* Base class - must be first */ 3182: sqlite3 *db; /* Database connection for this cursor */ 3183: int nPrefix, nLine; /* Number of bytes in zPrefix and zLine */ 3184: char *zPrefix; /* The prefix for the word we want to complete */ 3185: char *zLine; /* The whole that we want to complete */ 3186: const char *zCurrentRow; /* Current output row */ 3187: int szRow; /* Length of the zCurrentRow string */ 3188: sqlite3_stmt *pStmt; /* Current statement */ 3189: sqlite3_int64 iRowid; /* The rowid */ 3190: int ePhase; /* Current phase */ 3191: int j; /* inter-phase counter */ 3192: }; 3193: 3194: /* Values for ePhase: 3195: */ 3196: #define COMPLETION_FIRST_PHASE 1 3197: #define COMPLETION_KEYWORDS 1 3198: #define COMPLETION_PRAGMAS 2 3199: #define COMPLETION_FUNCTIONS 3 3200: #define COMPLETION_COLLATIONS 4 3201: #define COMPLETION_INDEXES 5 3202: #define COMPLETION_TRIGGERS 6 3203: #define COMPLETION_DATABASES 7 3204: #define COMPLETION_TABLES 8 /* Also VIEWs and TRIGGERs */ 3205: #define COMPLETION_COLUMNS 9 3206: #define COMPLETION_MODULES 10 3207: #define COMPLETION_EOF 11 3208: 3209: /* 3210: ** The completionConnect() method is invoked to create a new 3211: ** completion_vtab that describes the completion virtual table. 3212: ** 3213: ** Think of this routine as the constructor for completion_vtab objects. 3214: ** 3215: ** All this routine needs to do is: 3216: ** 3217: ** (1) Allocate the completion_vtab object and initialize all fields. 3218: ** 3219: ** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the 3220: ** result set of queries against completion will look like. 3221: */ 3222: static int completionConnect( 3223: sqlite3 *db, 3224: void *pAux, 3225: int argc, const char *const*argv, 3226: sqlite3_vtab **ppVtab, 3227: char **pzErr 3228: ){ 3229: completion_vtab *pNew; 3230: int rc; 3231: 3232: (void)(pAux); /* Unused parameter */ 3233: (void)(argc); /* Unused parameter */ 3234: (void)(argv); /* Unused parameter */ 3235: (void)(pzErr); /* Unused parameter */ 3236: 3237: /* Column numbers */ 3238: #define COMPLETION_COLUMN_CANDIDATE 0 /* Suggested completion of the input */ 3239: #define COMPLETION_COLUMN_PREFIX 1 /* Prefix of the word to be completed */ 3240: #define COMPLETION_COLUMN_WHOLELINE 2 /* Entire line seen so far */ 3241: #define COMPLETION_COLUMN_PHASE 3 /* ePhase - used for debugging only */ 3242: 3243: sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS); 3244: rc = sqlite3_declare_vtab(db, 3245: "CREATE TABLE x(" 3246: " candidate TEXT," 3247: " prefix TEXT HIDDEN," 3248: " wholeline TEXT HIDDEN," 3249: " phase INT HIDDEN" /* Used for debugging only */ 3250: ")"); 3251: if( rc==SQLITE_OK ){ 3252: pNew = sqlite3_malloc( sizeof(*pNew) ); 3253: *ppVtab = (sqlite3_vtab*)pNew; 3254: if( pNew==0 ) return SQLITE_NOMEM; 3255: memset(pNew, 0, sizeof(*pNew)); 3256: pNew->db = db; 3257: } 3258: return rc; 3259: } 3260: 3261: /* 3262: ** This method is the destructor for completion_cursor objects. 3263: */ 3264: static int completionDisconnect(sqlite3_vtab *pVtab){ 3265: sqlite3_free(pVtab); 3266: return SQLITE_OK; 3267: } 3268: 3269: /* 3270: ** Constructor for a new completion_cursor object. 3271: */ 3272: static int completionOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 3273: completion_cursor *pCur; 3274: pCur = sqlite3_malloc( sizeof(*pCur) ); 3275: if( pCur==0 ) return SQLITE_NOMEM; 3276: memset(pCur, 0, sizeof(*pCur)); 3277: pCur->db = ((completion_vtab*)p)->db; 3278: *ppCursor = &pCur->base; 3279: return SQLITE_OK; 3280: } 3281: 3282: /* 3283: ** Reset the completion_cursor. 3284: */ 3285: static void completionCursorReset(completion_cursor *pCur){ 3286: sqlite3_free(pCur->zPrefix); pCur->zPrefix = 0; pCur->nPrefix = 0; 3287: sqlite3_free(pCur->zLine); pCur->zLine = 0; pCur->nLine = 0; 3288: sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0; 3289: pCur->j = 0; 3290: } 3291: 3292: /* 3293: ** Destructor for a completion_cursor. 3294: */ 3295: static int completionClose(sqlite3_vtab_cursor *cur){ 3296: completionCursorReset((completion_cursor*)cur); 3297: sqlite3_free(cur); 3298: return SQLITE_OK; 3299: } 3300: 3301: /* 3302: ** Advance a completion_cursor to its next row of output. 3303: ** 3304: ** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object 3305: ** record the current state of the scan. This routine sets ->zCurrentRow 3306: ** to the current row of output and then returns. If no more rows remain, 3307: ** then ->ePhase is set to COMPLETION_EOF which will signal the virtual 3308: ** table that has reached the end of its scan. 3309: ** 3310: ** The current implementation just lists potential identifiers and 3311: ** keywords and filters them by zPrefix. Future enhancements should 3312: ** take zLine into account to try to restrict the set of identifiers and 3313: ** keywords based on what would be legal at the current point of input. 3314: */ 3315: static int completionNext(sqlite3_vtab_cursor *cur){ 3316: completion_cursor *pCur = (completion_cursor*)cur; 3317: int eNextPhase = 0; /* Next phase to try if current phase reaches end */ 3318: int iCol = -1; /* If >=0, step pCur->pStmt and use the i-th column */ 3319: pCur->iRowid++; 3320: while( pCur->ePhase!=COMPLETION_EOF ){ 3321: switch( pCur->ePhase ){ 3322: case COMPLETION_KEYWORDS: { 3323: if( pCur->j >= sqlite3_keyword_count() ){ 3324: pCur->zCurrentRow = 0; 3325: pCur->ePhase = COMPLETION_DATABASES; 3326: }else{ 3327: sqlite3_keyword_name(pCur->j++, &pCur->zCurrentRow, &pCur->szRow); 3328: } 3329: iCol = -1; 3330: break; 3331: } 3332: case COMPLETION_DATABASES: { 3333: if( pCur->pStmt==0 ){ 3334: sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, 3335: &pCur->pStmt, 0); 3336: } 3337: iCol = 1; 3338: eNextPhase = COMPLETION_TABLES; 3339: break; 3340: } 3341: case COMPLETION_TABLES: { 3342: if( pCur->pStmt==0 ){ 3343: sqlite3_stmt *pS2; 3344: char *zSql = 0; 3345: const char *zSep = ""; 3346: sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); 3347: while( sqlite3_step(pS2)==SQLITE_ROW ){ 3348: const char *zDb = (const char*)sqlite3_column_text(pS2, 1); 3349: zSql = sqlite3_mprintf( 3350: "%z%s" 3351: "SELECT name FROM \"%w\".sqlite_schema", 3352: zSql, zSep, zDb 3353: ); 3354: if( zSql==0 ) return SQLITE_NOMEM; 3355: zSep = " UNION "; 3356: } 3357: sqlite3_finalize(pS2); 3358: sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); 3359: sqlite3_free(zSql); 3360: } 3361: iCol = 0; 3362: eNextPhase = COMPLETION_COLUMNS; 3363: break; 3364: } 3365: case COMPLETION_COLUMNS: { 3366: if( pCur->pStmt==0 ){ 3367: sqlite3_stmt *pS2; 3368: char *zSql = 0; 3369: const char *zSep = ""; 3370: sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); 3371: while( sqlite3_step(pS2)==SQLITE_ROW ){ 3372: const char *zDb = (const char*)sqlite3_column_text(pS2, 1); 3373: zSql = sqlite3_mprintf( 3374: "%z%s" 3375: "SELECT pti.name FROM \"%w\".sqlite_schema AS sm" 3376: " JOIN pragma_table_info(sm.name,%Q) AS pti" 3377: " WHERE sm.type='table'", 3378: zSql, zSep, zDb, zDb 3379: ); 3380: if( zSql==0 ) return SQLITE_NOMEM; 3381: zSep = " UNION "; 1.4 misho 3382: } 1.5 misho 3383: sqlite3_finalize(pS2); 3384: sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); 3385: sqlite3_free(zSql); 3386: } 3387: iCol = 0; 3388: eNextPhase = COMPLETION_EOF; 3389: break; 3390: } 3391: } 3392: if( iCol<0 ){ 3393: /* This case is when the phase presets zCurrentRow */ 3394: if( pCur->zCurrentRow==0 ) continue; 3395: }else{ 3396: if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){ 3397: /* Extract the next row of content */ 3398: pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol); 3399: pCur->szRow = sqlite3_column_bytes(pCur->pStmt, iCol); 3400: }else{ 3401: /* When all rows are finished, advance to the next phase */ 3402: sqlite3_finalize(pCur->pStmt); 3403: pCur->pStmt = 0; 3404: pCur->ePhase = eNextPhase; 3405: continue; 3406: } 3407: } 3408: if( pCur->nPrefix==0 ) break; 3409: if( pCur->nPrefix<=pCur->szRow 3410: && sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0 3411: ){ 3412: break; 3413: } 3414: } 3415: 3416: return SQLITE_OK; 3417: } 3418: 3419: /* 3420: ** Return values of columns for the row at which the completion_cursor 3421: ** is currently pointing. 3422: */ 3423: static int completionColumn( 3424: sqlite3_vtab_cursor *cur, /* The cursor */ 3425: sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 3426: int i /* Which column to return */ 3427: ){ 3428: completion_cursor *pCur = (completion_cursor*)cur; 3429: switch( i ){ 3430: case COMPLETION_COLUMN_CANDIDATE: { 3431: sqlite3_result_text(ctx, pCur->zCurrentRow, pCur->szRow,SQLITE_TRANSIENT); 3432: break; 3433: } 3434: case COMPLETION_COLUMN_PREFIX: { 3435: sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT); 3436: break; 3437: } 3438: case COMPLETION_COLUMN_WHOLELINE: { 3439: sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT); 3440: break; 3441: } 3442: case COMPLETION_COLUMN_PHASE: { 3443: sqlite3_result_int(ctx, pCur->ePhase); 3444: break; 3445: } 3446: } 3447: return SQLITE_OK; 3448: } 3449: 3450: /* 3451: ** Return the rowid for the current row. In this implementation, the 3452: ** rowid is the same as the output value. 3453: */ 3454: static int completionRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 3455: completion_cursor *pCur = (completion_cursor*)cur; 3456: *pRowid = pCur->iRowid; 3457: return SQLITE_OK; 3458: } 3459: 3460: /* 3461: ** Return TRUE if the cursor has been moved off of the last 3462: ** row of output. 3463: */ 3464: static int completionEof(sqlite3_vtab_cursor *cur){ 3465: completion_cursor *pCur = (completion_cursor*)cur; 3466: return pCur->ePhase >= COMPLETION_EOF; 3467: } 3468: 3469: /* 3470: ** This method is called to "rewind" the completion_cursor object back 3471: ** to the first row of output. This method is always called at least 3472: ** once prior to any call to completionColumn() or completionRowid() or 3473: ** completionEof(). 3474: */ 3475: static int completionFilter( 3476: sqlite3_vtab_cursor *pVtabCursor, 3477: int idxNum, const char *idxStr, 3478: int argc, sqlite3_value **argv 3479: ){ 3480: completion_cursor *pCur = (completion_cursor *)pVtabCursor; 3481: int iArg = 0; 3482: (void)(idxStr); /* Unused parameter */ 3483: (void)(argc); /* Unused parameter */ 3484: completionCursorReset(pCur); 3485: if( idxNum & 1 ){ 3486: pCur->nPrefix = sqlite3_value_bytes(argv[iArg]); 3487: if( pCur->nPrefix>0 ){ 3488: pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); 3489: if( pCur->zPrefix==0 ) return SQLITE_NOMEM; 3490: } 3491: iArg = 1; 3492: } 3493: if( idxNum & 2 ){ 3494: pCur->nLine = sqlite3_value_bytes(argv[iArg]); 3495: if( pCur->nLine>0 ){ 3496: pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); 3497: if( pCur->zLine==0 ) return SQLITE_NOMEM; 3498: } 3499: } 3500: if( pCur->zLine!=0 && pCur->zPrefix==0 ){ 3501: int i = pCur->nLine; 3502: while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){ 3503: i--; 3504: } 3505: pCur->nPrefix = pCur->nLine - i; 3506: if( pCur->nPrefix>0 ){ 3507: pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i); 3508: if( pCur->zPrefix==0 ) return SQLITE_NOMEM; 3509: } 3510: } 3511: pCur->iRowid = 0; 3512: pCur->ePhase = COMPLETION_FIRST_PHASE; 3513: return completionNext(pVtabCursor); 3514: } 3515: 3516: /* 3517: ** SQLite will invoke this method one or more times while planning a query 3518: ** that uses the completion virtual table. This routine needs to create 3519: ** a query plan for each invocation and compute an estimated cost for that 3520: ** plan. 3521: ** 3522: ** There are two hidden parameters that act as arguments to the table-valued 3523: ** function: "prefix" and "wholeline". Bit 0 of idxNum is set if "prefix" 3524: ** is available and bit 1 is set if "wholeline" is available. 3525: */ 3526: static int completionBestIndex( 3527: sqlite3_vtab *tab, 3528: sqlite3_index_info *pIdxInfo 3529: ){ 3530: int i; /* Loop over constraints */ 3531: int idxNum = 0; /* The query plan bitmask */ 3532: int prefixIdx = -1; /* Index of the start= constraint, or -1 if none */ 3533: int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */ 3534: int nArg = 0; /* Number of arguments that completeFilter() expects */ 3535: const struct sqlite3_index_constraint *pConstraint; 3536: 3537: (void)(tab); /* Unused parameter */ 3538: pConstraint = pIdxInfo->aConstraint; 3539: for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 3540: if( pConstraint->usable==0 ) continue; 3541: if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 3542: switch( pConstraint->iColumn ){ 3543: case COMPLETION_COLUMN_PREFIX: 3544: prefixIdx = i; 3545: idxNum |= 1; 3546: break; 3547: case COMPLETION_COLUMN_WHOLELINE: 3548: wholelineIdx = i; 3549: idxNum |= 2; 3550: break; 3551: } 3552: } 3553: if( prefixIdx>=0 ){ 3554: pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg; 3555: pIdxInfo->aConstraintUsage[prefixIdx].omit = 1; 3556: } 3557: if( wholelineIdx>=0 ){ 3558: pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg; 3559: pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1; 3560: } 3561: pIdxInfo->idxNum = idxNum; 3562: pIdxInfo->estimatedCost = (double)5000 - 1000*nArg; 3563: pIdxInfo->estimatedRows = 500 - 100*nArg; 3564: return SQLITE_OK; 3565: } 3566: 3567: /* 3568: ** This following structure defines all the methods for the 3569: ** completion virtual table. 3570: */ 3571: static sqlite3_module completionModule = { 3572: 0, /* iVersion */ 3573: 0, /* xCreate */ 3574: completionConnect, /* xConnect */ 3575: completionBestIndex, /* xBestIndex */ 3576: completionDisconnect, /* xDisconnect */ 3577: 0, /* xDestroy */ 3578: completionOpen, /* xOpen - open a cursor */ 3579: completionClose, /* xClose - close a cursor */ 3580: completionFilter, /* xFilter - configure scan constraints */ 3581: completionNext, /* xNext - advance a cursor */ 3582: completionEof, /* xEof - check for end of scan */ 3583: completionColumn, /* xColumn - read data */ 3584: completionRowid, /* xRowid - read data */ 3585: 0, /* xUpdate */ 3586: 0, /* xBegin */ 3587: 0, /* xSync */ 3588: 0, /* xCommit */ 3589: 0, /* xRollback */ 3590: 0, /* xFindMethod */ 3591: 0, /* xRename */ 3592: 0, /* xSavepoint */ 3593: 0, /* xRelease */ 3594: 0, /* xRollbackTo */ 3595: 0 /* xShadowName */ 3596: }; 3597: 3598: #endif /* SQLITE_OMIT_VIRTUALTABLE */ 3599: 3600: int sqlite3CompletionVtabInit(sqlite3 *db){ 3601: int rc = SQLITE_OK; 3602: #ifndef SQLITE_OMIT_VIRTUALTABLE 3603: rc = sqlite3_create_module(db, "completion", &completionModule, 0); 3604: #endif 3605: return rc; 3606: } 3607: 3608: #ifdef _WIN32 3609: 3610: #endif 3611: int sqlite3_completion_init( 3612: sqlite3 *db, 3613: char **pzErrMsg, 3614: const sqlite3_api_routines *pApi 3615: ){ 3616: int rc = SQLITE_OK; 3617: SQLITE_EXTENSION_INIT2(pApi); 3618: (void)(pzErrMsg); /* Unused parameter */ 3619: #ifndef SQLITE_OMIT_VIRTUALTABLE 3620: rc = sqlite3CompletionVtabInit(db); 3621: #endif 3622: return rc; 3623: } 3624: 3625: /************************* End ../ext/misc/completion.c ********************/ 3626: /************************* Begin ../ext/misc/appendvfs.c ******************/ 3627: /* 3628: ** 2017-10-20 3629: ** 3630: ** The author disclaims copyright to this source code. In place of 3631: ** a legal notice, here is a blessing: 3632: ** 3633: ** May you do good and not evil. 3634: ** May you find forgiveness for yourself and forgive others. 3635: ** May you share freely, never taking more than you give. 3636: ** 3637: ****************************************************************************** 3638: ** 3639: ** This file implements a VFS shim that allows an SQLite database to be 3640: ** appended onto the end of some other file, such as an executable. 3641: ** 3642: ** A special record must appear at the end of the file that identifies the 1.6 ! misho 3643: ** file as an appended database and provides the offset to the first page ! 3644: ** of the exposed content. (Or, it is the length of the content prefix.) ! 3645: ** For best performance page 1 should be located at a disk page boundary, ! 3646: ** though that is not required. 1.5 misho 3647: ** 3648: ** When opening a database using this VFS, the connection might treat 1.6 ! misho 3649: ** the file as an ordinary SQLite database, or it might treat it as a ! 3650: ** database appended onto some other file. The decision is made by ! 3651: ** applying the following rules in order: ! 3652: ** ! 3653: ** (1) An empty file is an ordinary database. 1.5 misho 3654: ** 1.6 ! misho 3655: ** (2) If the file ends with the appendvfs trailer string ! 3656: ** "Start-Of-SQLite3-NNNNNNNN" that file is an appended database. 1.5 misho 3657: ** 1.6 ! misho 3658: ** (3) If the file begins with the standard SQLite prefix string ! 3659: ** "SQLite format 3", that file is an ordinary database. 1.5 misho 3660: ** 3661: ** (4) If none of the above apply and the SQLITE_OPEN_CREATE flag is 3662: ** set, then a new database is appended to the already existing file. 3663: ** 3664: ** (5) Otherwise, SQLITE_CANTOPEN is returned. 3665: ** 3666: ** To avoid unnecessary complications with the PENDING_BYTE, the size of 1.6 ! misho 3667: ** the file containing the database is limited to 1GB. (1000013824 bytes) ! 3668: ** This VFS will not read or write past the 1GB mark. This restriction ! 3669: ** might be lifted in future versions. For now, if you need a larger ! 3670: ** database, then keep it in a separate file. 1.5 misho 3671: ** 1.6 ! misho 3672: ** If the file being opened is a plain database (not an appended one), then ! 3673: ** this shim is a pass-through into the default underlying VFS. (rule 3) 1.5 misho 3674: **/ 3675: /* #include "sqlite3ext.h" */ 3676: SQLITE_EXTENSION_INIT1 3677: #include <string.h> 3678: #include <assert.h> 3679: 3680: /* The append mark at the end of the database is: 3681: ** 3682: ** Start-Of-SQLite3-NNNNNNNN 3683: ** 123456789 123456789 12345 3684: ** 3685: ** The NNNNNNNN represents a 64-bit big-endian unsigned integer which is 1.6 ! misho 3686: ** the offset to page 1, and also the length of the prefix content. 1.5 misho 3687: */ 3688: #define APND_MARK_PREFIX "Start-Of-SQLite3-" 3689: #define APND_MARK_PREFIX_SZ 17 1.6 ! misho 3690: #define APND_MARK_FOS_SZ 8 ! 3691: #define APND_MARK_SIZE (APND_MARK_PREFIX_SZ+APND_MARK_FOS_SZ) 1.5 misho 3692: 3693: /* 3694: ** Maximum size of the combined prefix + database + append-mark. This 3695: ** must be less than 0x40000000 to avoid locking issues on Windows. 3696: */ 3697: #define APND_MAX_SIZE (65536*15259) 3698: 3699: /* 1.6 ! misho 3700: ** Size of storage page upon which to align appendvfs portion. ! 3701: */ ! 3702: #ifndef APND_ROUNDUP_BITS ! 3703: #define APND_ROUNDUP_BITS 12 ! 3704: #endif ! 3705: ! 3706: /* 1.5 misho 3707: ** Forward declaration of objects used by this utility 3708: */ 3709: typedef struct sqlite3_vfs ApndVfs; 3710: typedef struct ApndFile ApndFile; 3711: 3712: /* Access to a lower-level VFS that (might) implement dynamic loading, 3713: ** access to randomness, etc. 3714: */ 3715: #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) 3716: #define ORIGFILE(p) ((sqlite3_file*)(((ApndFile*)(p))+1)) 3717: 1.6 ! misho 3718: /* Invariants for an open appendvfs file: ! 3719: * Once an appendvfs file is opened, it will be in one of three states: ! 3720: * State 0: Never written. Underlying file (if any) is unaltered. ! 3721: * State 1: Append mark is persisted, content write is in progress. ! 3722: * State 2: Append mark is persisted, content writes are complete. ! 3723: * ! 3724: * State 0 is persistent in the sense that nothing will have been done ! 3725: * to the underlying file, including any attempt to convert it to an ! 3726: * appendvfs file. ! 3727: * ! 3728: * State 1 is normally transitory. However, if a write operation ends ! 3729: * abnormally (disk full, power loss, process kill, etc.), then State 1 ! 3730: * may be persistent on disk with an incomplete content write-out. This ! 3731: * is logically equivalent to an interrupted write to an ordinary file, ! 3732: * where some unknown portion of to-be-written data is persisted while ! 3733: * the remainder is not. Database integrity in such cases is maintained ! 3734: * (or not) by the same measures available for ordinary file access. ! 3735: * ! 3736: * State 2 is persistent under normal circumstances (when there is no ! 3737: * abnormal termination of a write operation such that data provided ! 3738: * to the underlying VFS write method has not yet reached storage.) ! 3739: * ! 3740: * In order to maintain the state invariant, the append mark is written ! 3741: * in advance of content writes where any part of such content would ! 3742: * overwrite an existing (or yet to be written) append mark. ! 3743: */ 1.5 misho 3744: struct ApndFile { 1.6 ! misho 3745: /* Access to IO methods of the underlying file */ ! 3746: sqlite3_file base; ! 3747: /* File offset to beginning of appended content (unchanging) */ ! 3748: sqlite3_int64 iPgOne; ! 3749: /* File offset of written append-mark, or -1 if unwritten */ ! 3750: sqlite3_int64 iMark; 1.5 misho 3751: }; 3752: 3753: /* 3754: ** Methods for ApndFile 3755: */ 3756: static int apndClose(sqlite3_file*); 3757: static int apndRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); 3758: static int apndWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); 3759: static int apndTruncate(sqlite3_file*, sqlite3_int64 size); 3760: static int apndSync(sqlite3_file*, int flags); 3761: static int apndFileSize(sqlite3_file*, sqlite3_int64 *pSize); 3762: static int apndLock(sqlite3_file*, int); 3763: static int apndUnlock(sqlite3_file*, int); 3764: static int apndCheckReservedLock(sqlite3_file*, int *pResOut); 3765: static int apndFileControl(sqlite3_file*, int op, void *pArg); 3766: static int apndSectorSize(sqlite3_file*); 3767: static int apndDeviceCharacteristics(sqlite3_file*); 3768: static int apndShmMap(sqlite3_file*, int iPg, int pgsz, int, void volatile**); 3769: static int apndShmLock(sqlite3_file*, int offset, int n, int flags); 3770: static void apndShmBarrier(sqlite3_file*); 3771: static int apndShmUnmap(sqlite3_file*, int deleteFlag); 3772: static int apndFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); 3773: static int apndUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); 3774: 3775: /* 3776: ** Methods for ApndVfs 3777: */ 3778: static int apndOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); 3779: static int apndDelete(sqlite3_vfs*, const char *zName, int syncDir); 3780: static int apndAccess(sqlite3_vfs*, const char *zName, int flags, int *); 3781: static int apndFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); 3782: static void *apndDlOpen(sqlite3_vfs*, const char *zFilename); 3783: static void apndDlError(sqlite3_vfs*, int nByte, char *zErrMsg); 3784: static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); 3785: static void apndDlClose(sqlite3_vfs*, void*); 3786: static int apndRandomness(sqlite3_vfs*, int nByte, char *zOut); 3787: static int apndSleep(sqlite3_vfs*, int microseconds); 3788: static int apndCurrentTime(sqlite3_vfs*, double*); 3789: static int apndGetLastError(sqlite3_vfs*, int, char *); 3790: static int apndCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); 3791: static int apndSetSystemCall(sqlite3_vfs*, const char*,sqlite3_syscall_ptr); 3792: static sqlite3_syscall_ptr apndGetSystemCall(sqlite3_vfs*, const char *z); 3793: static const char *apndNextSystemCall(sqlite3_vfs*, const char *zName); 3794: 3795: static sqlite3_vfs apnd_vfs = { 3796: 3, /* iVersion (set when registered) */ 3797: 0, /* szOsFile (set when registered) */ 3798: 1024, /* mxPathname */ 3799: 0, /* pNext */ 3800: "apndvfs", /* zName */ 3801: 0, /* pAppData (set when registered) */ 3802: apndOpen, /* xOpen */ 3803: apndDelete, /* xDelete */ 3804: apndAccess, /* xAccess */ 3805: apndFullPathname, /* xFullPathname */ 3806: apndDlOpen, /* xDlOpen */ 3807: apndDlError, /* xDlError */ 3808: apndDlSym, /* xDlSym */ 3809: apndDlClose, /* xDlClose */ 3810: apndRandomness, /* xRandomness */ 3811: apndSleep, /* xSleep */ 3812: apndCurrentTime, /* xCurrentTime */ 3813: apndGetLastError, /* xGetLastError */ 3814: apndCurrentTimeInt64, /* xCurrentTimeInt64 */ 3815: apndSetSystemCall, /* xSetSystemCall */ 3816: apndGetSystemCall, /* xGetSystemCall */ 3817: apndNextSystemCall /* xNextSystemCall */ 3818: }; 3819: 3820: static const sqlite3_io_methods apnd_io_methods = { 3821: 3, /* iVersion */ 3822: apndClose, /* xClose */ 3823: apndRead, /* xRead */ 3824: apndWrite, /* xWrite */ 3825: apndTruncate, /* xTruncate */ 3826: apndSync, /* xSync */ 3827: apndFileSize, /* xFileSize */ 3828: apndLock, /* xLock */ 3829: apndUnlock, /* xUnlock */ 3830: apndCheckReservedLock, /* xCheckReservedLock */ 3831: apndFileControl, /* xFileControl */ 3832: apndSectorSize, /* xSectorSize */ 3833: apndDeviceCharacteristics, /* xDeviceCharacteristics */ 3834: apndShmMap, /* xShmMap */ 3835: apndShmLock, /* xShmLock */ 3836: apndShmBarrier, /* xShmBarrier */ 3837: apndShmUnmap, /* xShmUnmap */ 3838: apndFetch, /* xFetch */ 3839: apndUnfetch /* xUnfetch */ 3840: }; 3841: 3842: /* 3843: ** Close an apnd-file. 3844: */ 3845: static int apndClose(sqlite3_file *pFile){ 3846: pFile = ORIGFILE(pFile); 3847: return pFile->pMethods->xClose(pFile); 3848: } 3849: 3850: /* 3851: ** Read data from an apnd-file. 3852: */ 3853: static int apndRead( 3854: sqlite3_file *pFile, 3855: void *zBuf, 3856: int iAmt, 3857: sqlite_int64 iOfst 3858: ){ 1.6 ! misho 3859: ApndFile *paf = (ApndFile *)pFile; 1.5 misho 3860: pFile = ORIGFILE(pFile); 1.6 ! misho 3861: return pFile->pMethods->xRead(pFile, zBuf, iAmt, paf->iPgOne+iOfst); 1.5 misho 3862: } 3863: 3864: /* 1.6 ! misho 3865: ** Add the append-mark onto what should become the end of the file. ! 3866: * If and only if this succeeds, internal ApndFile.iMark is updated. ! 3867: * Parameter iWriteEnd is the appendvfs-relative offset of the new mark. 1.5 misho 3868: */ 1.6 ! misho 3869: static int apndWriteMark( ! 3870: ApndFile *paf, ! 3871: sqlite3_file *pFile, ! 3872: sqlite_int64 iWriteEnd ! 3873: ){ ! 3874: sqlite_int64 iPgOne = paf->iPgOne; 1.5 misho 3875: unsigned char a[APND_MARK_SIZE]; 1.6 ! misho 3876: int i = APND_MARK_FOS_SZ; ! 3877: int rc; ! 3878: assert(pFile == ORIGFILE(paf)); 1.5 misho 3879: memcpy(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ); 1.6 ! misho 3880: while (--i >= 0) { ! 3881: a[APND_MARK_PREFIX_SZ+i] = (unsigned char)(iPgOne & 0xff); ! 3882: iPgOne >>= 8; ! 3883: } ! 3884: iWriteEnd += paf->iPgOne; ! 3885: if( SQLITE_OK==(rc = pFile->pMethods->xWrite ! 3886: (pFile, a, APND_MARK_SIZE, iWriteEnd)) ){ ! 3887: paf->iMark = iWriteEnd; 1.5 misho 3888: } 1.6 ! misho 3889: return rc; 1.5 misho 3890: } 3891: 3892: /* 3893: ** Write data to an apnd-file. 3894: */ 3895: static int apndWrite( 3896: sqlite3_file *pFile, 3897: const void *zBuf, 3898: int iAmt, 3899: sqlite_int64 iOfst 3900: ){ 1.6 ! misho 3901: ApndFile *paf = (ApndFile *)pFile; ! 3902: sqlite_int64 iWriteEnd = iOfst + iAmt; ! 3903: if( iWriteEnd>=APND_MAX_SIZE ) return SQLITE_FULL; 1.5 misho 3904: pFile = ORIGFILE(pFile); 1.6 ! misho 3905: /* If append-mark is absent or will be overwritten, write it. */ ! 3906: if( paf->iMark < 0 || paf->iPgOne + iWriteEnd > paf->iMark ){ ! 3907: int rc = apndWriteMark(paf, pFile, iWriteEnd); ! 3908: if( SQLITE_OK!=rc ) ! 3909: return rc; 1.5 misho 3910: } 1.6 ! misho 3911: return pFile->pMethods->xWrite(pFile, zBuf, iAmt, paf->iPgOne+iOfst); 1.5 misho 3912: } 3913: 3914: /* 3915: ** Truncate an apnd-file. 3916: */ 3917: static int apndTruncate(sqlite3_file *pFile, sqlite_int64 size){ 1.6 ! misho 3918: ApndFile *paf = (ApndFile *)pFile; 1.5 misho 3919: pFile = ORIGFILE(pFile); 1.6 ! misho 3920: /* The append mark goes out first so truncate failure does not lose it. */ ! 3921: if( SQLITE_OK!=apndWriteMark(paf, pFile, size) ) ! 3922: return SQLITE_IOERR; ! 3923: /* Truncate underlying file just past append mark */ ! 3924: return pFile->pMethods->xTruncate(pFile, paf->iMark+APND_MARK_SIZE); 1.5 misho 3925: } 3926: 3927: /* 3928: ** Sync an apnd-file. 3929: */ 3930: static int apndSync(sqlite3_file *pFile, int flags){ 3931: pFile = ORIGFILE(pFile); 3932: return pFile->pMethods->xSync(pFile, flags); 3933: } 3934: 3935: /* 3936: ** Return the current file-size of an apnd-file. 1.6 ! misho 3937: ** If the append mark is not yet there, the file-size is 0. 1.5 misho 3938: */ 3939: static int apndFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 1.6 ! misho 3940: ApndFile *paf = (ApndFile *)pFile; ! 3941: *pSize = ( paf->iMark >= 0 )? (paf->iMark - paf->iPgOne) : 0; ! 3942: return SQLITE_OK; 1.5 misho 3943: } 3944: 3945: /* 3946: ** Lock an apnd-file. 3947: */ 3948: static int apndLock(sqlite3_file *pFile, int eLock){ 3949: pFile = ORIGFILE(pFile); 3950: return pFile->pMethods->xLock(pFile, eLock); 3951: } 3952: 3953: /* 3954: ** Unlock an apnd-file. 3955: */ 3956: static int apndUnlock(sqlite3_file *pFile, int eLock){ 3957: pFile = ORIGFILE(pFile); 3958: return pFile->pMethods->xUnlock(pFile, eLock); 3959: } 3960: 3961: /* 3962: ** Check if another file-handle holds a RESERVED lock on an apnd-file. 3963: */ 3964: static int apndCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 3965: pFile = ORIGFILE(pFile); 3966: return pFile->pMethods->xCheckReservedLock(pFile, pResOut); 3967: } 3968: 3969: /* 3970: ** File control method. For custom operations on an apnd-file. 3971: */ 3972: static int apndFileControl(sqlite3_file *pFile, int op, void *pArg){ 1.6 ! misho 3973: ApndFile *paf = (ApndFile *)pFile; 1.5 misho 3974: int rc; 3975: pFile = ORIGFILE(pFile); 1.6 ! misho 3976: if( op==SQLITE_FCNTL_SIZE_HINT ) *(sqlite3_int64*)pArg += paf->iPgOne; 1.5 misho 3977: rc = pFile->pMethods->xFileControl(pFile, op, pArg); 3978: if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){ 1.6 ! misho 3979: *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", paf->iPgOne,*(char**)pArg); 1.5 misho 3980: } 3981: return rc; 3982: } 3983: 3984: /* 3985: ** Return the sector-size in bytes for an apnd-file. 3986: */ 3987: static int apndSectorSize(sqlite3_file *pFile){ 3988: pFile = ORIGFILE(pFile); 3989: return pFile->pMethods->xSectorSize(pFile); 3990: } 3991: 3992: /* 3993: ** Return the device characteristic flags supported by an apnd-file. 3994: */ 3995: static int apndDeviceCharacteristics(sqlite3_file *pFile){ 3996: pFile = ORIGFILE(pFile); 3997: return pFile->pMethods->xDeviceCharacteristics(pFile); 3998: } 3999: 4000: /* Create a shared memory file mapping */ 4001: static int apndShmMap( 4002: sqlite3_file *pFile, 4003: int iPg, 4004: int pgsz, 4005: int bExtend, 4006: void volatile **pp 4007: ){ 4008: pFile = ORIGFILE(pFile); 4009: return pFile->pMethods->xShmMap(pFile,iPg,pgsz,bExtend,pp); 4010: } 4011: 4012: /* Perform locking on a shared-memory segment */ 4013: static int apndShmLock(sqlite3_file *pFile, int offset, int n, int flags){ 4014: pFile = ORIGFILE(pFile); 4015: return pFile->pMethods->xShmLock(pFile,offset,n,flags); 4016: } 4017: 4018: /* Memory barrier operation on shared memory */ 4019: static void apndShmBarrier(sqlite3_file *pFile){ 4020: pFile = ORIGFILE(pFile); 4021: pFile->pMethods->xShmBarrier(pFile); 4022: } 4023: 4024: /* Unmap a shared memory segment */ 4025: static int apndShmUnmap(sqlite3_file *pFile, int deleteFlag){ 4026: pFile = ORIGFILE(pFile); 4027: return pFile->pMethods->xShmUnmap(pFile,deleteFlag); 4028: } 4029: 4030: /* Fetch a page of a memory-mapped file */ 4031: static int apndFetch( 4032: sqlite3_file *pFile, 4033: sqlite3_int64 iOfst, 4034: int iAmt, 4035: void **pp 4036: ){ 4037: ApndFile *p = (ApndFile *)pFile; 1.6 ! misho 4038: if( p->iMark < 0 || iOfst+iAmt > p->iMark) ! 4039: return SQLITE_IOERR; /* Cannot read what is not yet there. */ 1.5 misho 4040: pFile = ORIGFILE(pFile); 4041: return pFile->pMethods->xFetch(pFile, iOfst+p->iPgOne, iAmt, pp); 4042: } 4043: 4044: /* Release a memory-mapped page */ 4045: static int apndUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ 4046: ApndFile *p = (ApndFile *)pFile; 4047: pFile = ORIGFILE(pFile); 4048: return pFile->pMethods->xUnfetch(pFile, iOfst+p->iPgOne, pPage); 4049: } 4050: 4051: /* 4052: ** Try to read the append-mark off the end of a file. Return the 1.6 ! misho 4053: ** start of the appended database if the append-mark is present. ! 4054: ** If there is no valid append-mark, return -1; ! 4055: ** ! 4056: ** An append-mark is only valid if the NNNNNNNN start-of-database offset ! 4057: ** indicates that the appended database contains at least one page. The ! 4058: ** start-of-database value must be a multiple of 512. 1.5 misho 4059: */ 4060: static sqlite3_int64 apndReadMark(sqlite3_int64 sz, sqlite3_file *pFile){ 4061: int rc, i; 4062: sqlite3_int64 iMark; 1.6 ! misho 4063: int msbs = 8 * (APND_MARK_FOS_SZ-1); 1.5 misho 4064: unsigned char a[APND_MARK_SIZE]; 4065: 1.6 ! misho 4066: if( APND_MARK_SIZE!=(sz & 0x1ff) ) return -1; 1.5 misho 4067: rc = pFile->pMethods->xRead(pFile, a, APND_MARK_SIZE, sz-APND_MARK_SIZE); 4068: if( rc ) return -1; 4069: if( memcmp(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ)!=0 ) return -1; 1.6 ! misho 4070: iMark = ((sqlite3_int64)(a[APND_MARK_PREFIX_SZ] & 0x7f)) << msbs; ! 4071: for(i=1; i<8; i++){ ! 4072: msbs -= 8; ! 4073: iMark |= (sqlite3_int64)a[APND_MARK_PREFIX_SZ+i]<<msbs; 1.5 misho 4074: } 1.6 ! misho 4075: if( iMark > (sz - APND_MARK_SIZE - 512) ) return -1; ! 4076: if( iMark & 0x1ff ) return -1; 1.5 misho 4077: return iMark; 4078: } 4079: 1.6 ! misho 4080: static const char apvfsSqliteHdr[] = "SQLite format 3"; ! 4081: /* ! 4082: ** Check to see if the file is an appendvfs SQLite database file. ! 4083: ** Return true iff it is such. Parameter sz is the file's size. ! 4084: */ ! 4085: static int apndIsAppendvfsDatabase(sqlite3_int64 sz, sqlite3_file *pFile){ ! 4086: int rc; ! 4087: char zHdr[16]; ! 4088: sqlite3_int64 iMark = apndReadMark(sz, pFile); ! 4089: if( iMark>=0 ){ ! 4090: /* If file has right end-marker, the expected odd size, and the ! 4091: * SQLite DB type marker where the end-marker puts it, then it ! 4092: * is an appendvfs database (to be treated as such.) ! 4093: */ ! 4094: rc = pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), iMark); ! 4095: if( SQLITE_OK==rc && memcmp(zHdr, apvfsSqliteHdr, sizeof(zHdr))==0 ! 4096: && (sz & 0x1ff)== APND_MARK_SIZE && sz>=512+APND_MARK_SIZE ) ! 4097: return 1; /* It's an appendvfs database */ ! 4098: } ! 4099: return 0; ! 4100: } ! 4101: ! 4102: /* ! 4103: ** Check to see if the file is an ordinary SQLite database file. ! 4104: ** Return true iff so. Parameter sz is the file's size. ! 4105: */ ! 4106: static int apndIsOrdinaryDatabaseFile(sqlite3_int64 sz, sqlite3_file *pFile){ ! 4107: char zHdr[16]; ! 4108: if( apndIsAppendvfsDatabase(sz, pFile) /* rule 2 */ ! 4109: || (sz & 0x1ff) != 0 ! 4110: || SQLITE_OK!=pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), 0) ! 4111: || memcmp(zHdr, apvfsSqliteHdr, sizeof(zHdr))!=0 ! 4112: ){ ! 4113: return 0; ! 4114: }else{ ! 4115: return 1; ! 4116: } ! 4117: } ! 4118: ! 4119: /* Round-up used to get appendvfs portion to begin at a page boundary. */ ! 4120: #define APND_ALIGN_MASK(nbits) ((1<<nbits)-1) ! 4121: #define APND_START_ROUNDUP(fsz, nbits) \ ! 4122: ( ((fsz)+APND_ALIGN_MASK(nbits)) & ~(sqlite3_int64)APND_ALIGN_MASK(nbits) ) ! 4123: 1.5 misho 4124: /* 4125: ** Open an apnd file handle. 4126: */ 4127: static int apndOpen( 4128: sqlite3_vfs *pVfs, 4129: const char *zName, 4130: sqlite3_file *pFile, 4131: int flags, 4132: int *pOutFlags 4133: ){ 4134: ApndFile *p; 4135: sqlite3_file *pSubFile; 4136: sqlite3_vfs *pSubVfs; 4137: int rc; 4138: sqlite3_int64 sz; 4139: pSubVfs = ORIGVFS(pVfs); 4140: if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){ 1.6 ! misho 4141: /* The appendvfs is not to be used for transient or temporary databases. */ 1.5 misho 4142: return pSubVfs->xOpen(pSubVfs, zName, pFile, flags, pOutFlags); 4143: } 4144: p = (ApndFile*)pFile; 4145: memset(p, 0, sizeof(*p)); 4146: pSubFile = ORIGFILE(pFile); 4147: pFile->pMethods = &apnd_io_methods; 4148: rc = pSubVfs->xOpen(pSubVfs, zName, pSubFile, flags, pOutFlags); 4149: if( rc ) goto apnd_open_done; 4150: rc = pSubFile->pMethods->xFileSize(pSubFile, &sz); 4151: if( rc ){ 4152: pSubFile->pMethods->xClose(pSubFile); 4153: goto apnd_open_done; 4154: } 4155: if( apndIsOrdinaryDatabaseFile(sz, pSubFile) ){ 4156: memmove(pFile, pSubFile, pSubVfs->szOsFile); 4157: return SQLITE_OK; 4158: } 1.6 ! misho 4159: /* Record that append mark has not been written until seen otherwise. */ ! 4160: p->iMark = -1; 1.5 misho 4161: p->iPgOne = apndReadMark(sz, pFile); 1.6 ! misho 4162: if( p->iPgOne>=0 ){ ! 4163: /* Append mark was found, infer its offset */ ! 4164: p->iMark = sz - p->iPgOne - APND_MARK_SIZE; 1.5 misho 4165: return SQLITE_OK; 4166: } 4167: if( (flags & SQLITE_OPEN_CREATE)==0 ){ 4168: pSubFile->pMethods->xClose(pSubFile); 4169: rc = SQLITE_CANTOPEN; 4170: } 1.6 ! misho 4171: /* Round newly added appendvfs location to #define'd page boundary. ! 4172: * Note that nothing has yet been written to the underlying file. ! 4173: * The append mark will be written along with first content write. ! 4174: * Until then, the p->iMark value indicates it is not yet written. ! 4175: */ ! 4176: p->iPgOne = APND_START_ROUNDUP(sz, APND_ROUNDUP_BITS); 1.5 misho 4177: apnd_open_done: 4178: if( rc ) pFile->pMethods = 0; 4179: return rc; 4180: } 4181: 4182: /* 1.6 ! misho 4183: ** Delete an apnd file. ! 4184: ** For an appendvfs, this could mean delete the appendvfs portion, ! 4185: ** leaving the appendee as it was before it gained an appendvfs. ! 4186: ** For now, this code deletes the underlying file too. 1.5 misho 4187: */ 4188: static int apndDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ 4189: return ORIGVFS(pVfs)->xDelete(ORIGVFS(pVfs), zPath, dirSync); 4190: } 1.6 ! misho 4191: ! 4192: /* ! 4193: ** All other VFS methods are pass-thrus. ! 4194: */ 1.5 misho 4195: static int apndAccess( 4196: sqlite3_vfs *pVfs, 4197: const char *zPath, 4198: int flags, 4199: int *pResOut 4200: ){ 4201: return ORIGVFS(pVfs)->xAccess(ORIGVFS(pVfs), zPath, flags, pResOut); 4202: } 4203: static int apndFullPathname( 4204: sqlite3_vfs *pVfs, 4205: const char *zPath, 4206: int nOut, 4207: char *zOut 4208: ){ 4209: return ORIGVFS(pVfs)->xFullPathname(ORIGVFS(pVfs),zPath,nOut,zOut); 4210: } 4211: static void *apndDlOpen(sqlite3_vfs *pVfs, const char *zPath){ 4212: return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); 4213: } 4214: static void apndDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ 4215: ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); 4216: } 4217: static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ 4218: return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); 4219: } 4220: static void apndDlClose(sqlite3_vfs *pVfs, void *pHandle){ 4221: ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); 4222: } 4223: static int apndRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ 4224: return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); 4225: } 4226: static int apndSleep(sqlite3_vfs *pVfs, int nMicro){ 4227: return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); 4228: } 4229: static int apndCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ 4230: return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); 4231: } 4232: static int apndGetLastError(sqlite3_vfs *pVfs, int a, char *b){ 4233: return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); 4234: } 4235: static int apndCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ 4236: return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); 4237: } 4238: static int apndSetSystemCall( 4239: sqlite3_vfs *pVfs, 4240: const char *zName, 4241: sqlite3_syscall_ptr pCall 4242: ){ 4243: return ORIGVFS(pVfs)->xSetSystemCall(ORIGVFS(pVfs),zName,pCall); 4244: } 4245: static sqlite3_syscall_ptr apndGetSystemCall( 4246: sqlite3_vfs *pVfs, 4247: const char *zName 4248: ){ 4249: return ORIGVFS(pVfs)->xGetSystemCall(ORIGVFS(pVfs),zName); 4250: } 4251: static const char *apndNextSystemCall(sqlite3_vfs *pVfs, const char *zName){ 4252: return ORIGVFS(pVfs)->xNextSystemCall(ORIGVFS(pVfs), zName); 4253: } 4254: 4255: 4256: #ifdef _WIN32 4257: 4258: #endif 4259: /* 4260: ** This routine is called when the extension is loaded. 4261: ** Register the new VFS. 4262: */ 4263: int sqlite3_appendvfs_init( 4264: sqlite3 *db, 4265: char **pzErrMsg, 4266: const sqlite3_api_routines *pApi 4267: ){ 4268: int rc = SQLITE_OK; 4269: sqlite3_vfs *pOrig; 4270: SQLITE_EXTENSION_INIT2(pApi); 4271: (void)pzErrMsg; 4272: (void)db; 4273: pOrig = sqlite3_vfs_find(0); 4274: apnd_vfs.iVersion = pOrig->iVersion; 4275: apnd_vfs.pAppData = pOrig; 4276: apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile); 4277: rc = sqlite3_vfs_register(&apnd_vfs, 0); 4278: #ifdef APPENDVFS_TEST 4279: if( rc==SQLITE_OK ){ 4280: rc = sqlite3_auto_extension((void(*)(void))apndvfsRegister); 4281: } 4282: #endif 4283: if( rc==SQLITE_OK ) rc = SQLITE_OK_LOAD_PERMANENTLY; 4284: return rc; 4285: } 4286: 4287: /************************* End ../ext/misc/appendvfs.c ********************/ 4288: /************************* Begin ../ext/misc/memtrace.c ******************/ 4289: /* 4290: ** 2019-01-21 4291: ** 4292: ** The author disclaims copyright to this source code. In place of 4293: ** a legal notice, here is a blessing: 4294: ** 4295: ** May you do good and not evil. 4296: ** May you find forgiveness for yourself and forgive others. 4297: ** May you share freely, never taking more than you give. 4298: ** 4299: ************************************************************************* 4300: ** 4301: ** This file implements an extension that uses the SQLITE_CONFIG_MALLOC 4302: ** mechanism to add a tracing layer on top of SQLite. If this extension 4303: ** is registered prior to sqlite3_initialize(), it will cause all memory 4304: ** allocation activities to be logged on standard output, or to some other 4305: ** FILE specified by the initializer. 4306: ** 4307: ** This file needs to be compiled into the application that uses it. 4308: ** 4309: ** This extension is used to implement the --memtrace option of the 4310: ** command-line shell. 4311: */ 4312: #include <assert.h> 4313: #include <string.h> 4314: #include <stdio.h> 4315: 4316: /* The original memory allocation routines */ 4317: static sqlite3_mem_methods memtraceBase; 4318: static FILE *memtraceOut; 4319: 4320: /* Methods that trace memory allocations */ 4321: static void *memtraceMalloc(int n){ 4322: if( memtraceOut ){ 4323: fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n", 4324: memtraceBase.xRoundup(n)); 4325: } 4326: return memtraceBase.xMalloc(n); 4327: } 4328: static void memtraceFree(void *p){ 4329: if( p==0 ) return; 4330: if( memtraceOut ){ 4331: fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p)); 4332: } 4333: memtraceBase.xFree(p); 4334: } 4335: static void *memtraceRealloc(void *p, int n){ 4336: if( p==0 ) return memtraceMalloc(n); 4337: if( n==0 ){ 4338: memtraceFree(p); 4339: return 0; 4340: } 4341: if( memtraceOut ){ 4342: fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n", 4343: memtraceBase.xSize(p), memtraceBase.xRoundup(n)); 4344: } 4345: return memtraceBase.xRealloc(p, n); 4346: } 4347: static int memtraceSize(void *p){ 4348: return memtraceBase.xSize(p); 4349: } 4350: static int memtraceRoundup(int n){ 4351: return memtraceBase.xRoundup(n); 4352: } 4353: static int memtraceInit(void *p){ 4354: return memtraceBase.xInit(p); 4355: } 4356: static void memtraceShutdown(void *p){ 4357: memtraceBase.xShutdown(p); 4358: } 4359: 4360: /* The substitute memory allocator */ 4361: static sqlite3_mem_methods ersaztMethods = { 4362: memtraceMalloc, 4363: memtraceFree, 4364: memtraceRealloc, 4365: memtraceSize, 4366: memtraceRoundup, 4367: memtraceInit, 4368: memtraceShutdown, 4369: 0 4370: }; 4371: 4372: /* Begin tracing memory allocations to out. */ 4373: int sqlite3MemTraceActivate(FILE *out){ 4374: int rc = SQLITE_OK; 4375: if( memtraceBase.xMalloc==0 ){ 4376: rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase); 4377: if( rc==SQLITE_OK ){ 4378: rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods); 4379: } 4380: } 4381: memtraceOut = out; 4382: return rc; 4383: } 4384: 4385: /* Deactivate memory tracing */ 4386: int sqlite3MemTraceDeactivate(void){ 4387: int rc = SQLITE_OK; 4388: if( memtraceBase.xMalloc!=0 ){ 4389: rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase); 4390: if( rc==SQLITE_OK ){ 4391: memset(&memtraceBase, 0, sizeof(memtraceBase)); 4392: } 4393: } 4394: memtraceOut = 0; 4395: return rc; 4396: } 4397: 4398: /************************* End ../ext/misc/memtrace.c ********************/ 4399: /************************* Begin ../ext/misc/uint.c ******************/ 4400: /* 4401: ** 2020-04-14 4402: ** 4403: ** The author disclaims copyright to this source code. In place of 4404: ** a legal notice, here is a blessing: 4405: ** 4406: ** May you do good and not evil. 4407: ** May you find forgiveness for yourself and forgive others. 4408: ** May you share freely, never taking more than you give. 4409: ** 4410: ****************************************************************************** 4411: ** 4412: ** This SQLite extension implements the UINT collating sequence. 4413: ** 4414: ** UINT works like BINARY for text, except that embedded strings 4415: ** of digits compare in numeric order. 4416: ** 4417: ** * Leading zeros are handled properly, in the sense that 4418: ** they do not mess of the maginitude comparison of embedded 4419: ** strings of digits. "x00123y" is equal to "x123y". 4420: ** 4421: ** * Only unsigned integers are recognized. Plus and minus 4422: ** signs are ignored. Decimal points and exponential notation 4423: ** are ignored. 4424: ** 4425: ** * Embedded integers can be of arbitrary length. Comparison 4426: ** is *not* limited integers that can be expressed as a 4427: ** 64-bit machine integer. 4428: */ 4429: /* #include "sqlite3ext.h" */ 4430: SQLITE_EXTENSION_INIT1 4431: #include <assert.h> 4432: #include <string.h> 4433: #include <ctype.h> 4434: 4435: /* 4436: ** Compare text in lexicographic order, except strings of digits 4437: ** compare in numeric order. 4438: */ 4439: static int uintCollFunc( 4440: void *notUsed, 4441: int nKey1, const void *pKey1, 4442: int nKey2, const void *pKey2 4443: ){ 4444: const unsigned char *zA = (const unsigned char*)pKey1; 4445: const unsigned char *zB = (const unsigned char*)pKey2; 4446: int i=0, j=0, x; 4447: (void)notUsed; 4448: while( i<nKey1 && j<nKey2 ){ 4449: x = zA[i] - zB[j]; 4450: if( isdigit(zA[i]) ){ 4451: int k; 4452: if( !isdigit(zB[j]) ) return x; 4453: while( i<nKey1 && zA[i]=='0' ){ i++; } 4454: while( j<nKey2 && zB[j]=='0' ){ j++; } 4455: k = 0; 4456: while( i+k<nKey1 && isdigit(zA[i+k]) 4457: && j+k<nKey2 && isdigit(zB[j+k]) ){ 4458: k++; 4459: } 4460: if( i+k<nKey1 && isdigit(zA[i+k]) ){ 4461: return +1; 4462: }else if( j+k<nKey2 && isdigit(zB[j+k]) ){ 4463: return -1; 4464: }else{ 4465: x = memcmp(zA+i, zB+j, k); 4466: if( x ) return x; 4467: i += k; 4468: j += k; 4469: } 4470: }else if( x ){ 4471: return x; 4472: }else{ 4473: i++; 4474: j++; 4475: } 4476: } 4477: return (nKey1 - i) - (nKey2 - j); 4478: } 4479: 4480: #ifdef _WIN32 4481: 4482: #endif 4483: int sqlite3_uint_init( 4484: sqlite3 *db, 4485: char **pzErrMsg, 4486: const sqlite3_api_routines *pApi 4487: ){ 4488: SQLITE_EXTENSION_INIT2(pApi); 4489: (void)pzErrMsg; /* Unused parameter */ 4490: return sqlite3_create_collation(db, "uint", SQLITE_UTF8, 0, uintCollFunc); 4491: } 4492: 4493: /************************* End ../ext/misc/uint.c ********************/ 4494: /************************* Begin ../ext/misc/decimal.c ******************/ 4495: /* 4496: ** 2020-06-22 4497: ** 4498: ** The author disclaims copyright to this source code. In place of 4499: ** a legal notice, here is a blessing: 4500: ** 4501: ** May you do good and not evil. 4502: ** May you find forgiveness for yourself and forgive others. 4503: ** May you share freely, never taking more than you give. 4504: ** 4505: ****************************************************************************** 4506: ** 4507: ** Routines to implement arbitrary-precision decimal math. 4508: ** 4509: ** The focus here is on simplicity and correctness, not performance. 4510: */ 4511: /* #include "sqlite3ext.h" */ 4512: SQLITE_EXTENSION_INIT1 4513: #include <assert.h> 4514: #include <string.h> 4515: #include <ctype.h> 4516: #include <stdlib.h> 4517: 4518: /* Mark a function parameter as unused, to suppress nuisance compiler 4519: ** warnings. */ 4520: #ifndef UNUSED_PARAMETER 4521: # define UNUSED_PARAMETER(X) (void)(X) 4522: #endif 4523: 4524: 4525: /* A decimal object */ 4526: typedef struct Decimal Decimal; 4527: struct Decimal { 4528: char sign; /* 0 for positive, 1 for negative */ 4529: char oom; /* True if an OOM is encountered */ 4530: char isNull; /* True if holds a NULL rather than a number */ 4531: char isInit; /* True upon initialization */ 4532: int nDigit; /* Total number of digits */ 4533: int nFrac; /* Number of digits to the right of the decimal point */ 4534: signed char *a; /* Array of digits. Most significant first. */ 4535: }; 4536: 4537: /* 4538: ** Release memory held by a Decimal, but do not free the object itself. 4539: */ 4540: static void decimal_clear(Decimal *p){ 4541: sqlite3_free(p->a); 4542: } 4543: 4544: /* 4545: ** Destroy a Decimal object 4546: */ 4547: static void decimal_free(Decimal *p){ 4548: if( p ){ 4549: decimal_clear(p); 4550: sqlite3_free(p); 4551: } 4552: } 4553: 4554: /* 4555: ** Allocate a new Decimal object. Initialize it to the number given 4556: ** by the input string. 4557: */ 4558: static Decimal *decimal_new( 4559: sqlite3_context *pCtx, 4560: sqlite3_value *pIn, 4561: int nAlt, 4562: const unsigned char *zAlt 4563: ){ 4564: Decimal *p; 4565: int n, i; 4566: const unsigned char *zIn; 4567: int iExp = 0; 4568: p = sqlite3_malloc( sizeof(*p) ); 4569: if( p==0 ) goto new_no_mem; 4570: p->sign = 0; 4571: p->oom = 0; 4572: p->isInit = 1; 4573: p->isNull = 0; 4574: p->nDigit = 0; 4575: p->nFrac = 0; 4576: if( zAlt ){ 4577: n = nAlt, 4578: zIn = zAlt; 4579: }else{ 4580: if( sqlite3_value_type(pIn)==SQLITE_NULL ){ 4581: p->a = 0; 4582: p->isNull = 1; 4583: return p; 4584: } 4585: n = sqlite3_value_bytes(pIn); 4586: zIn = sqlite3_value_text(pIn); 4587: } 4588: p->a = sqlite3_malloc64( n+1 ); 4589: if( p->a==0 ) goto new_no_mem; 4590: for(i=0; isspace(zIn[i]); i++){} 4591: if( zIn[i]=='-' ){ 4592: p->sign = 1; 4593: i++; 4594: }else if( zIn[i]=='+' ){ 4595: i++; 4596: } 4597: while( i<n && zIn[i]=='0' ) i++; 4598: while( i<n ){ 4599: char c = zIn[i]; 4600: if( c>='0' && c<='9' ){ 4601: p->a[p->nDigit++] = c - '0'; 4602: }else if( c=='.' ){ 4603: p->nFrac = p->nDigit + 1; 4604: }else if( c=='e' || c=='E' ){ 4605: int j = i+1; 4606: int neg = 0; 4607: if( j>=n ) break; 4608: if( zIn[j]=='-' ){ 4609: neg = 1; 4610: j++; 4611: }else if( zIn[j]=='+' ){ 4612: j++; 4613: } 4614: while( j<n && iExp<1000000 ){ 4615: if( zIn[j]>='0' && zIn[j]<='9' ){ 4616: iExp = iExp*10 + zIn[j] - '0'; 4617: } 4618: j++; 4619: } 4620: if( neg ) iExp = -iExp; 4621: break; 4622: } 4623: i++; 4624: } 4625: if( p->nFrac ){ 4626: p->nFrac = p->nDigit - (p->nFrac - 1); 4627: } 4628: if( iExp>0 ){ 4629: if( p->nFrac>0 ){ 4630: if( iExp<=p->nFrac ){ 4631: p->nFrac -= iExp; 4632: iExp = 0; 4633: }else{ 4634: iExp -= p->nFrac; 4635: p->nFrac = 0; 4636: } 4637: } 4638: if( iExp>0 ){ 4639: p->a = sqlite3_realloc64(p->a, p->nDigit + iExp + 1 ); 4640: if( p->a==0 ) goto new_no_mem; 4641: memset(p->a+p->nDigit, 0, iExp); 4642: p->nDigit += iExp; 4643: } 4644: }else if( iExp<0 ){ 4645: int nExtra; 4646: iExp = -iExp; 4647: nExtra = p->nDigit - p->nFrac - 1; 4648: if( nExtra ){ 4649: if( nExtra>=iExp ){ 4650: p->nFrac += iExp; 4651: iExp = 0; 4652: }else{ 4653: iExp -= nExtra; 4654: p->nFrac = p->nDigit - 1; 4655: } 4656: } 4657: if( iExp>0 ){ 4658: p->a = sqlite3_realloc64(p->a, p->nDigit + iExp + 1 ); 4659: if( p->a==0 ) goto new_no_mem; 4660: memmove(p->a+iExp, p->a, p->nDigit); 4661: memset(p->a, 0, iExp); 4662: p->nDigit += iExp; 4663: p->nFrac += iExp; 4664: } 4665: } 4666: return p; 4667: 4668: new_no_mem: 4669: if( pCtx ) sqlite3_result_error_nomem(pCtx); 4670: sqlite3_free(p); 4671: return 0; 4672: } 4673: 4674: /* 4675: ** Make the given Decimal the result. 4676: */ 4677: static void decimal_result(sqlite3_context *pCtx, Decimal *p){ 4678: char *z; 4679: int i, j; 4680: int n; 4681: if( p==0 || p->oom ){ 4682: sqlite3_result_error_nomem(pCtx); 4683: return; 4684: } 4685: if( p->isNull ){ 4686: sqlite3_result_null(pCtx); 4687: return; 4688: } 4689: z = sqlite3_malloc( p->nDigit+4 ); 4690: if( z==0 ){ 4691: sqlite3_result_error_nomem(pCtx); 4692: return; 4693: } 4694: i = 0; 4695: if( p->nDigit==0 || (p->nDigit==1 && p->a[0]==0) ){ 4696: p->sign = 0; 4697: } 4698: if( p->sign ){ 4699: z[0] = '-'; 4700: i = 1; 4701: } 4702: n = p->nDigit - p->nFrac; 4703: if( n<=0 ){ 4704: z[i++] = '0'; 4705: } 4706: j = 0; 4707: while( n>1 && p->a[j]==0 ){ 4708: j++; 4709: n--; 4710: } 4711: while( n>0 ){ 4712: z[i++] = p->a[j] + '0'; 4713: j++; 4714: n--; 4715: } 4716: if( p->nFrac ){ 4717: z[i++] = '.'; 4718: do{ 4719: z[i++] = p->a[j] + '0'; 4720: j++; 4721: }while( j<p->nDigit ); 4722: } 4723: z[i] = 0; 4724: sqlite3_result_text(pCtx, z, i, sqlite3_free); 4725: } 4726: 4727: /* 4728: ** SQL Function: decimal(X) 4729: ** 4730: ** Convert input X into decimal and then back into text 4731: */ 4732: static void decimalFunc( 4733: sqlite3_context *context, 4734: int argc, 4735: sqlite3_value **argv 4736: ){ 4737: Decimal *p = decimal_new(context, argv[0], 0, 0); 4738: UNUSED_PARAMETER(argc); 4739: decimal_result(context, p); 4740: decimal_free(p); 4741: } 4742: 4743: /* 4744: ** Compare to Decimal objects. Return negative, 0, or positive if the 4745: ** first object is less than, equal to, or greater than the second. 4746: ** 4747: ** Preconditions for this routine: 4748: ** 4749: ** pA!=0 4750: ** pA->isNull==0 4751: ** pB!=0 4752: ** pB->isNull==0 4753: */ 4754: static int decimal_cmp(const Decimal *pA, const Decimal *pB){ 4755: int nASig, nBSig, rc, n; 4756: if( pA->sign!=pB->sign ){ 4757: return pA->sign ? -1 : +1; 4758: } 4759: if( pA->sign ){ 4760: const Decimal *pTemp = pA; 4761: pA = pB; 4762: pB = pTemp; 4763: } 4764: nASig = pA->nDigit - pA->nFrac; 4765: nBSig = pB->nDigit - pB->nFrac; 4766: if( nASig!=nBSig ){ 4767: return nASig - nBSig; 4768: } 4769: n = pA->nDigit; 4770: if( n>pB->nDigit ) n = pB->nDigit; 4771: rc = memcmp(pA->a, pB->a, n); 4772: if( rc==0 ){ 4773: rc = pA->nDigit - pB->nDigit; 4774: } 4775: return rc; 4776: } 4777: 4778: /* 4779: ** SQL Function: decimal_cmp(X, Y) 4780: ** 4781: ** Return negative, zero, or positive if X is less then, equal to, or 4782: ** greater than Y. 4783: */ 4784: static void decimalCmpFunc( 4785: sqlite3_context *context, 4786: int argc, 4787: sqlite3_value **argv 4788: ){ 4789: Decimal *pA = 0, *pB = 0; 4790: int rc; 4791: 4792: UNUSED_PARAMETER(argc); 4793: pA = decimal_new(context, argv[0], 0, 0); 4794: if( pA==0 || pA->isNull ) goto cmp_done; 4795: pB = decimal_new(context, argv[1], 0, 0); 4796: if( pB==0 || pB->isNull ) goto cmp_done; 4797: rc = decimal_cmp(pA, pB); 4798: if( rc<0 ) rc = -1; 4799: else if( rc>0 ) rc = +1; 4800: sqlite3_result_int(context, rc); 4801: cmp_done: 4802: decimal_free(pA); 4803: decimal_free(pB); 4804: } 4805: 4806: /* 4807: ** Expand the Decimal so that it has a least nDigit digits and nFrac 4808: ** digits to the right of the decimal point. 4809: */ 4810: static void decimal_expand(Decimal *p, int nDigit, int nFrac){ 4811: int nAddSig; 4812: int nAddFrac; 4813: if( p==0 ) return; 4814: nAddFrac = nFrac - p->nFrac; 4815: nAddSig = (nDigit - p->nDigit) - nAddFrac; 4816: if( nAddFrac==0 && nAddSig==0 ) return; 4817: p->a = sqlite3_realloc64(p->a, nDigit+1); 4818: if( p->a==0 ){ 4819: p->oom = 1; 4820: return; 4821: } 4822: if( nAddSig ){ 4823: memmove(p->a+nAddSig, p->a, p->nDigit); 4824: memset(p->a, 0, nAddSig); 4825: p->nDigit += nAddSig; 4826: } 4827: if( nAddFrac ){ 4828: memset(p->a+p->nDigit, 0, nAddFrac); 4829: p->nDigit += nAddFrac; 4830: p->nFrac += nAddFrac; 4831: } 4832: } 4833: 4834: /* 4835: ** Add the value pB into pA. 4836: ** 4837: ** Both pA and pB might become denormalized by this routine. 4838: */ 4839: static void decimal_add(Decimal *pA, Decimal *pB){ 4840: int nSig, nFrac, nDigit; 4841: int i, rc; 4842: if( pA==0 ){ 4843: return; 4844: } 4845: if( pA->oom || pB==0 || pB->oom ){ 4846: pA->oom = 1; 4847: return; 4848: } 4849: if( pA->isNull || pB->isNull ){ 4850: pA->isNull = 1; 4851: return; 4852: } 4853: nSig = pA->nDigit - pA->nFrac; 4854: if( nSig && pA->a[0]==0 ) nSig--; 4855: if( nSig<pB->nDigit-pB->nFrac ){ 4856: nSig = pB->nDigit - pB->nFrac; 4857: } 4858: nFrac = pA->nFrac; 4859: if( nFrac<pB->nFrac ) nFrac = pB->nFrac; 4860: nDigit = nSig + nFrac + 1; 4861: decimal_expand(pA, nDigit, nFrac); 4862: decimal_expand(pB, nDigit, nFrac); 4863: if( pA->oom || pB->oom ){ 4864: pA->oom = 1; 4865: }else{ 4866: if( pA->sign==pB->sign ){ 4867: int carry = 0; 4868: for(i=nDigit-1; i>=0; i--){ 4869: int x = pA->a[i] + pB->a[i] + carry; 4870: if( x>=10 ){ 4871: carry = 1; 4872: pA->a[i] = x - 10; 4873: }else{ 4874: carry = 0; 4875: pA->a[i] = x; 4876: } 4877: } 4878: }else{ 4879: signed char *aA, *aB; 4880: int borrow = 0; 4881: rc = memcmp(pA->a, pB->a, nDigit); 4882: if( rc<0 ){ 4883: aA = pB->a; 4884: aB = pA->a; 4885: pA->sign = !pA->sign; 4886: }else{ 4887: aA = pA->a; 4888: aB = pB->a; 4889: } 4890: for(i=nDigit-1; i>=0; i--){ 4891: int x = aA[i] - aB[i] - borrow; 4892: if( x<0 ){ 4893: pA->a[i] = x+10; 4894: borrow = 1; 4895: }else{ 4896: pA->a[i] = x; 4897: borrow = 0; 4898: } 4899: } 4900: } 4901: } 4902: } 4903: 4904: /* 4905: ** Compare text in decimal order. 4906: */ 4907: static int decimalCollFunc( 4908: void *notUsed, 4909: int nKey1, const void *pKey1, 4910: int nKey2, const void *pKey2 4911: ){ 4912: const unsigned char *zA = (const unsigned char*)pKey1; 4913: const unsigned char *zB = (const unsigned char*)pKey2; 4914: Decimal *pA = decimal_new(0, 0, nKey1, zA); 4915: Decimal *pB = decimal_new(0, 0, nKey2, zB); 4916: int rc; 4917: UNUSED_PARAMETER(notUsed); 4918: if( pA==0 || pB==0 ){ 4919: rc = 0; 4920: }else{ 4921: rc = decimal_cmp(pA, pB); 4922: } 4923: decimal_free(pA); 4924: decimal_free(pB); 4925: return rc; 4926: } 4927: 4928: 4929: /* 4930: ** SQL Function: decimal_add(X, Y) 4931: ** decimal_sub(X, Y) 4932: ** 4933: ** Return the sum or difference of X and Y. 4934: */ 4935: static void decimalAddFunc( 4936: sqlite3_context *context, 4937: int argc, 4938: sqlite3_value **argv 4939: ){ 4940: Decimal *pA = decimal_new(context, argv[0], 0, 0); 4941: Decimal *pB = decimal_new(context, argv[1], 0, 0); 4942: UNUSED_PARAMETER(argc); 4943: decimal_add(pA, pB); 4944: decimal_result(context, pA); 4945: decimal_free(pA); 4946: decimal_free(pB); 4947: } 4948: static void decimalSubFunc( 4949: sqlite3_context *context, 4950: int argc, 4951: sqlite3_value **argv 4952: ){ 4953: Decimal *pA = decimal_new(context, argv[0], 0, 0); 4954: Decimal *pB = decimal_new(context, argv[1], 0, 0); 4955: UNUSED_PARAMETER(argc); 4956: if( pB==0 ) return; 4957: pB->sign = !pB->sign; 4958: decimal_add(pA, pB); 4959: decimal_result(context, pA); 4960: decimal_free(pA); 4961: decimal_free(pB); 4962: } 4963: 4964: /* Aggregate funcion: decimal_sum(X) 4965: ** 4966: ** Works like sum() except that it uses decimal arithmetic for unlimited 4967: ** precision. 4968: */ 4969: static void decimalSumStep( 4970: sqlite3_context *context, 4971: int argc, 4972: sqlite3_value **argv 4973: ){ 4974: Decimal *p; 4975: Decimal *pArg; 4976: UNUSED_PARAMETER(argc); 4977: p = sqlite3_aggregate_context(context, sizeof(*p)); 4978: if( p==0 ) return; 4979: if( !p->isInit ){ 4980: p->isInit = 1; 4981: p->a = sqlite3_malloc(2); 4982: if( p->a==0 ){ 4983: p->oom = 1; 4984: }else{ 4985: p->a[0] = 0; 4986: } 4987: p->nDigit = 1; 4988: p->nFrac = 0; 4989: } 4990: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 4991: pArg = decimal_new(context, argv[0], 0, 0); 4992: decimal_add(p, pArg); 4993: decimal_free(pArg); 4994: } 4995: static void decimalSumInverse( 4996: sqlite3_context *context, 4997: int argc, 4998: sqlite3_value **argv 4999: ){ 5000: Decimal *p; 5001: Decimal *pArg; 5002: UNUSED_PARAMETER(argc); 5003: p = sqlite3_aggregate_context(context, sizeof(*p)); 5004: if( p==0 ) return; 5005: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 5006: pArg = decimal_new(context, argv[0], 0, 0); 5007: if( pArg ) pArg->sign = !pArg->sign; 5008: decimal_add(p, pArg); 5009: decimal_free(pArg); 5010: } 5011: static void decimalSumValue(sqlite3_context *context){ 5012: Decimal *p = sqlite3_aggregate_context(context, 0); 5013: if( p==0 ) return; 5014: decimal_result(context, p); 5015: } 5016: static void decimalSumFinalize(sqlite3_context *context){ 5017: Decimal *p = sqlite3_aggregate_context(context, 0); 5018: if( p==0 ) return; 5019: decimal_result(context, p); 5020: decimal_clear(p); 5021: } 5022: 5023: /* 5024: ** SQL Function: decimal_mul(X, Y) 5025: ** 5026: ** Return the product of X and Y. 5027: ** 5028: ** All significant digits after the decimal point are retained. 5029: ** Trailing zeros after the decimal point are omitted as long as 5030: ** the number of digits after the decimal point is no less than 5031: ** either the number of digits in either input. 5032: */ 5033: static void decimalMulFunc( 5034: sqlite3_context *context, 5035: int argc, 5036: sqlite3_value **argv 5037: ){ 5038: Decimal *pA = decimal_new(context, argv[0], 0, 0); 5039: Decimal *pB = decimal_new(context, argv[1], 0, 0); 5040: signed char *acc = 0; 5041: int i, j, k; 5042: int minFrac; 5043: UNUSED_PARAMETER(argc); 5044: if( pA==0 || pA->oom || pA->isNull 5045: || pB==0 || pB->oom || pB->isNull 5046: ){ 5047: goto mul_end; 5048: } 5049: acc = sqlite3_malloc64( pA->nDigit + pB->nDigit + 2 ); 5050: if( acc==0 ){ 5051: sqlite3_result_error_nomem(context); 5052: goto mul_end; 5053: } 5054: memset(acc, 0, pA->nDigit + pB->nDigit + 2); 5055: minFrac = pA->nFrac; 5056: if( pB->nFrac<minFrac ) minFrac = pB->nFrac; 5057: for(i=pA->nDigit-1; i>=0; i--){ 5058: signed char f = pA->a[i]; 5059: int carry = 0, x; 5060: for(j=pB->nDigit-1, k=i+j+3; j>=0; j--, k--){ 5061: x = acc[k] + f*pB->a[j] + carry; 5062: acc[k] = x%10; 5063: carry = x/10; 5064: } 5065: x = acc[k] + carry; 5066: acc[k] = x%10; 5067: acc[k-1] += x/10; 5068: } 5069: sqlite3_free(pA->a); 5070: pA->a = acc; 5071: acc = 0; 5072: pA->nDigit += pB->nDigit + 2; 5073: pA->nFrac += pB->nFrac; 5074: pA->sign ^= pB->sign; 5075: while( pA->nFrac>minFrac && pA->a[pA->nDigit-1]==0 ){ 5076: pA->nFrac--; 5077: pA->nDigit--; 5078: } 5079: decimal_result(context, pA); 5080: 5081: mul_end: 5082: sqlite3_free(acc); 5083: decimal_free(pA); 5084: decimal_free(pB); 5085: } 5086: 5087: #ifdef _WIN32 5088: 5089: #endif 5090: int sqlite3_decimal_init( 5091: sqlite3 *db, 5092: char **pzErrMsg, 5093: const sqlite3_api_routines *pApi 5094: ){ 5095: int rc = SQLITE_OK; 5096: static const struct { 5097: const char *zFuncName; 5098: int nArg; 5099: void (*xFunc)(sqlite3_context*,int,sqlite3_value**); 5100: } aFunc[] = { 5101: { "decimal", 1, decimalFunc }, 5102: { "decimal_cmp", 2, decimalCmpFunc }, 5103: { "decimal_add", 2, decimalAddFunc }, 5104: { "decimal_sub", 2, decimalSubFunc }, 5105: { "decimal_mul", 2, decimalMulFunc }, 5106: }; 5107: unsigned int i; 5108: (void)pzErrMsg; /* Unused parameter */ 5109: 5110: SQLITE_EXTENSION_INIT2(pApi); 5111: 5112: for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){ 5113: rc = sqlite3_create_function(db, aFunc[i].zFuncName, aFunc[i].nArg, 5114: SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC, 5115: 0, aFunc[i].xFunc, 0, 0); 5116: } 5117: if( rc==SQLITE_OK ){ 5118: rc = sqlite3_create_window_function(db, "decimal_sum", 1, 5119: SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC, 0, 5120: decimalSumStep, decimalSumFinalize, 5121: decimalSumValue, decimalSumInverse, 0); 5122: } 5123: if( rc==SQLITE_OK ){ 5124: rc = sqlite3_create_collation(db, "decimal", SQLITE_UTF8, 5125: 0, decimalCollFunc); 5126: } 5127: return rc; 5128: } 5129: 5130: /************************* End ../ext/misc/decimal.c ********************/ 5131: /************************* Begin ../ext/misc/ieee754.c ******************/ 5132: /* 5133: ** 2013-04-17 5134: ** 5135: ** The author disclaims copyright to this source code. In place of 5136: ** a legal notice, here is a blessing: 5137: ** 5138: ** May you do good and not evil. 5139: ** May you find forgiveness for yourself and forgive others. 5140: ** May you share freely, never taking more than you give. 5141: ** 5142: ****************************************************************************** 5143: ** 5144: ** This SQLite extension implements functions for the exact display 5145: ** and input of IEEE754 Binary64 floating-point numbers. 5146: ** 5147: ** ieee754(X) 5148: ** ieee754(Y,Z) 5149: ** 5150: ** In the first form, the value X should be a floating-point number. 5151: ** The function will return a string of the form 'ieee754(Y,Z)' where 5152: ** Y and Z are integers such that X==Y*pow(2,Z). 5153: ** 5154: ** In the second form, Y and Z are integers which are the mantissa and 5155: ** base-2 exponent of a new floating point number. The function returns 5156: ** a floating-point value equal to Y*pow(2,Z). 5157: ** 5158: ** Examples: 5159: ** 5160: ** ieee754(2.0) -> 'ieee754(2,0)' 5161: ** ieee754(45.25) -> 'ieee754(181,-2)' 5162: ** ieee754(2, 0) -> 2.0 5163: ** ieee754(181, -2) -> 45.25 5164: ** 5165: ** Two additional functions break apart the one-argument ieee754() 5166: ** result into separate integer values: 5167: ** 5168: ** ieee754_mantissa(45.25) -> 181 5169: ** ieee754_exponent(45.25) -> -2 5170: ** 5171: ** These functions convert binary64 numbers into blobs and back again. 5172: ** 5173: ** ieee754_from_blob(x'3ff0000000000000') -> 1.0 5174: ** ieee754_to_blob(1.0) -> x'3ff0000000000000' 5175: ** 5176: ** In all single-argument functions, if the argument is an 8-byte blob 5177: ** then that blob is interpreted as a big-endian binary64 value. 5178: ** 5179: ** 5180: ** EXACT DECIMAL REPRESENTATION OF BINARY64 VALUES 5181: ** ----------------------------------------------- 5182: ** 5183: ** This extension in combination with the separate 'decimal' extension 5184: ** can be used to compute the exact decimal representation of binary64 5185: ** values. To begin, first compute a table of exponent values: 5186: ** 5187: ** CREATE TABLE pow2(x INTEGER PRIMARY KEY, v TEXT); 5188: ** WITH RECURSIVE c(x,v) AS ( 5189: ** VALUES(0,'1') 5190: ** UNION ALL 5191: ** SELECT x+1, decimal_mul(v,'2') FROM c WHERE x+1<=971 5192: ** ) INSERT INTO pow2(x,v) SELECT x, v FROM c; 5193: ** WITH RECURSIVE c(x,v) AS ( 5194: ** VALUES(-1,'0.5') 5195: ** UNION ALL 5196: ** SELECT x-1, decimal_mul(v,'0.5') FROM c WHERE x-1>=-1075 5197: ** ) INSERT INTO pow2(x,v) SELECT x, v FROM c; 5198: ** 5199: ** Then, to compute the exact decimal representation of a floating 5200: ** point value (the value 47.49 is used in the example) do: 5201: ** 5202: ** WITH c(n) AS (VALUES(47.49)) 5203: ** ---------------^^^^^---- Replace with whatever you want 5204: ** SELECT decimal_mul(ieee754_mantissa(c.n),pow2.v) 5205: ** FROM pow2, c WHERE pow2.x=ieee754_exponent(c.n); 5206: ** 5207: ** Here is a query to show various boundry values for the binary64 5208: ** number format: 5209: ** 5210: ** WITH c(name,bin) AS (VALUES 5211: ** ('minimum positive value', x'0000000000000001'), 5212: ** ('maximum subnormal value', x'000fffffffffffff'), 5213: ** ('mininum positive nornal value', x'0010000000000000'), 5214: ** ('maximum value', x'7fefffffffffffff')) 5215: ** SELECT c.name, decimal_mul(ieee754_mantissa(c.bin),pow2.v) 5216: ** FROM pow2, c WHERE pow2.x=ieee754_exponent(c.bin); 5217: ** 5218: */ 5219: /* #include "sqlite3ext.h" */ 5220: SQLITE_EXTENSION_INIT1 5221: #include <assert.h> 5222: #include <string.h> 5223: 5224: /* Mark a function parameter as unused, to suppress nuisance compiler 5225: ** warnings. */ 5226: #ifndef UNUSED_PARAMETER 5227: # define UNUSED_PARAMETER(X) (void)(X) 5228: #endif 5229: 5230: /* 5231: ** Implementation of the ieee754() function 5232: */ 5233: static void ieee754func( 5234: sqlite3_context *context, 5235: int argc, 5236: sqlite3_value **argv 5237: ){ 5238: if( argc==1 ){ 5239: sqlite3_int64 m, a; 5240: double r; 5241: int e; 5242: int isNeg; 5243: char zResult[100]; 5244: assert( sizeof(m)==sizeof(r) ); 5245: if( sqlite3_value_type(argv[0])==SQLITE_BLOB 5246: && sqlite3_value_bytes(argv[0])==sizeof(r) 5247: ){ 5248: const unsigned char *x = sqlite3_value_blob(argv[0]); 5249: unsigned int i; 5250: sqlite3_uint64 v = 0; 5251: for(i=0; i<sizeof(r); i++){ 5252: v = (v<<8) | x[i]; 5253: } 5254: memcpy(&r, &v, sizeof(r)); 5255: }else{ 5256: r = sqlite3_value_double(argv[0]); 5257: } 5258: if( r<0.0 ){ 5259: isNeg = 1; 5260: r = -r; 5261: }else{ 5262: isNeg = 0; 5263: } 5264: memcpy(&a,&r,sizeof(a)); 5265: if( a==0 ){ 5266: e = 0; 5267: m = 0; 5268: }else{ 5269: e = a>>52; 5270: m = a & ((((sqlite3_int64)1)<<52)-1); 5271: if( e==0 ){ 5272: m <<= 1; 5273: }else{ 5274: m |= ((sqlite3_int64)1)<<52; 5275: } 5276: while( e<1075 && m>0 && (m&1)==0 ){ 5277: m >>= 1; 5278: e++; 5279: } 5280: if( isNeg ) m = -m; 5281: } 5282: switch( *(int*)sqlite3_user_data(context) ){ 5283: case 0: 5284: sqlite3_snprintf(sizeof(zResult), zResult, "ieee754(%lld,%d)", 5285: m, e-1075); 5286: sqlite3_result_text(context, zResult, -1, SQLITE_TRANSIENT); 5287: break; 5288: case 1: 5289: sqlite3_result_int64(context, m); 5290: break; 5291: case 2: 5292: sqlite3_result_int(context, e-1075); 5293: break; 5294: } 5295: }else{ 5296: sqlite3_int64 m, e, a; 5297: double r; 5298: int isNeg = 0; 5299: m = sqlite3_value_int64(argv[0]); 5300: e = sqlite3_value_int64(argv[1]); 1.6 ! misho 5301: ! 5302: /* Limit the range of e. Ticket 22dea1cfdb9151e4 2021-03-02 */ ! 5303: if( e>10000 ){ ! 5304: e = 10000; ! 5305: }else if( e<-10000 ){ ! 5306: e = -10000; ! 5307: } ! 5308: 1.5 misho 5309: if( m<0 ){ 5310: isNeg = 1; 5311: m = -m; 5312: if( m<0 ) return; 5313: }else if( m==0 && e>-1000 && e<1000 ){ 5314: sqlite3_result_double(context, 0.0); 5315: return; 5316: } 5317: while( (m>>32)&0xffe00000 ){ 5318: m >>= 1; 5319: e++; 5320: } 5321: while( m!=0 && ((m>>32)&0xfff00000)==0 ){ 5322: m <<= 1; 5323: e--; 5324: } 5325: e += 1075; 5326: if( e<=0 ){ 5327: /* Subnormal */ 5328: m >>= 1-e; 5329: e = 0; 5330: }else if( e>0x7ff ){ 5331: e = 0x7ff; 5332: } 5333: a = m & ((((sqlite3_int64)1)<<52)-1); 5334: a |= e<<52; 5335: if( isNeg ) a |= ((sqlite3_uint64)1)<<63; 5336: memcpy(&r, &a, sizeof(r)); 5337: sqlite3_result_double(context, r); 5338: } 5339: } 5340: 5341: /* 5342: ** Functions to convert between blobs and floats. 5343: */ 5344: static void ieee754func_from_blob( 5345: sqlite3_context *context, 5346: int argc, 5347: sqlite3_value **argv 5348: ){ 5349: UNUSED_PARAMETER(argc); 5350: if( sqlite3_value_type(argv[0])==SQLITE_BLOB 5351: && sqlite3_value_bytes(argv[0])==sizeof(double) 5352: ){ 5353: double r; 5354: const unsigned char *x = sqlite3_value_blob(argv[0]); 5355: unsigned int i; 5356: sqlite3_uint64 v = 0; 5357: for(i=0; i<sizeof(r); i++){ 5358: v = (v<<8) | x[i]; 5359: } 5360: memcpy(&r, &v, sizeof(r)); 5361: sqlite3_result_double(context, r); 5362: } 5363: } 5364: static void ieee754func_to_blob( 5365: sqlite3_context *context, 5366: int argc, 5367: sqlite3_value **argv 5368: ){ 5369: UNUSED_PARAMETER(argc); 5370: if( sqlite3_value_type(argv[0])==SQLITE_FLOAT 5371: || sqlite3_value_type(argv[0])==SQLITE_INTEGER 5372: ){ 5373: double r = sqlite3_value_double(argv[0]); 5374: sqlite3_uint64 v; 5375: unsigned char a[sizeof(r)]; 5376: unsigned int i; 5377: memcpy(&v, &r, sizeof(r)); 5378: for(i=1; i<=sizeof(r); i++){ 5379: a[sizeof(r)-i] = v&0xff; 5380: v >>= 8; 5381: } 5382: sqlite3_result_blob(context, a, sizeof(r), SQLITE_TRANSIENT); 5383: } 5384: } 5385: 5386: 5387: #ifdef _WIN32 5388: 5389: #endif 5390: int sqlite3_ieee_init( 5391: sqlite3 *db, 5392: char **pzErrMsg, 5393: const sqlite3_api_routines *pApi 5394: ){ 5395: static const struct { 5396: char *zFName; 5397: int nArg; 5398: int iAux; 5399: void (*xFunc)(sqlite3_context*,int,sqlite3_value**); 5400: } aFunc[] = { 5401: { "ieee754", 1, 0, ieee754func }, 5402: { "ieee754", 2, 0, ieee754func }, 5403: { "ieee754_mantissa", 1, 1, ieee754func }, 5404: { "ieee754_exponent", 1, 2, ieee754func }, 5405: { "ieee754_to_blob", 1, 0, ieee754func_to_blob }, 5406: { "ieee754_from_blob", 1, 0, ieee754func_from_blob }, 5407: 5408: }; 5409: unsigned int i; 5410: int rc = SQLITE_OK; 5411: SQLITE_EXTENSION_INIT2(pApi); 5412: (void)pzErrMsg; /* Unused parameter */ 5413: for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){ 5414: rc = sqlite3_create_function(db, aFunc[i].zFName, aFunc[i].nArg, 5415: SQLITE_UTF8|SQLITE_INNOCUOUS, 5416: (void*)&aFunc[i].iAux, 5417: aFunc[i].xFunc, 0, 0); 5418: } 5419: return rc; 5420: } 5421: 5422: /************************* End ../ext/misc/ieee754.c ********************/ 1.6 ! misho 5423: /************************* Begin ../ext/misc/series.c ******************/ ! 5424: /* ! 5425: ** 2015-08-18 ! 5426: ** ! 5427: ** The author disclaims copyright to this source code. In place of ! 5428: ** a legal notice, here is a blessing: ! 5429: ** ! 5430: ** May you do good and not evil. ! 5431: ** May you find forgiveness for yourself and forgive others. ! 5432: ** May you share freely, never taking more than you give. ! 5433: ** ! 5434: ************************************************************************* ! 5435: ** ! 5436: ** This file demonstrates how to create a table-valued-function using ! 5437: ** a virtual table. This demo implements the generate_series() function ! 5438: ** which gives similar results to the eponymous function in PostgreSQL. ! 5439: ** Examples: ! 5440: ** ! 5441: ** SELECT * FROM generate_series(0,100,5); ! 5442: ** ! 5443: ** The query above returns integers from 0 through 100 counting by steps ! 5444: ** of 5. ! 5445: ** ! 5446: ** SELECT * FROM generate_series(0,100); ! 5447: ** ! 5448: ** Integers from 0 through 100 with a step size of 1. ! 5449: ** ! 5450: ** SELECT * FROM generate_series(20) LIMIT 10; ! 5451: ** ! 5452: ** Integers 20 through 29. ! 5453: ** ! 5454: ** HOW IT WORKS ! 5455: ** ! 5456: ** The generate_series "function" is really a virtual table with the ! 5457: ** following schema: ! 5458: ** ! 5459: ** CREATE TABLE generate_series( ! 5460: ** value, ! 5461: ** start HIDDEN, ! 5462: ** stop HIDDEN, ! 5463: ** step HIDDEN ! 5464: ** ); ! 5465: ** ! 5466: ** Function arguments in queries against this virtual table are translated ! 5467: ** into equality constraints against successive hidden columns. In other ! 5468: ** words, the following pairs of queries are equivalent to each other: ! 5469: ** ! 5470: ** SELECT * FROM generate_series(0,100,5); ! 5471: ** SELECT * FROM generate_series WHERE start=0 AND stop=100 AND step=5; ! 5472: ** ! 5473: ** SELECT * FROM generate_series(0,100); ! 5474: ** SELECT * FROM generate_series WHERE start=0 AND stop=100; ! 5475: ** ! 5476: ** SELECT * FROM generate_series(20) LIMIT 10; ! 5477: ** SELECT * FROM generate_series WHERE start=20 LIMIT 10; ! 5478: ** ! 5479: ** The generate_series virtual table implementation leaves the xCreate method ! 5480: ** set to NULL. This means that it is not possible to do a CREATE VIRTUAL ! 5481: ** TABLE command with "generate_series" as the USING argument. Instead, there ! 5482: ** is a single generate_series virtual table that is always available without ! 5483: ** having to be created first. ! 5484: ** ! 5485: ** The xBestIndex method looks for equality constraints against the hidden ! 5486: ** start, stop, and step columns, and if present, it uses those constraints ! 5487: ** to bound the sequence of generated values. If the equality constraints ! 5488: ** are missing, it uses 0 for start, 4294967295 for stop, and 1 for step. ! 5489: ** xBestIndex returns a small cost when both start and stop are available, ! 5490: ** and a very large cost if either start or stop are unavailable. This ! 5491: ** encourages the query planner to order joins such that the bounds of the ! 5492: ** series are well-defined. ! 5493: */ ! 5494: /* #include "sqlite3ext.h" */ ! 5495: SQLITE_EXTENSION_INIT1 ! 5496: #include <assert.h> ! 5497: #include <string.h> ! 5498: ! 5499: #ifndef SQLITE_OMIT_VIRTUALTABLE ! 5500: ! 5501: ! 5502: /* series_cursor is a subclass of sqlite3_vtab_cursor which will ! 5503: ** serve as the underlying representation of a cursor that scans ! 5504: ** over rows of the result ! 5505: */ ! 5506: typedef struct series_cursor series_cursor; ! 5507: struct series_cursor { ! 5508: sqlite3_vtab_cursor base; /* Base class - must be first */ ! 5509: int isDesc; /* True to count down rather than up */ ! 5510: sqlite3_int64 iRowid; /* The rowid */ ! 5511: sqlite3_int64 iValue; /* Current value ("value") */ ! 5512: sqlite3_int64 mnValue; /* Mimimum value ("start") */ ! 5513: sqlite3_int64 mxValue; /* Maximum value ("stop") */ ! 5514: sqlite3_int64 iStep; /* Increment ("step") */ ! 5515: }; ! 5516: ! 5517: /* ! 5518: ** The seriesConnect() method is invoked to create a new ! 5519: ** series_vtab that describes the generate_series virtual table. ! 5520: ** ! 5521: ** Think of this routine as the constructor for series_vtab objects. ! 5522: ** ! 5523: ** All this routine needs to do is: ! 5524: ** ! 5525: ** (1) Allocate the series_vtab object and initialize all fields. ! 5526: ** ! 5527: ** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the ! 5528: ** result set of queries against generate_series will look like. ! 5529: */ ! 5530: static int seriesConnect( ! 5531: sqlite3 *db, ! 5532: void *pUnused, ! 5533: int argcUnused, const char *const*argvUnused, ! 5534: sqlite3_vtab **ppVtab, ! 5535: char **pzErrUnused ! 5536: ){ ! 5537: sqlite3_vtab *pNew; ! 5538: int rc; ! 5539: ! 5540: /* Column numbers */ ! 5541: #define SERIES_COLUMN_VALUE 0 ! 5542: #define SERIES_COLUMN_START 1 ! 5543: #define SERIES_COLUMN_STOP 2 ! 5544: #define SERIES_COLUMN_STEP 3 ! 5545: ! 5546: (void)pUnused; ! 5547: (void)argcUnused; ! 5548: (void)argvUnused; ! 5549: (void)pzErrUnused; ! 5550: rc = sqlite3_declare_vtab(db, ! 5551: "CREATE TABLE x(value,start hidden,stop hidden,step hidden)"); ! 5552: if( rc==SQLITE_OK ){ ! 5553: pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) ); ! 5554: if( pNew==0 ) return SQLITE_NOMEM; ! 5555: memset(pNew, 0, sizeof(*pNew)); ! 5556: sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS); ! 5557: } ! 5558: return rc; ! 5559: } ! 5560: ! 5561: /* ! 5562: ** This method is the destructor for series_cursor objects. ! 5563: */ ! 5564: static int seriesDisconnect(sqlite3_vtab *pVtab){ ! 5565: sqlite3_free(pVtab); ! 5566: return SQLITE_OK; ! 5567: } ! 5568: ! 5569: /* ! 5570: ** Constructor for a new series_cursor object. ! 5571: */ ! 5572: static int seriesOpen(sqlite3_vtab *pUnused, sqlite3_vtab_cursor **ppCursor){ ! 5573: series_cursor *pCur; ! 5574: (void)pUnused; ! 5575: pCur = sqlite3_malloc( sizeof(*pCur) ); ! 5576: if( pCur==0 ) return SQLITE_NOMEM; ! 5577: memset(pCur, 0, sizeof(*pCur)); ! 5578: *ppCursor = &pCur->base; ! 5579: return SQLITE_OK; ! 5580: } ! 5581: ! 5582: /* ! 5583: ** Destructor for a series_cursor. ! 5584: */ ! 5585: static int seriesClose(sqlite3_vtab_cursor *cur){ ! 5586: sqlite3_free(cur); ! 5587: return SQLITE_OK; ! 5588: } ! 5589: ! 5590: ! 5591: /* ! 5592: ** Advance a series_cursor to its next row of output. ! 5593: */ ! 5594: static int seriesNext(sqlite3_vtab_cursor *cur){ ! 5595: series_cursor *pCur = (series_cursor*)cur; ! 5596: if( pCur->isDesc ){ ! 5597: pCur->iValue -= pCur->iStep; ! 5598: }else{ ! 5599: pCur->iValue += pCur->iStep; ! 5600: } ! 5601: pCur->iRowid++; ! 5602: return SQLITE_OK; ! 5603: } ! 5604: ! 5605: /* ! 5606: ** Return values of columns for the row at which the series_cursor ! 5607: ** is currently pointing. ! 5608: */ ! 5609: static int seriesColumn( ! 5610: sqlite3_vtab_cursor *cur, /* The cursor */ ! 5611: sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ ! 5612: int i /* Which column to return */ ! 5613: ){ ! 5614: series_cursor *pCur = (series_cursor*)cur; ! 5615: sqlite3_int64 x = 0; ! 5616: switch( i ){ ! 5617: case SERIES_COLUMN_START: x = pCur->mnValue; break; ! 5618: case SERIES_COLUMN_STOP: x = pCur->mxValue; break; ! 5619: case SERIES_COLUMN_STEP: x = pCur->iStep; break; ! 5620: default: x = pCur->iValue; break; ! 5621: } ! 5622: sqlite3_result_int64(ctx, x); ! 5623: return SQLITE_OK; ! 5624: } ! 5625: ! 5626: /* ! 5627: ** Return the rowid for the current row. In this implementation, the ! 5628: ** first row returned is assigned rowid value 1, and each subsequent ! 5629: ** row a value 1 more than that of the previous. ! 5630: */ ! 5631: static int seriesRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ ! 5632: series_cursor *pCur = (series_cursor*)cur; ! 5633: *pRowid = pCur->iRowid; ! 5634: return SQLITE_OK; ! 5635: } ! 5636: ! 5637: /* ! 5638: ** Return TRUE if the cursor has been moved off of the last ! 5639: ** row of output. ! 5640: */ ! 5641: static int seriesEof(sqlite3_vtab_cursor *cur){ ! 5642: series_cursor *pCur = (series_cursor*)cur; ! 5643: if( pCur->isDesc ){ ! 5644: return pCur->iValue < pCur->mnValue; ! 5645: }else{ ! 5646: return pCur->iValue > pCur->mxValue; ! 5647: } ! 5648: } ! 5649: ! 5650: /* True to cause run-time checking of the start=, stop=, and/or step= ! 5651: ** parameters. The only reason to do this is for testing the ! 5652: ** constraint checking logic for virtual tables in the SQLite core. ! 5653: */ ! 5654: #ifndef SQLITE_SERIES_CONSTRAINT_VERIFY ! 5655: # define SQLITE_SERIES_CONSTRAINT_VERIFY 0 ! 5656: #endif ! 5657: ! 5658: /* ! 5659: ** This method is called to "rewind" the series_cursor object back ! 5660: ** to the first row of output. This method is always called at least ! 5661: ** once prior to any call to seriesColumn() or seriesRowid() or ! 5662: ** seriesEof(). ! 5663: ** ! 5664: ** The query plan selected by seriesBestIndex is passed in the idxNum ! 5665: ** parameter. (idxStr is not used in this implementation.) idxNum ! 5666: ** is a bitmask showing which constraints are available: ! 5667: ** ! 5668: ** 1: start=VALUE ! 5669: ** 2: stop=VALUE ! 5670: ** 4: step=VALUE ! 5671: ** ! 5672: ** Also, if bit 8 is set, that means that the series should be output ! 5673: ** in descending order rather than in ascending order. If bit 16 is ! 5674: ** set, then output must appear in ascending order. ! 5675: ** ! 5676: ** This routine should initialize the cursor and position it so that it ! 5677: ** is pointing at the first row, or pointing off the end of the table ! 5678: ** (so that seriesEof() will return true) if the table is empty. ! 5679: */ ! 5680: static int seriesFilter( ! 5681: sqlite3_vtab_cursor *pVtabCursor, ! 5682: int idxNum, const char *idxStrUnused, ! 5683: int argc, sqlite3_value **argv ! 5684: ){ ! 5685: series_cursor *pCur = (series_cursor *)pVtabCursor; ! 5686: int i = 0; ! 5687: (void)idxStrUnused; ! 5688: if( idxNum & 1 ){ ! 5689: pCur->mnValue = sqlite3_value_int64(argv[i++]); ! 5690: }else{ ! 5691: pCur->mnValue = 0; ! 5692: } ! 5693: if( idxNum & 2 ){ ! 5694: pCur->mxValue = sqlite3_value_int64(argv[i++]); ! 5695: }else{ ! 5696: pCur->mxValue = 0xffffffff; ! 5697: } ! 5698: if( idxNum & 4 ){ ! 5699: pCur->iStep = sqlite3_value_int64(argv[i++]); ! 5700: if( pCur->iStep==0 ){ ! 5701: pCur->iStep = 1; ! 5702: }else if( pCur->iStep<0 ){ ! 5703: pCur->iStep = -pCur->iStep; ! 5704: if( (idxNum & 16)==0 ) idxNum |= 8; ! 5705: } ! 5706: }else{ ! 5707: pCur->iStep = 1; ! 5708: } ! 5709: for(i=0; i<argc; i++){ ! 5710: if( sqlite3_value_type(argv[i])==SQLITE_NULL ){ ! 5711: /* If any of the constraints have a NULL value, then return no rows. ! 5712: ** See ticket https://www.sqlite.org/src/info/fac496b61722daf2 */ ! 5713: pCur->mnValue = 1; ! 5714: pCur->mxValue = 0; ! 5715: break; ! 5716: } ! 5717: } ! 5718: if( idxNum & 8 ){ ! 5719: pCur->isDesc = 1; ! 5720: pCur->iValue = pCur->mxValue; ! 5721: if( pCur->iStep>0 ){ ! 5722: pCur->iValue -= (pCur->mxValue - pCur->mnValue)%pCur->iStep; ! 5723: } ! 5724: }else{ ! 5725: pCur->isDesc = 0; ! 5726: pCur->iValue = pCur->mnValue; ! 5727: } ! 5728: pCur->iRowid = 1; ! 5729: return SQLITE_OK; ! 5730: } ! 5731: ! 5732: /* ! 5733: ** SQLite will invoke this method one or more times while planning a query ! 5734: ** that uses the generate_series virtual table. This routine needs to create ! 5735: ** a query plan for each invocation and compute an estimated cost for that ! 5736: ** plan. ! 5737: ** ! 5738: ** In this implementation idxNum is used to represent the ! 5739: ** query plan. idxStr is unused. ! 5740: ** ! 5741: ** The query plan is represented by bits in idxNum: ! 5742: ** ! 5743: ** (1) start = $value -- constraint exists ! 5744: ** (2) stop = $value -- constraint exists ! 5745: ** (4) step = $value -- constraint exists ! 5746: ** (8) output in descending order ! 5747: */ ! 5748: static int seriesBestIndex( ! 5749: sqlite3_vtab *tabUnused, ! 5750: sqlite3_index_info *pIdxInfo ! 5751: ){ ! 5752: int i, j; /* Loop over constraints */ ! 5753: int idxNum = 0; /* The query plan bitmask */ ! 5754: int unusableMask = 0; /* Mask of unusable constraints */ ! 5755: int nArg = 0; /* Number of arguments that seriesFilter() expects */ ! 5756: int aIdx[3]; /* Constraints on start, stop, and step */ ! 5757: const struct sqlite3_index_constraint *pConstraint; ! 5758: ! 5759: /* This implementation assumes that the start, stop, and step columns ! 5760: ** are the last three columns in the virtual table. */ ! 5761: assert( SERIES_COLUMN_STOP == SERIES_COLUMN_START+1 ); ! 5762: assert( SERIES_COLUMN_STEP == SERIES_COLUMN_START+2 ); ! 5763: (void)tabUnused; ! 5764: aIdx[0] = aIdx[1] = aIdx[2] = -1; ! 5765: pConstraint = pIdxInfo->aConstraint; ! 5766: for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ ! 5767: int iCol; /* 0 for start, 1 for stop, 2 for step */ ! 5768: int iMask; /* bitmask for those column */ ! 5769: if( pConstraint->iColumn<SERIES_COLUMN_START ) continue; ! 5770: iCol = pConstraint->iColumn - SERIES_COLUMN_START; ! 5771: assert( iCol>=0 && iCol<=2 ); ! 5772: iMask = 1 << iCol; ! 5773: if( pConstraint->usable==0 ){ ! 5774: unusableMask |= iMask; ! 5775: continue; ! 5776: }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){ ! 5777: idxNum |= iMask; ! 5778: aIdx[iCol] = i; ! 5779: } ! 5780: } ! 5781: for(i=0; i<3; i++){ ! 5782: if( (j = aIdx[i])>=0 ){ ! 5783: pIdxInfo->aConstraintUsage[j].argvIndex = ++nArg; ! 5784: pIdxInfo->aConstraintUsage[j].omit = !SQLITE_SERIES_CONSTRAINT_VERIFY; ! 5785: } ! 5786: } ! 5787: if( (unusableMask & ~idxNum)!=0 ){ ! 5788: /* The start, stop, and step columns are inputs. Therefore if there ! 5789: ** are unusable constraints on any of start, stop, or step then ! 5790: ** this plan is unusable */ ! 5791: return SQLITE_CONSTRAINT; ! 5792: } ! 5793: if( (idxNum & 3)==3 ){ ! 5794: /* Both start= and stop= boundaries are available. This is the ! 5795: ** the preferred case */ ! 5796: pIdxInfo->estimatedCost = (double)(2 - ((idxNum&4)!=0)); ! 5797: pIdxInfo->estimatedRows = 1000; ! 5798: if( pIdxInfo->nOrderBy==1 ){ ! 5799: if( pIdxInfo->aOrderBy[0].desc ){ ! 5800: idxNum |= 8; ! 5801: }else{ ! 5802: idxNum |= 16; ! 5803: } ! 5804: pIdxInfo->orderByConsumed = 1; ! 5805: } ! 5806: }else{ ! 5807: /* If either boundary is missing, we have to generate a huge span ! 5808: ** of numbers. Make this case very expensive so that the query ! 5809: ** planner will work hard to avoid it. */ ! 5810: pIdxInfo->estimatedRows = 2147483647; ! 5811: } ! 5812: pIdxInfo->idxNum = idxNum; ! 5813: return SQLITE_OK; ! 5814: } ! 5815: ! 5816: /* ! 5817: ** This following structure defines all the methods for the ! 5818: ** generate_series virtual table. ! 5819: */ ! 5820: static sqlite3_module seriesModule = { ! 5821: 0, /* iVersion */ ! 5822: 0, /* xCreate */ ! 5823: seriesConnect, /* xConnect */ ! 5824: seriesBestIndex, /* xBestIndex */ ! 5825: seriesDisconnect, /* xDisconnect */ ! 5826: 0, /* xDestroy */ ! 5827: seriesOpen, /* xOpen - open a cursor */ ! 5828: seriesClose, /* xClose - close a cursor */ ! 5829: seriesFilter, /* xFilter - configure scan constraints */ ! 5830: seriesNext, /* xNext - advance a cursor */ ! 5831: seriesEof, /* xEof - check for end of scan */ ! 5832: seriesColumn, /* xColumn - read data */ ! 5833: seriesRowid, /* xRowid - read data */ ! 5834: 0, /* xUpdate */ ! 5835: 0, /* xBegin */ ! 5836: 0, /* xSync */ ! 5837: 0, /* xCommit */ ! 5838: 0, /* xRollback */ ! 5839: 0, /* xFindMethod */ ! 5840: 0, /* xRename */ ! 5841: 0, /* xSavepoint */ ! 5842: 0, /* xRelease */ ! 5843: 0, /* xRollbackTo */ ! 5844: 0 /* xShadowName */ ! 5845: }; ! 5846: ! 5847: #endif /* SQLITE_OMIT_VIRTUALTABLE */ ! 5848: ! 5849: #ifdef _WIN32 ! 5850: ! 5851: #endif ! 5852: int sqlite3_series_init( ! 5853: sqlite3 *db, ! 5854: char **pzErrMsg, ! 5855: const sqlite3_api_routines *pApi ! 5856: ){ ! 5857: int rc = SQLITE_OK; ! 5858: SQLITE_EXTENSION_INIT2(pApi); ! 5859: #ifndef SQLITE_OMIT_VIRTUALTABLE ! 5860: if( sqlite3_libversion_number()<3008012 ){ ! 5861: *pzErrMsg = sqlite3_mprintf( ! 5862: "generate_series() requires SQLite 3.8.12 or later"); ! 5863: return SQLITE_ERROR; ! 5864: } ! 5865: rc = sqlite3_create_module(db, "generate_series", &seriesModule, 0); ! 5866: #endif ! 5867: return rc; ! 5868: } ! 5869: ! 5870: /************************* End ../ext/misc/series.c ********************/ 1.5 misho 5871: #ifdef SQLITE_HAVE_ZLIB 5872: /************************* Begin ../ext/misc/zipfile.c ******************/ 5873: /* 5874: ** 2017-12-26 5875: ** 5876: ** The author disclaims copyright to this source code. In place of 5877: ** a legal notice, here is a blessing: 5878: ** 5879: ** May you do good and not evil. 5880: ** May you find forgiveness for yourself and forgive others. 5881: ** May you share freely, never taking more than you give. 5882: ** 5883: ****************************************************************************** 5884: ** 5885: ** This file implements a virtual table for reading and writing ZIP archive 5886: ** files. 5887: ** 5888: ** Usage example: 5889: ** 5890: ** SELECT name, sz, datetime(mtime,'unixepoch') FROM zipfile($filename); 5891: ** 5892: ** Current limitations: 5893: ** 5894: ** * No support for encryption 5895: ** * No support for ZIP archives spanning multiple files 5896: ** * No support for zip64 extensions 5897: ** * Only the "inflate/deflate" (zlib) compression method is supported 5898: */ 5899: /* #include "sqlite3ext.h" */ 5900: SQLITE_EXTENSION_INIT1 5901: #include <stdio.h> 5902: #include <string.h> 5903: #include <assert.h> 5904: 5905: #include <zlib.h> 5906: 5907: #ifndef SQLITE_OMIT_VIRTUALTABLE 5908: 5909: #ifndef SQLITE_AMALGAMATION 5910: 5911: /* typedef sqlite3_int64 i64; */ 5912: /* typedef unsigned char u8; */ 5913: typedef unsigned short u16; 5914: typedef unsigned long u32; 5915: #define MIN(a,b) ((a)<(b) ? (a) : (b)) 5916: 5917: #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) 5918: # define ALWAYS(X) (1) 5919: # define NEVER(X) (0) 5920: #elif !defined(NDEBUG) 5921: # define ALWAYS(X) ((X)?1:(assert(0),0)) 5922: # define NEVER(X) ((X)?(assert(0),1):0) 5923: #else 5924: # define ALWAYS(X) (X) 5925: # define NEVER(X) (X) 5926: #endif 5927: 5928: #endif /* SQLITE_AMALGAMATION */ 5929: 5930: /* 5931: ** Definitions for mode bitmasks S_IFDIR, S_IFREG and S_IFLNK. 5932: ** 5933: ** In some ways it would be better to obtain these values from system 5934: ** header files. But, the dependency is undesirable and (a) these 5935: ** have been stable for decades, (b) the values are part of POSIX and 5936: ** are also made explicit in [man stat], and (c) are part of the 5937: ** file format for zip archives. 5938: */ 5939: #ifndef S_IFDIR 5940: # define S_IFDIR 0040000 5941: #endif 5942: #ifndef S_IFREG 5943: # define S_IFREG 0100000 5944: #endif 5945: #ifndef S_IFLNK 5946: # define S_IFLNK 0120000 5947: #endif 5948: 5949: static const char ZIPFILE_SCHEMA[] = 5950: "CREATE TABLE y(" 5951: "name PRIMARY KEY," /* 0: Name of file in zip archive */ 5952: "mode," /* 1: POSIX mode for file */ 5953: "mtime," /* 2: Last modification time (secs since 1970)*/ 5954: "sz," /* 3: Size of object */ 5955: "rawdata," /* 4: Raw data */ 5956: "data," /* 5: Uncompressed data */ 5957: "method," /* 6: Compression method (integer) */ 5958: "z HIDDEN" /* 7: Name of zip file */ 5959: ") WITHOUT ROWID;"; 5960: 5961: #define ZIPFILE_F_COLUMN_IDX 7 /* Index of column "file" in the above */ 5962: #define ZIPFILE_BUFFER_SIZE (64*1024) 5963: 5964: 5965: /* 5966: ** Magic numbers used to read and write zip files. 5967: ** 5968: ** ZIPFILE_NEWENTRY_MADEBY: 5969: ** Use this value for the "version-made-by" field in new zip file 5970: ** entries. The upper byte indicates "unix", and the lower byte 5971: ** indicates that the zip file matches pkzip specification 3.0. 5972: ** This is what info-zip seems to do. 5973: ** 5974: ** ZIPFILE_NEWENTRY_REQUIRED: 5975: ** Value for "version-required-to-extract" field of new entries. 5976: ** Version 2.0 is required to support folders and deflate compression. 5977: ** 5978: ** ZIPFILE_NEWENTRY_FLAGS: 5979: ** Value for "general-purpose-bit-flags" field of new entries. Bit 5980: ** 11 means "utf-8 filename and comment". 5981: ** 5982: ** ZIPFILE_SIGNATURE_CDS: 5983: ** First 4 bytes of a valid CDS record. 5984: ** 5985: ** ZIPFILE_SIGNATURE_LFH: 5986: ** First 4 bytes of a valid LFH record. 5987: ** 5988: ** ZIPFILE_SIGNATURE_EOCD 5989: ** First 4 bytes of a valid EOCD record. 5990: */ 5991: #define ZIPFILE_EXTRA_TIMESTAMP 0x5455 5992: #define ZIPFILE_NEWENTRY_MADEBY ((3<<8) + 30) 5993: #define ZIPFILE_NEWENTRY_REQUIRED 20 5994: #define ZIPFILE_NEWENTRY_FLAGS 0x800 5995: #define ZIPFILE_SIGNATURE_CDS 0x02014b50 5996: #define ZIPFILE_SIGNATURE_LFH 0x04034b50 5997: #define ZIPFILE_SIGNATURE_EOCD 0x06054b50 5998: 5999: /* 6000: ** The sizes of the fixed-size part of each of the three main data 6001: ** structures in a zip archive. 6002: */ 6003: #define ZIPFILE_LFH_FIXED_SZ 30 6004: #define ZIPFILE_EOCD_FIXED_SZ 22 6005: #define ZIPFILE_CDS_FIXED_SZ 46 6006: 6007: /* 6008: *** 4.3.16 End of central directory record: 6009: *** 6010: *** end of central dir signature 4 bytes (0x06054b50) 6011: *** number of this disk 2 bytes 6012: *** number of the disk with the 6013: *** start of the central directory 2 bytes 6014: *** total number of entries in the 6015: *** central directory on this disk 2 bytes 6016: *** total number of entries in 6017: *** the central directory 2 bytes 6018: *** size of the central directory 4 bytes 6019: *** offset of start of central 6020: *** directory with respect to 6021: *** the starting disk number 4 bytes 6022: *** .ZIP file comment length 2 bytes 6023: *** .ZIP file comment (variable size) 6024: */ 6025: typedef struct ZipfileEOCD ZipfileEOCD; 6026: struct ZipfileEOCD { 6027: u16 iDisk; 6028: u16 iFirstDisk; 6029: u16 nEntry; 6030: u16 nEntryTotal; 6031: u32 nSize; 6032: u32 iOffset; 6033: }; 6034: 6035: /* 6036: *** 4.3.12 Central directory structure: 6037: *** 6038: *** ... 6039: *** 6040: *** central file header signature 4 bytes (0x02014b50) 6041: *** version made by 2 bytes 6042: *** version needed to extract 2 bytes 6043: *** general purpose bit flag 2 bytes 6044: *** compression method 2 bytes 6045: *** last mod file time 2 bytes 6046: *** last mod file date 2 bytes 6047: *** crc-32 4 bytes 6048: *** compressed size 4 bytes 6049: *** uncompressed size 4 bytes 6050: *** file name length 2 bytes 6051: *** extra field length 2 bytes 6052: *** file comment length 2 bytes 6053: *** disk number start 2 bytes 6054: *** internal file attributes 2 bytes 6055: *** external file attributes 4 bytes 6056: *** relative offset of local header 4 bytes 6057: */ 6058: typedef struct ZipfileCDS ZipfileCDS; 6059: struct ZipfileCDS { 6060: u16 iVersionMadeBy; 6061: u16 iVersionExtract; 6062: u16 flags; 6063: u16 iCompression; 6064: u16 mTime; 6065: u16 mDate; 6066: u32 crc32; 6067: u32 szCompressed; 6068: u32 szUncompressed; 6069: u16 nFile; 6070: u16 nExtra; 6071: u16 nComment; 6072: u16 iDiskStart; 6073: u16 iInternalAttr; 6074: u32 iExternalAttr; 6075: u32 iOffset; 6076: char *zFile; /* Filename (sqlite3_malloc()) */ 6077: }; 6078: 6079: /* 6080: *** 4.3.7 Local file header: 6081: *** 6082: *** local file header signature 4 bytes (0x04034b50) 6083: *** version needed to extract 2 bytes 6084: *** general purpose bit flag 2 bytes 6085: *** compression method 2 bytes 6086: *** last mod file time 2 bytes 6087: *** last mod file date 2 bytes 6088: *** crc-32 4 bytes 6089: *** compressed size 4 bytes 6090: *** uncompressed size 4 bytes 6091: *** file name length 2 bytes 6092: *** extra field length 2 bytes 6093: *** 6094: */ 6095: typedef struct ZipfileLFH ZipfileLFH; 6096: struct ZipfileLFH { 6097: u16 iVersionExtract; 6098: u16 flags; 6099: u16 iCompression; 6100: u16 mTime; 6101: u16 mDate; 6102: u32 crc32; 6103: u32 szCompressed; 6104: u32 szUncompressed; 6105: u16 nFile; 6106: u16 nExtra; 6107: }; 6108: 6109: typedef struct ZipfileEntry ZipfileEntry; 6110: struct ZipfileEntry { 6111: ZipfileCDS cds; /* Parsed CDS record */ 6112: u32 mUnixTime; /* Modification time, in UNIX format */ 6113: u8 *aExtra; /* cds.nExtra+cds.nComment bytes of extra data */ 6114: i64 iDataOff; /* Offset to data in file (if aData==0) */ 6115: u8 *aData; /* cds.szCompressed bytes of compressed data */ 6116: ZipfileEntry *pNext; /* Next element in in-memory CDS */ 6117: }; 6118: 6119: /* 6120: ** Cursor type for zipfile tables. 6121: */ 6122: typedef struct ZipfileCsr ZipfileCsr; 6123: struct ZipfileCsr { 6124: sqlite3_vtab_cursor base; /* Base class - must be first */ 6125: i64 iId; /* Cursor ID */ 6126: u8 bEof; /* True when at EOF */ 6127: u8 bNoop; /* If next xNext() call is no-op */ 6128: 6129: /* Used outside of write transactions */ 6130: FILE *pFile; /* Zip file */ 6131: i64 iNextOff; /* Offset of next record in central directory */ 6132: ZipfileEOCD eocd; /* Parse of central directory record */ 6133: 6134: ZipfileEntry *pFreeEntry; /* Free this list when cursor is closed or reset */ 6135: ZipfileEntry *pCurrent; /* Current entry */ 6136: ZipfileCsr *pCsrNext; /* Next cursor on same virtual table */ 6137: }; 6138: 6139: typedef struct ZipfileTab ZipfileTab; 6140: struct ZipfileTab { 6141: sqlite3_vtab base; /* Base class - must be first */ 6142: char *zFile; /* Zip file this table accesses (may be NULL) */ 6143: sqlite3 *db; /* Host database connection */ 6144: u8 *aBuffer; /* Temporary buffer used for various tasks */ 6145: 6146: ZipfileCsr *pCsrList; /* List of cursors */ 6147: i64 iNextCsrid; 6148: 6149: /* The following are used by write transactions only */ 6150: ZipfileEntry *pFirstEntry; /* Linked list of all files (if pWriteFd!=0) */ 6151: ZipfileEntry *pLastEntry; /* Last element in pFirstEntry list */ 6152: FILE *pWriteFd; /* File handle open on zip archive */ 6153: i64 szCurrent; /* Current size of zip archive */ 6154: i64 szOrig; /* Size of archive at start of transaction */ 6155: }; 6156: 6157: /* 6158: ** Set the error message contained in context ctx to the results of 6159: ** vprintf(zFmt, ...). 6160: */ 6161: static void zipfileCtxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){ 6162: char *zMsg = 0; 6163: va_list ap; 6164: va_start(ap, zFmt); 6165: zMsg = sqlite3_vmprintf(zFmt, ap); 6166: sqlite3_result_error(ctx, zMsg, -1); 6167: sqlite3_free(zMsg); 6168: va_end(ap); 6169: } 6170: 6171: /* 6172: ** If string zIn is quoted, dequote it in place. Otherwise, if the string 6173: ** is not quoted, do nothing. 6174: */ 6175: static void zipfileDequote(char *zIn){ 6176: char q = zIn[0]; 6177: if( q=='"' || q=='\'' || q=='`' || q=='[' ){ 6178: int iIn = 1; 6179: int iOut = 0; 6180: if( q=='[' ) q = ']'; 6181: while( ALWAYS(zIn[iIn]) ){ 6182: char c = zIn[iIn++]; 6183: if( c==q && zIn[iIn++]!=q ) break; 6184: zIn[iOut++] = c; 6185: } 6186: zIn[iOut] = '\0'; 6187: } 6188: } 6189: 6190: /* 6191: ** Construct a new ZipfileTab virtual table object. 6192: ** 6193: ** argv[0] -> module name ("zipfile") 6194: ** argv[1] -> database name 6195: ** argv[2] -> table name 6196: ** argv[...] -> "column name" and other module argument fields. 6197: */ 6198: static int zipfileConnect( 6199: sqlite3 *db, 6200: void *pAux, 6201: int argc, const char *const*argv, 6202: sqlite3_vtab **ppVtab, 6203: char **pzErr 6204: ){ 6205: int nByte = sizeof(ZipfileTab) + ZIPFILE_BUFFER_SIZE; 6206: int nFile = 0; 6207: const char *zFile = 0; 6208: ZipfileTab *pNew = 0; 6209: int rc; 6210: 6211: /* If the table name is not "zipfile", require that the argument be 6212: ** specified. This stops zipfile tables from being created as: 6213: ** 6214: ** CREATE VIRTUAL TABLE zzz USING zipfile(); 6215: ** 6216: ** It does not prevent: 6217: ** 6218: ** CREATE VIRTUAL TABLE zipfile USING zipfile(); 6219: */ 6220: assert( 0==sqlite3_stricmp(argv[0], "zipfile") ); 6221: if( (0!=sqlite3_stricmp(argv[2], "zipfile") && argc<4) || argc>4 ){ 6222: *pzErr = sqlite3_mprintf("zipfile constructor requires one argument"); 6223: return SQLITE_ERROR; 6224: } 6225: 6226: if( argc>3 ){ 6227: zFile = argv[3]; 6228: nFile = (int)strlen(zFile)+1; 6229: } 6230: 6231: rc = sqlite3_declare_vtab(db, ZIPFILE_SCHEMA); 6232: if( rc==SQLITE_OK ){ 6233: pNew = (ZipfileTab*)sqlite3_malloc64((sqlite3_int64)nByte+nFile); 6234: if( pNew==0 ) return SQLITE_NOMEM; 6235: memset(pNew, 0, nByte+nFile); 6236: pNew->db = db; 6237: pNew->aBuffer = (u8*)&pNew[1]; 6238: if( zFile ){ 6239: pNew->zFile = (char*)&pNew->aBuffer[ZIPFILE_BUFFER_SIZE]; 6240: memcpy(pNew->zFile, zFile, nFile); 6241: zipfileDequote(pNew->zFile); 6242: } 6243: } 6244: sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY); 6245: *ppVtab = (sqlite3_vtab*)pNew; 6246: return rc; 6247: } 6248: 6249: /* 6250: ** Free the ZipfileEntry structure indicated by the only argument. 6251: */ 6252: static void zipfileEntryFree(ZipfileEntry *p){ 6253: if( p ){ 6254: sqlite3_free(p->cds.zFile); 6255: sqlite3_free(p); 6256: } 6257: } 6258: 6259: /* 6260: ** Release resources that should be freed at the end of a write 6261: ** transaction. 6262: */ 6263: static void zipfileCleanupTransaction(ZipfileTab *pTab){ 6264: ZipfileEntry *pEntry; 6265: ZipfileEntry *pNext; 6266: 6267: if( pTab->pWriteFd ){ 6268: fclose(pTab->pWriteFd); 6269: pTab->pWriteFd = 0; 6270: } 6271: for(pEntry=pTab->pFirstEntry; pEntry; pEntry=pNext){ 6272: pNext = pEntry->pNext; 6273: zipfileEntryFree(pEntry); 6274: } 6275: pTab->pFirstEntry = 0; 6276: pTab->pLastEntry = 0; 6277: pTab->szCurrent = 0; 6278: pTab->szOrig = 0; 6279: } 6280: 6281: /* 6282: ** This method is the destructor for zipfile vtab objects. 6283: */ 6284: static int zipfileDisconnect(sqlite3_vtab *pVtab){ 6285: zipfileCleanupTransaction((ZipfileTab*)pVtab); 6286: sqlite3_free(pVtab); 6287: return SQLITE_OK; 6288: } 6289: 6290: /* 6291: ** Constructor for a new ZipfileCsr object. 6292: */ 6293: static int zipfileOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCsr){ 6294: ZipfileTab *pTab = (ZipfileTab*)p; 6295: ZipfileCsr *pCsr; 6296: pCsr = sqlite3_malloc(sizeof(*pCsr)); 6297: *ppCsr = (sqlite3_vtab_cursor*)pCsr; 6298: if( pCsr==0 ){ 6299: return SQLITE_NOMEM; 6300: } 6301: memset(pCsr, 0, sizeof(*pCsr)); 6302: pCsr->iId = ++pTab->iNextCsrid; 6303: pCsr->pCsrNext = pTab->pCsrList; 6304: pTab->pCsrList = pCsr; 6305: return SQLITE_OK; 6306: } 6307: 6308: /* 6309: ** Reset a cursor back to the state it was in when first returned 6310: ** by zipfileOpen(). 6311: */ 6312: static void zipfileResetCursor(ZipfileCsr *pCsr){ 6313: ZipfileEntry *p; 6314: ZipfileEntry *pNext; 6315: 6316: pCsr->bEof = 0; 6317: if( pCsr->pFile ){ 6318: fclose(pCsr->pFile); 6319: pCsr->pFile = 0; 6320: zipfileEntryFree(pCsr->pCurrent); 6321: pCsr->pCurrent = 0; 6322: } 6323: 6324: for(p=pCsr->pFreeEntry; p; p=pNext){ 6325: pNext = p->pNext; 6326: zipfileEntryFree(p); 6327: } 6328: } 6329: 6330: /* 6331: ** Destructor for an ZipfileCsr. 6332: */ 6333: static int zipfileClose(sqlite3_vtab_cursor *cur){ 6334: ZipfileCsr *pCsr = (ZipfileCsr*)cur; 6335: ZipfileTab *pTab = (ZipfileTab*)(pCsr->base.pVtab); 6336: ZipfileCsr **pp; 6337: zipfileResetCursor(pCsr); 6338: 6339: /* Remove this cursor from the ZipfileTab.pCsrList list. */ 6340: for(pp=&pTab->pCsrList; *pp!=pCsr; pp=&((*pp)->pCsrNext)); 6341: *pp = pCsr->pCsrNext; 6342: 6343: sqlite3_free(pCsr); 6344: return SQLITE_OK; 6345: } 6346: 6347: /* 6348: ** Set the error message for the virtual table associated with cursor 6349: ** pCsr to the results of vprintf(zFmt, ...). 6350: */ 6351: static void zipfileTableErr(ZipfileTab *pTab, const char *zFmt, ...){ 6352: va_list ap; 6353: va_start(ap, zFmt); 6354: sqlite3_free(pTab->base.zErrMsg); 6355: pTab->base.zErrMsg = sqlite3_vmprintf(zFmt, ap); 6356: va_end(ap); 6357: } 6358: static void zipfileCursorErr(ZipfileCsr *pCsr, const char *zFmt, ...){ 6359: va_list ap; 6360: va_start(ap, zFmt); 6361: sqlite3_free(pCsr->base.pVtab->zErrMsg); 6362: pCsr->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap); 6363: va_end(ap); 6364: } 6365: 6366: /* 6367: ** Read nRead bytes of data from offset iOff of file pFile into buffer 6368: ** aRead[]. Return SQLITE_OK if successful, or an SQLite error code 6369: ** otherwise. 6370: ** 6371: ** If an error does occur, output variable (*pzErrmsg) may be set to point 6372: ** to an English language error message. It is the responsibility of the 6373: ** caller to eventually free this buffer using 6374: ** sqlite3_free(). 6375: */ 6376: static int zipfileReadData( 6377: FILE *pFile, /* Read from this file */ 6378: u8 *aRead, /* Read into this buffer */ 6379: int nRead, /* Number of bytes to read */ 6380: i64 iOff, /* Offset to read from */ 6381: char **pzErrmsg /* OUT: Error message (from sqlite3_malloc) */ 6382: ){ 6383: size_t n; 6384: fseek(pFile, (long)iOff, SEEK_SET); 6385: n = fread(aRead, 1, nRead, pFile); 6386: if( (int)n!=nRead ){ 6387: *pzErrmsg = sqlite3_mprintf("error in fread()"); 6388: return SQLITE_ERROR; 6389: } 6390: return SQLITE_OK; 6391: } 6392: 6393: static int zipfileAppendData( 6394: ZipfileTab *pTab, 6395: const u8 *aWrite, 6396: int nWrite 6397: ){ 1.6 ! misho 6398: if( nWrite>0 ){ ! 6399: size_t n = nWrite; ! 6400: fseek(pTab->pWriteFd, (long)pTab->szCurrent, SEEK_SET); ! 6401: n = fwrite(aWrite, 1, nWrite, pTab->pWriteFd); ! 6402: if( (int)n!=nWrite ){ ! 6403: pTab->base.zErrMsg = sqlite3_mprintf("error in fwrite()"); ! 6404: return SQLITE_ERROR; ! 6405: } ! 6406: pTab->szCurrent += nWrite; 1.5 misho 6407: } 6408: return SQLITE_OK; 6409: } 6410: 6411: /* 6412: ** Read and return a 16-bit little-endian unsigned integer from buffer aBuf. 6413: */ 6414: static u16 zipfileGetU16(const u8 *aBuf){ 6415: return (aBuf[1] << 8) + aBuf[0]; 6416: } 6417: 6418: /* 6419: ** Read and return a 32-bit little-endian unsigned integer from buffer aBuf. 6420: */ 6421: static u32 zipfileGetU32(const u8 *aBuf){ 6422: return ((u32)(aBuf[3]) << 24) 6423: + ((u32)(aBuf[2]) << 16) 6424: + ((u32)(aBuf[1]) << 8) 6425: + ((u32)(aBuf[0]) << 0); 6426: } 6427: 6428: /* 6429: ** Write a 16-bit little endiate integer into buffer aBuf. 6430: */ 6431: static void zipfilePutU16(u8 *aBuf, u16 val){ 6432: aBuf[0] = val & 0xFF; 6433: aBuf[1] = (val>>8) & 0xFF; 6434: } 6435: 6436: /* 6437: ** Write a 32-bit little endiate integer into buffer aBuf. 6438: */ 6439: static void zipfilePutU32(u8 *aBuf, u32 val){ 6440: aBuf[0] = val & 0xFF; 6441: aBuf[1] = (val>>8) & 0xFF; 6442: aBuf[2] = (val>>16) & 0xFF; 6443: aBuf[3] = (val>>24) & 0xFF; 6444: } 6445: 6446: #define zipfileRead32(aBuf) ( aBuf+=4, zipfileGetU32(aBuf-4) ) 6447: #define zipfileRead16(aBuf) ( aBuf+=2, zipfileGetU16(aBuf-2) ) 6448: 6449: #define zipfileWrite32(aBuf,val) { zipfilePutU32(aBuf,val); aBuf+=4; } 6450: #define zipfileWrite16(aBuf,val) { zipfilePutU16(aBuf,val); aBuf+=2; } 6451: 6452: /* 6453: ** Magic numbers used to read CDS records. 6454: */ 6455: #define ZIPFILE_CDS_NFILE_OFF 28 6456: #define ZIPFILE_CDS_SZCOMPRESSED_OFF 20 6457: 6458: /* 6459: ** Decode the CDS record in buffer aBuf into (*pCDS). Return SQLITE_ERROR 6460: ** if the record is not well-formed, or SQLITE_OK otherwise. 6461: */ 6462: static int zipfileReadCDS(u8 *aBuf, ZipfileCDS *pCDS){ 6463: u8 *aRead = aBuf; 6464: u32 sig = zipfileRead32(aRead); 6465: int rc = SQLITE_OK; 6466: if( sig!=ZIPFILE_SIGNATURE_CDS ){ 6467: rc = SQLITE_ERROR; 6468: }else{ 6469: pCDS->iVersionMadeBy = zipfileRead16(aRead); 6470: pCDS->iVersionExtract = zipfileRead16(aRead); 6471: pCDS->flags = zipfileRead16(aRead); 6472: pCDS->iCompression = zipfileRead16(aRead); 6473: pCDS->mTime = zipfileRead16(aRead); 6474: pCDS->mDate = zipfileRead16(aRead); 6475: pCDS->crc32 = zipfileRead32(aRead); 6476: pCDS->szCompressed = zipfileRead32(aRead); 6477: pCDS->szUncompressed = zipfileRead32(aRead); 6478: assert( aRead==&aBuf[ZIPFILE_CDS_NFILE_OFF] ); 6479: pCDS->nFile = zipfileRead16(aRead); 6480: pCDS->nExtra = zipfileRead16(aRead); 6481: pCDS->nComment = zipfileRead16(aRead); 6482: pCDS->iDiskStart = zipfileRead16(aRead); 6483: pCDS->iInternalAttr = zipfileRead16(aRead); 6484: pCDS->iExternalAttr = zipfileRead32(aRead); 6485: pCDS->iOffset = zipfileRead32(aRead); 6486: assert( aRead==&aBuf[ZIPFILE_CDS_FIXED_SZ] ); 6487: } 6488: 6489: return rc; 6490: } 6491: 6492: /* 6493: ** Decode the LFH record in buffer aBuf into (*pLFH). Return SQLITE_ERROR 6494: ** if the record is not well-formed, or SQLITE_OK otherwise. 6495: */ 6496: static int zipfileReadLFH( 6497: u8 *aBuffer, 6498: ZipfileLFH *pLFH 6499: ){ 6500: u8 *aRead = aBuffer; 6501: int rc = SQLITE_OK; 6502: 6503: u32 sig = zipfileRead32(aRead); 6504: if( sig!=ZIPFILE_SIGNATURE_LFH ){ 6505: rc = SQLITE_ERROR; 6506: }else{ 6507: pLFH->iVersionExtract = zipfileRead16(aRead); 6508: pLFH->flags = zipfileRead16(aRead); 6509: pLFH->iCompression = zipfileRead16(aRead); 6510: pLFH->mTime = zipfileRead16(aRead); 6511: pLFH->mDate = zipfileRead16(aRead); 6512: pLFH->crc32 = zipfileRead32(aRead); 6513: pLFH->szCompressed = zipfileRead32(aRead); 6514: pLFH->szUncompressed = zipfileRead32(aRead); 6515: pLFH->nFile = zipfileRead16(aRead); 6516: pLFH->nExtra = zipfileRead16(aRead); 6517: } 6518: return rc; 6519: } 6520: 6521: 6522: /* 6523: ** Buffer aExtra (size nExtra bytes) contains zip archive "extra" fields. 6524: ** Scan through this buffer to find an "extra-timestamp" field. If one 6525: ** exists, extract the 32-bit modification-timestamp from it and store 6526: ** the value in output parameter *pmTime. 6527: ** 6528: ** Zero is returned if no extra-timestamp record could be found (and so 6529: ** *pmTime is left unchanged), or non-zero otherwise. 6530: ** 6531: ** The general format of an extra field is: 6532: ** 6533: ** Header ID 2 bytes 6534: ** Data Size 2 bytes 6535: ** Data N bytes 6536: */ 6537: static int zipfileScanExtra(u8 *aExtra, int nExtra, u32 *pmTime){ 6538: int ret = 0; 6539: u8 *p = aExtra; 6540: u8 *pEnd = &aExtra[nExtra]; 6541: 6542: while( p<pEnd ){ 6543: u16 id = zipfileRead16(p); 6544: u16 nByte = zipfileRead16(p); 6545: 6546: switch( id ){ 6547: case ZIPFILE_EXTRA_TIMESTAMP: { 6548: u8 b = p[0]; 6549: if( b & 0x01 ){ /* 0x01 -> modtime is present */ 6550: *pmTime = zipfileGetU32(&p[1]); 6551: ret = 1; 6552: } 6553: break; 6554: } 6555: } 6556: 6557: p += nByte; 6558: } 6559: return ret; 6560: } 6561: 6562: /* 6563: ** Convert the standard MS-DOS timestamp stored in the mTime and mDate 6564: ** fields of the CDS structure passed as the only argument to a 32-bit 6565: ** UNIX seconds-since-the-epoch timestamp. Return the result. 6566: ** 6567: ** "Standard" MS-DOS time format: 6568: ** 6569: ** File modification time: 6570: ** Bits 00-04: seconds divided by 2 6571: ** Bits 05-10: minute 6572: ** Bits 11-15: hour 6573: ** File modification date: 6574: ** Bits 00-04: day 6575: ** Bits 05-08: month (1-12) 6576: ** Bits 09-15: years from 1980 6577: ** 6578: ** https://msdn.microsoft.com/en-us/library/9kkf9tah.aspx 6579: */ 6580: static u32 zipfileMtime(ZipfileCDS *pCDS){ 6581: int Y = (1980 + ((pCDS->mDate >> 9) & 0x7F)); 6582: int M = ((pCDS->mDate >> 5) & 0x0F); 6583: int D = (pCDS->mDate & 0x1F); 6584: int B = -13; 6585: 6586: int sec = (pCDS->mTime & 0x1F)*2; 6587: int min = (pCDS->mTime >> 5) & 0x3F; 6588: int hr = (pCDS->mTime >> 11) & 0x1F; 6589: i64 JD; 6590: 6591: /* JD = INT(365.25 * (Y+4716)) + INT(30.6001 * (M+1)) + D + B - 1524.5 */ 6592: 6593: /* Calculate the JD in seconds for noon on the day in question */ 6594: if( M<3 ){ 6595: Y = Y-1; 6596: M = M+12; 6597: } 6598: JD = (i64)(24*60*60) * ( 6599: (int)(365.25 * (Y + 4716)) 6600: + (int)(30.6001 * (M + 1)) 6601: + D + B - 1524 6602: ); 6603: 6604: /* Correct the JD for the time within the day */ 6605: JD += (hr-12) * 3600 + min * 60 + sec; 6606: 6607: /* Convert JD to unix timestamp (the JD epoch is 2440587.5) */ 6608: return (u32)(JD - (i64)(24405875) * 24*60*6); 6609: } 6610: 6611: /* 6612: ** The opposite of zipfileMtime(). This function populates the mTime and 6613: ** mDate fields of the CDS structure passed as the first argument according 6614: ** to the UNIX timestamp value passed as the second. 6615: */ 6616: static void zipfileMtimeToDos(ZipfileCDS *pCds, u32 mUnixTime){ 6617: /* Convert unix timestamp to JD (2440588 is noon on 1/1/1970) */ 6618: i64 JD = (i64)2440588 + mUnixTime / (24*60*60); 6619: 6620: int A, B, C, D, E; 6621: int yr, mon, day; 6622: int hr, min, sec; 6623: 6624: A = (int)((JD - 1867216.25)/36524.25); 6625: A = (int)(JD + 1 + A - (A/4)); 6626: B = A + 1524; 6627: C = (int)((B - 122.1)/365.25); 6628: D = (36525*(C&32767))/100; 6629: E = (int)((B-D)/30.6001); 6630: 6631: day = B - D - (int)(30.6001*E); 6632: mon = (E<14 ? E-1 : E-13); 6633: yr = mon>2 ? C-4716 : C-4715; 6634: 6635: hr = (mUnixTime % (24*60*60)) / (60*60); 6636: min = (mUnixTime % (60*60)) / 60; 6637: sec = (mUnixTime % 60); 6638: 6639: if( yr>=1980 ){ 6640: pCds->mDate = (u16)(day + (mon << 5) + ((yr-1980) << 9)); 6641: pCds->mTime = (u16)(sec/2 + (min<<5) + (hr<<11)); 6642: }else{ 6643: pCds->mDate = pCds->mTime = 0; 6644: } 6645: 6646: assert( mUnixTime<315507600 6647: || mUnixTime==zipfileMtime(pCds) 6648: || ((mUnixTime % 2) && mUnixTime-1==zipfileMtime(pCds)) 6649: /* || (mUnixTime % 2) */ 6650: ); 6651: } 6652: 6653: /* 6654: ** If aBlob is not NULL, then it is a pointer to a buffer (nBlob bytes in 6655: ** size) containing an entire zip archive image. Or, if aBlob is NULL, 6656: ** then pFile is a file-handle open on a zip file. In either case, this 6657: ** function creates a ZipfileEntry object based on the zip archive entry 6658: ** for which the CDS record is at offset iOff. 6659: ** 6660: ** If successful, SQLITE_OK is returned and (*ppEntry) set to point to 6661: ** the new object. Otherwise, an SQLite error code is returned and the 6662: ** final value of (*ppEntry) undefined. 6663: */ 6664: static int zipfileGetEntry( 6665: ZipfileTab *pTab, /* Store any error message here */ 6666: const u8 *aBlob, /* Pointer to in-memory file image */ 6667: int nBlob, /* Size of aBlob[] in bytes */ 6668: FILE *pFile, /* If aBlob==0, read from this file */ 6669: i64 iOff, /* Offset of CDS record */ 6670: ZipfileEntry **ppEntry /* OUT: Pointer to new object */ 6671: ){ 6672: u8 *aRead; 6673: char **pzErr = &pTab->base.zErrMsg; 6674: int rc = SQLITE_OK; 6675: 6676: if( aBlob==0 ){ 6677: aRead = pTab->aBuffer; 6678: rc = zipfileReadData(pFile, aRead, ZIPFILE_CDS_FIXED_SZ, iOff, pzErr); 6679: }else{ 6680: aRead = (u8*)&aBlob[iOff]; 6681: } 6682: 6683: if( rc==SQLITE_OK ){ 6684: sqlite3_int64 nAlloc; 6685: ZipfileEntry *pNew; 6686: 6687: int nFile = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF]); 6688: int nExtra = zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+2]); 6689: nExtra += zipfileGetU16(&aRead[ZIPFILE_CDS_NFILE_OFF+4]); 6690: 6691: nAlloc = sizeof(ZipfileEntry) + nExtra; 6692: if( aBlob ){ 6693: nAlloc += zipfileGetU32(&aRead[ZIPFILE_CDS_SZCOMPRESSED_OFF]); 6694: } 6695: 6696: pNew = (ZipfileEntry*)sqlite3_malloc64(nAlloc); 6697: if( pNew==0 ){ 6698: rc = SQLITE_NOMEM; 6699: }else{ 6700: memset(pNew, 0, sizeof(ZipfileEntry)); 6701: rc = zipfileReadCDS(aRead, &pNew->cds); 6702: if( rc!=SQLITE_OK ){ 6703: *pzErr = sqlite3_mprintf("failed to read CDS at offset %lld", iOff); 6704: }else if( aBlob==0 ){ 6705: rc = zipfileReadData( 6706: pFile, aRead, nExtra+nFile, iOff+ZIPFILE_CDS_FIXED_SZ, pzErr 6707: ); 6708: }else{ 6709: aRead = (u8*)&aBlob[iOff + ZIPFILE_CDS_FIXED_SZ]; 6710: } 6711: } 6712: 6713: if( rc==SQLITE_OK ){ 6714: u32 *pt = &pNew->mUnixTime; 6715: pNew->cds.zFile = sqlite3_mprintf("%.*s", nFile, aRead); 6716: pNew->aExtra = (u8*)&pNew[1]; 6717: memcpy(pNew->aExtra, &aRead[nFile], nExtra); 6718: if( pNew->cds.zFile==0 ){ 6719: rc = SQLITE_NOMEM; 6720: }else if( 0==zipfileScanExtra(&aRead[nFile], pNew->cds.nExtra, pt) ){ 6721: pNew->mUnixTime = zipfileMtime(&pNew->cds); 6722: } 6723: } 6724: 6725: if( rc==SQLITE_OK ){ 6726: static const int szFix = ZIPFILE_LFH_FIXED_SZ; 6727: ZipfileLFH lfh; 6728: if( pFile ){ 6729: rc = zipfileReadData(pFile, aRead, szFix, pNew->cds.iOffset, pzErr); 6730: }else{ 6731: aRead = (u8*)&aBlob[pNew->cds.iOffset]; 6732: } 6733: 6734: rc = zipfileReadLFH(aRead, &lfh); 6735: if( rc==SQLITE_OK ){ 6736: pNew->iDataOff = pNew->cds.iOffset + ZIPFILE_LFH_FIXED_SZ; 6737: pNew->iDataOff += lfh.nFile + lfh.nExtra; 6738: if( aBlob && pNew->cds.szCompressed ){ 6739: pNew->aData = &pNew->aExtra[nExtra]; 6740: memcpy(pNew->aData, &aBlob[pNew->iDataOff], pNew->cds.szCompressed); 6741: } 6742: }else{ 6743: *pzErr = sqlite3_mprintf("failed to read LFH at offset %d", 6744: (int)pNew->cds.iOffset 6745: ); 6746: } 6747: } 6748: 6749: if( rc!=SQLITE_OK ){ 6750: zipfileEntryFree(pNew); 6751: }else{ 6752: *ppEntry = pNew; 6753: } 6754: } 6755: 6756: return rc; 6757: } 6758: 6759: /* 6760: ** Advance an ZipfileCsr to its next row of output. 6761: */ 6762: static int zipfileNext(sqlite3_vtab_cursor *cur){ 6763: ZipfileCsr *pCsr = (ZipfileCsr*)cur; 6764: int rc = SQLITE_OK; 6765: 6766: if( pCsr->pFile ){ 6767: i64 iEof = pCsr->eocd.iOffset + pCsr->eocd.nSize; 6768: zipfileEntryFree(pCsr->pCurrent); 6769: pCsr->pCurrent = 0; 6770: if( pCsr->iNextOff>=iEof ){ 6771: pCsr->bEof = 1; 6772: }else{ 6773: ZipfileEntry *p = 0; 6774: ZipfileTab *pTab = (ZipfileTab*)(cur->pVtab); 6775: rc = zipfileGetEntry(pTab, 0, 0, pCsr->pFile, pCsr->iNextOff, &p); 6776: if( rc==SQLITE_OK ){ 6777: pCsr->iNextOff += ZIPFILE_CDS_FIXED_SZ; 6778: pCsr->iNextOff += (int)p->cds.nExtra + p->cds.nFile + p->cds.nComment; 6779: } 6780: pCsr->pCurrent = p; 6781: } 6782: }else{ 6783: if( !pCsr->bNoop ){ 6784: pCsr->pCurrent = pCsr->pCurrent->pNext; 6785: } 6786: if( pCsr->pCurrent==0 ){ 6787: pCsr->bEof = 1; 6788: } 6789: } 6790: 6791: pCsr->bNoop = 0; 6792: return rc; 6793: } 6794: 6795: static void zipfileFree(void *p) { 6796: sqlite3_free(p); 6797: } 6798: 6799: /* 6800: ** Buffer aIn (size nIn bytes) contains compressed data. Uncompressed, the 6801: ** size is nOut bytes. This function uncompresses the data and sets the 6802: ** return value in context pCtx to the result (a blob). 6803: ** 6804: ** If an error occurs, an error code is left in pCtx instead. 6805: */ 6806: static void zipfileInflate( 6807: sqlite3_context *pCtx, /* Store result here */ 6808: const u8 *aIn, /* Compressed data */ 6809: int nIn, /* Size of buffer aIn[] in bytes */ 6810: int nOut /* Expected output size */ 6811: ){ 6812: u8 *aRes = sqlite3_malloc(nOut); 6813: if( aRes==0 ){ 6814: sqlite3_result_error_nomem(pCtx); 6815: }else{ 6816: int err; 6817: z_stream str; 6818: memset(&str, 0, sizeof(str)); 6819: 6820: str.next_in = (Byte*)aIn; 6821: str.avail_in = nIn; 6822: str.next_out = (Byte*)aRes; 6823: str.avail_out = nOut; 6824: 6825: err = inflateInit2(&str, -15); 6826: if( err!=Z_OK ){ 6827: zipfileCtxErrorMsg(pCtx, "inflateInit2() failed (%d)", err); 6828: }else{ 6829: err = inflate(&str, Z_NO_FLUSH); 6830: if( err!=Z_STREAM_END ){ 6831: zipfileCtxErrorMsg(pCtx, "inflate() failed (%d)", err); 6832: }else{ 6833: sqlite3_result_blob(pCtx, aRes, nOut, zipfileFree); 6834: aRes = 0; 6835: } 6836: } 6837: sqlite3_free(aRes); 6838: inflateEnd(&str); 6839: } 6840: } 6841: 6842: /* 6843: ** Buffer aIn (size nIn bytes) contains uncompressed data. This function 6844: ** compresses it and sets (*ppOut) to point to a buffer containing the 6845: ** compressed data. The caller is responsible for eventually calling 6846: ** sqlite3_free() to release buffer (*ppOut). Before returning, (*pnOut) 6847: ** is set to the size of buffer (*ppOut) in bytes. 6848: ** 6849: ** If no error occurs, SQLITE_OK is returned. Otherwise, an SQLite error 6850: ** code is returned and an error message left in virtual-table handle 6851: ** pTab. The values of (*ppOut) and (*pnOut) are left unchanged in this 6852: ** case. 6853: */ 6854: static int zipfileDeflate( 6855: const u8 *aIn, int nIn, /* Input */ 6856: u8 **ppOut, int *pnOut, /* Output */ 6857: char **pzErr /* OUT: Error message */ 6858: ){ 6859: int rc = SQLITE_OK; 6860: sqlite3_int64 nAlloc; 6861: z_stream str; 6862: u8 *aOut; 6863: 6864: memset(&str, 0, sizeof(str)); 6865: str.next_in = (Bytef*)aIn; 6866: str.avail_in = nIn; 6867: deflateInit2(&str, 9, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY); 6868: 6869: nAlloc = deflateBound(&str, nIn); 6870: aOut = (u8*)sqlite3_malloc64(nAlloc); 6871: if( aOut==0 ){ 6872: rc = SQLITE_NOMEM; 6873: }else{ 6874: int res; 6875: str.next_out = aOut; 6876: str.avail_out = nAlloc; 6877: res = deflate(&str, Z_FINISH); 6878: if( res==Z_STREAM_END ){ 6879: *ppOut = aOut; 6880: *pnOut = (int)str.total_out; 6881: }else{ 6882: sqlite3_free(aOut); 6883: *pzErr = sqlite3_mprintf("zipfile: deflate() error"); 6884: rc = SQLITE_ERROR; 6885: } 6886: deflateEnd(&str); 6887: } 6888: 6889: return rc; 6890: } 6891: 6892: 6893: /* 6894: ** Return values of columns for the row at which the series_cursor 6895: ** is currently pointing. 6896: */ 6897: static int zipfileColumn( 6898: sqlite3_vtab_cursor *cur, /* The cursor */ 6899: sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 6900: int i /* Which column to return */ 6901: ){ 6902: ZipfileCsr *pCsr = (ZipfileCsr*)cur; 6903: ZipfileCDS *pCDS = &pCsr->pCurrent->cds; 6904: int rc = SQLITE_OK; 6905: switch( i ){ 6906: case 0: /* name */ 6907: sqlite3_result_text(ctx, pCDS->zFile, -1, SQLITE_TRANSIENT); 6908: break; 6909: case 1: /* mode */ 6910: /* TODO: Whether or not the following is correct surely depends on 6911: ** the platform on which the archive was created. */ 6912: sqlite3_result_int(ctx, pCDS->iExternalAttr >> 16); 6913: break; 6914: case 2: { /* mtime */ 6915: sqlite3_result_int64(ctx, pCsr->pCurrent->mUnixTime); 6916: break; 6917: } 6918: case 3: { /* sz */ 6919: if( sqlite3_vtab_nochange(ctx)==0 ){ 6920: sqlite3_result_int64(ctx, pCDS->szUncompressed); 6921: } 6922: break; 6923: } 6924: case 4: /* rawdata */ 6925: if( sqlite3_vtab_nochange(ctx) ) break; 6926: case 5: { /* data */ 6927: if( i==4 || pCDS->iCompression==0 || pCDS->iCompression==8 ){ 6928: int sz = pCDS->szCompressed; 6929: int szFinal = pCDS->szUncompressed; 6930: if( szFinal>0 ){ 6931: u8 *aBuf; 6932: u8 *aFree = 0; 6933: if( pCsr->pCurrent->aData ){ 6934: aBuf = pCsr->pCurrent->aData; 6935: }else{ 6936: aBuf = aFree = sqlite3_malloc64(sz); 6937: if( aBuf==0 ){ 6938: rc = SQLITE_NOMEM; 6939: }else{ 6940: FILE *pFile = pCsr->pFile; 6941: if( pFile==0 ){ 6942: pFile = ((ZipfileTab*)(pCsr->base.pVtab))->pWriteFd; 6943: } 6944: rc = zipfileReadData(pFile, aBuf, sz, pCsr->pCurrent->iDataOff, 6945: &pCsr->base.pVtab->zErrMsg 6946: ); 6947: } 6948: } 6949: if( rc==SQLITE_OK ){ 6950: if( i==5 && pCDS->iCompression ){ 6951: zipfileInflate(ctx, aBuf, sz, szFinal); 6952: }else{ 6953: sqlite3_result_blob(ctx, aBuf, sz, SQLITE_TRANSIENT); 6954: } 6955: } 6956: sqlite3_free(aFree); 6957: }else{ 6958: /* Figure out if this is a directory or a zero-sized file. Consider 6959: ** it to be a directory either if the mode suggests so, or if 6960: ** the final character in the name is '/'. */ 6961: u32 mode = pCDS->iExternalAttr >> 16; 6962: if( !(mode & S_IFDIR) && pCDS->zFile[pCDS->nFile-1]!='/' ){ 6963: sqlite3_result_blob(ctx, "", 0, SQLITE_STATIC); 6964: } 6965: } 6966: } 6967: break; 6968: } 6969: case 6: /* method */ 6970: sqlite3_result_int(ctx, pCDS->iCompression); 6971: break; 6972: default: /* z */ 6973: assert( i==7 ); 6974: sqlite3_result_int64(ctx, pCsr->iId); 6975: break; 6976: } 6977: 6978: return rc; 6979: } 6980: 6981: /* 6982: ** Return TRUE if the cursor is at EOF. 6983: */ 6984: static int zipfileEof(sqlite3_vtab_cursor *cur){ 6985: ZipfileCsr *pCsr = (ZipfileCsr*)cur; 6986: return pCsr->bEof; 6987: } 6988: 6989: /* 6990: ** If aBlob is not NULL, then it points to a buffer nBlob bytes in size 6991: ** containing an entire zip archive image. Or, if aBlob is NULL, then pFile 6992: ** is guaranteed to be a file-handle open on a zip file. 6993: ** 6994: ** This function attempts to locate the EOCD record within the zip archive 6995: ** and populate *pEOCD with the results of decoding it. SQLITE_OK is 6996: ** returned if successful. Otherwise, an SQLite error code is returned and 6997: ** an English language error message may be left in virtual-table pTab. 6998: */ 6999: static int zipfileReadEOCD( 7000: ZipfileTab *pTab, /* Return errors here */ 7001: const u8 *aBlob, /* Pointer to in-memory file image */ 7002: int nBlob, /* Size of aBlob[] in bytes */ 7003: FILE *pFile, /* Read from this file if aBlob==0 */ 7004: ZipfileEOCD *pEOCD /* Object to populate */ 7005: ){ 7006: u8 *aRead = pTab->aBuffer; /* Temporary buffer */ 7007: int nRead; /* Bytes to read from file */ 7008: int rc = SQLITE_OK; 7009: 7010: if( aBlob==0 ){ 7011: i64 iOff; /* Offset to read from */ 7012: i64 szFile; /* Total size of file in bytes */ 7013: fseek(pFile, 0, SEEK_END); 7014: szFile = (i64)ftell(pFile); 7015: if( szFile==0 ){ 7016: memset(pEOCD, 0, sizeof(ZipfileEOCD)); 7017: return SQLITE_OK; 7018: } 7019: nRead = (int)(MIN(szFile, ZIPFILE_BUFFER_SIZE)); 7020: iOff = szFile - nRead; 7021: rc = zipfileReadData(pFile, aRead, nRead, iOff, &pTab->base.zErrMsg); 7022: }else{ 7023: nRead = (int)(MIN(nBlob, ZIPFILE_BUFFER_SIZE)); 7024: aRead = (u8*)&aBlob[nBlob-nRead]; 7025: } 7026: 7027: if( rc==SQLITE_OK ){ 7028: int i; 7029: 7030: /* Scan backwards looking for the signature bytes */ 7031: for(i=nRead-20; i>=0; i--){ 7032: if( aRead[i]==0x50 && aRead[i+1]==0x4b 7033: && aRead[i+2]==0x05 && aRead[i+3]==0x06 7034: ){ 7035: break; 7036: } 7037: } 7038: if( i<0 ){ 7039: pTab->base.zErrMsg = sqlite3_mprintf( 7040: "cannot find end of central directory record" 7041: ); 7042: return SQLITE_ERROR; 7043: } 7044: 7045: aRead += i+4; 7046: pEOCD->iDisk = zipfileRead16(aRead); 7047: pEOCD->iFirstDisk = zipfileRead16(aRead); 7048: pEOCD->nEntry = zipfileRead16(aRead); 7049: pEOCD->nEntryTotal = zipfileRead16(aRead); 7050: pEOCD->nSize = zipfileRead32(aRead); 7051: pEOCD->iOffset = zipfileRead32(aRead); 7052: } 7053: 7054: return rc; 7055: } 7056: 7057: /* 7058: ** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry 7059: ** and ends with pLastEntry. If argument pBefore is NULL, then pNew is added 7060: ** to the end of the list. Otherwise, it is added to the list immediately 7061: ** before pBefore (which is guaranteed to be a part of said list). 7062: */ 7063: static void zipfileAddEntry( 7064: ZipfileTab *pTab, 7065: ZipfileEntry *pBefore, 7066: ZipfileEntry *pNew 7067: ){ 7068: assert( (pTab->pFirstEntry==0)==(pTab->pLastEntry==0) ); 7069: assert( pNew->pNext==0 ); 7070: if( pBefore==0 ){ 7071: if( pTab->pFirstEntry==0 ){ 7072: pTab->pFirstEntry = pTab->pLastEntry = pNew; 7073: }else{ 7074: assert( pTab->pLastEntry->pNext==0 ); 7075: pTab->pLastEntry->pNext = pNew; 7076: pTab->pLastEntry = pNew; 7077: } 7078: }else{ 7079: ZipfileEntry **pp; 7080: for(pp=&pTab->pFirstEntry; *pp!=pBefore; pp=&((*pp)->pNext)); 7081: pNew->pNext = pBefore; 7082: *pp = pNew; 7083: } 7084: } 7085: 7086: static int zipfileLoadDirectory(ZipfileTab *pTab, const u8 *aBlob, int nBlob){ 7087: ZipfileEOCD eocd; 7088: int rc; 7089: int i; 7090: i64 iOff; 7091: 7092: rc = zipfileReadEOCD(pTab, aBlob, nBlob, pTab->pWriteFd, &eocd); 7093: iOff = eocd.iOffset; 7094: for(i=0; rc==SQLITE_OK && i<eocd.nEntry; i++){ 7095: ZipfileEntry *pNew = 0; 7096: rc = zipfileGetEntry(pTab, aBlob, nBlob, pTab->pWriteFd, iOff, &pNew); 7097: 7098: if( rc==SQLITE_OK ){ 7099: zipfileAddEntry(pTab, 0, pNew); 7100: iOff += ZIPFILE_CDS_FIXED_SZ; 7101: iOff += (int)pNew->cds.nExtra + pNew->cds.nFile + pNew->cds.nComment; 7102: } 7103: } 7104: return rc; 7105: } 7106: 7107: /* 7108: ** xFilter callback. 7109: */ 7110: static int zipfileFilter( 7111: sqlite3_vtab_cursor *cur, 7112: int idxNum, const char *idxStr, 7113: int argc, sqlite3_value **argv 7114: ){ 7115: ZipfileTab *pTab = (ZipfileTab*)cur->pVtab; 7116: ZipfileCsr *pCsr = (ZipfileCsr*)cur; 7117: const char *zFile = 0; /* Zip file to scan */ 7118: int rc = SQLITE_OK; /* Return Code */ 7119: int bInMemory = 0; /* True for an in-memory zipfile */ 7120: 7121: zipfileResetCursor(pCsr); 7122: 7123: if( pTab->zFile ){ 7124: zFile = pTab->zFile; 7125: }else if( idxNum==0 ){ 7126: zipfileCursorErr(pCsr, "zipfile() function requires an argument"); 7127: return SQLITE_ERROR; 7128: }else if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){ 7129: const u8 *aBlob = (const u8*)sqlite3_value_blob(argv[0]); 7130: int nBlob = sqlite3_value_bytes(argv[0]); 7131: assert( pTab->pFirstEntry==0 ); 7132: rc = zipfileLoadDirectory(pTab, aBlob, nBlob); 7133: pCsr->pFreeEntry = pTab->pFirstEntry; 7134: pTab->pFirstEntry = pTab->pLastEntry = 0; 7135: if( rc!=SQLITE_OK ) return rc; 7136: bInMemory = 1; 7137: }else{ 7138: zFile = (const char*)sqlite3_value_text(argv[0]); 7139: } 7140: 7141: if( 0==pTab->pWriteFd && 0==bInMemory ){ 7142: pCsr->pFile = fopen(zFile, "rb"); 7143: if( pCsr->pFile==0 ){ 7144: zipfileCursorErr(pCsr, "cannot open file: %s", zFile); 7145: rc = SQLITE_ERROR; 7146: }else{ 7147: rc = zipfileReadEOCD(pTab, 0, 0, pCsr->pFile, &pCsr->eocd); 7148: if( rc==SQLITE_OK ){ 7149: if( pCsr->eocd.nEntry==0 ){ 7150: pCsr->bEof = 1; 7151: }else{ 7152: pCsr->iNextOff = pCsr->eocd.iOffset; 7153: rc = zipfileNext(cur); 7154: } 7155: } 7156: } 7157: }else{ 7158: pCsr->bNoop = 1; 7159: pCsr->pCurrent = pCsr->pFreeEntry ? pCsr->pFreeEntry : pTab->pFirstEntry; 7160: rc = zipfileNext(cur); 7161: } 7162: 7163: return rc; 7164: } 7165: 7166: /* 7167: ** xBestIndex callback. 7168: */ 7169: static int zipfileBestIndex( 7170: sqlite3_vtab *tab, 7171: sqlite3_index_info *pIdxInfo 7172: ){ 7173: int i; 7174: int idx = -1; 7175: int unusable = 0; 7176: 7177: for(i=0; i<pIdxInfo->nConstraint; i++){ 7178: const struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i]; 7179: if( pCons->iColumn!=ZIPFILE_F_COLUMN_IDX ) continue; 7180: if( pCons->usable==0 ){ 7181: unusable = 1; 7182: }else if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 7183: idx = i; 7184: } 7185: } 7186: pIdxInfo->estimatedCost = 1000.0; 7187: if( idx>=0 ){ 7188: pIdxInfo->aConstraintUsage[idx].argvIndex = 1; 7189: pIdxInfo->aConstraintUsage[idx].omit = 1; 7190: pIdxInfo->idxNum = 1; 7191: }else if( unusable ){ 7192: return SQLITE_CONSTRAINT; 7193: } 7194: return SQLITE_OK; 7195: } 7196: 7197: static ZipfileEntry *zipfileNewEntry(const char *zPath){ 7198: ZipfileEntry *pNew; 7199: pNew = sqlite3_malloc(sizeof(ZipfileEntry)); 7200: if( pNew ){ 7201: memset(pNew, 0, sizeof(ZipfileEntry)); 7202: pNew->cds.zFile = sqlite3_mprintf("%s", zPath); 7203: if( pNew->cds.zFile==0 ){ 7204: sqlite3_free(pNew); 7205: pNew = 0; 7206: } 7207: } 7208: return pNew; 7209: } 7210: 7211: static int zipfileSerializeLFH(ZipfileEntry *pEntry, u8 *aBuf){ 7212: ZipfileCDS *pCds = &pEntry->cds; 7213: u8 *a = aBuf; 7214: 7215: pCds->nExtra = 9; 7216: 7217: /* Write the LFH itself */ 7218: zipfileWrite32(a, ZIPFILE_SIGNATURE_LFH); 7219: zipfileWrite16(a, pCds->iVersionExtract); 7220: zipfileWrite16(a, pCds->flags); 7221: zipfileWrite16(a, pCds->iCompression); 7222: zipfileWrite16(a, pCds->mTime); 7223: zipfileWrite16(a, pCds->mDate); 7224: zipfileWrite32(a, pCds->crc32); 7225: zipfileWrite32(a, pCds->szCompressed); 7226: zipfileWrite32(a, pCds->szUncompressed); 7227: zipfileWrite16(a, (u16)pCds->nFile); 7228: zipfileWrite16(a, pCds->nExtra); 7229: assert( a==&aBuf[ZIPFILE_LFH_FIXED_SZ] ); 7230: 7231: /* Add the file name */ 7232: memcpy(a, pCds->zFile, (int)pCds->nFile); 7233: a += (int)pCds->nFile; 7234: 7235: /* The "extra" data */ 7236: zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP); 7237: zipfileWrite16(a, 5); 7238: *a++ = 0x01; 7239: zipfileWrite32(a, pEntry->mUnixTime); 7240: 7241: return a-aBuf; 7242: } 7243: 7244: static int zipfileAppendEntry( 7245: ZipfileTab *pTab, 7246: ZipfileEntry *pEntry, 7247: const u8 *pData, 7248: int nData 7249: ){ 7250: u8 *aBuf = pTab->aBuffer; 7251: int nBuf; 7252: int rc; 7253: 7254: nBuf = zipfileSerializeLFH(pEntry, aBuf); 7255: rc = zipfileAppendData(pTab, aBuf, nBuf); 7256: if( rc==SQLITE_OK ){ 7257: pEntry->iDataOff = pTab->szCurrent; 7258: rc = zipfileAppendData(pTab, pData, nData); 7259: } 7260: 7261: return rc; 7262: } 7263: 7264: static int zipfileGetMode( 7265: sqlite3_value *pVal, 7266: int bIsDir, /* If true, default to directory */ 7267: u32 *pMode, /* OUT: Mode value */ 7268: char **pzErr /* OUT: Error message */ 7269: ){ 7270: const char *z = (const char*)sqlite3_value_text(pVal); 7271: u32 mode = 0; 7272: if( z==0 ){ 7273: mode = (bIsDir ? (S_IFDIR + 0755) : (S_IFREG + 0644)); 7274: }else if( z[0]>='0' && z[0]<='9' ){ 7275: mode = (unsigned int)sqlite3_value_int(pVal); 7276: }else{ 7277: const char zTemplate[11] = "-rwxrwxrwx"; 7278: int i; 7279: if( strlen(z)!=10 ) goto parse_error; 7280: switch( z[0] ){ 7281: case '-': mode |= S_IFREG; break; 7282: case 'd': mode |= S_IFDIR; break; 7283: case 'l': mode |= S_IFLNK; break; 7284: default: goto parse_error; 7285: } 7286: for(i=1; i<10; i++){ 7287: if( z[i]==zTemplate[i] ) mode |= 1 << (9-i); 7288: else if( z[i]!='-' ) goto parse_error; 7289: } 7290: } 7291: if( ((mode & S_IFDIR)==0)==bIsDir ){ 7292: /* The "mode" attribute is a directory, but data has been specified. 7293: ** Or vice-versa - no data but "mode" is a file or symlink. */ 7294: *pzErr = sqlite3_mprintf("zipfile: mode does not match data"); 7295: return SQLITE_CONSTRAINT; 7296: } 7297: *pMode = mode; 7298: return SQLITE_OK; 7299: 7300: parse_error: 7301: *pzErr = sqlite3_mprintf("zipfile: parse error in mode: %s", z); 7302: return SQLITE_ERROR; 7303: } 7304: 7305: /* 7306: ** Both (const char*) arguments point to nul-terminated strings. Argument 7307: ** nB is the value of strlen(zB). This function returns 0 if the strings are 7308: ** identical, ignoring any trailing '/' character in either path. */ 7309: static int zipfileComparePath(const char *zA, const char *zB, int nB){ 7310: int nA = (int)strlen(zA); 7311: if( nA>0 && zA[nA-1]=='/' ) nA--; 7312: if( nB>0 && zB[nB-1]=='/' ) nB--; 7313: if( nA==nB && memcmp(zA, zB, nA)==0 ) return 0; 7314: return 1; 7315: } 7316: 7317: static int zipfileBegin(sqlite3_vtab *pVtab){ 7318: ZipfileTab *pTab = (ZipfileTab*)pVtab; 7319: int rc = SQLITE_OK; 7320: 7321: assert( pTab->pWriteFd==0 ); 7322: if( pTab->zFile==0 || pTab->zFile[0]==0 ){ 7323: pTab->base.zErrMsg = sqlite3_mprintf("zipfile: missing filename"); 7324: return SQLITE_ERROR; 7325: } 7326: 7327: /* Open a write fd on the file. Also load the entire central directory 7328: ** structure into memory. During the transaction any new file data is 7329: ** appended to the archive file, but the central directory is accumulated 7330: ** in main-memory until the transaction is committed. */ 7331: pTab->pWriteFd = fopen(pTab->zFile, "ab+"); 7332: if( pTab->pWriteFd==0 ){ 7333: pTab->base.zErrMsg = sqlite3_mprintf( 7334: "zipfile: failed to open file %s for writing", pTab->zFile 7335: ); 7336: rc = SQLITE_ERROR; 7337: }else{ 7338: fseek(pTab->pWriteFd, 0, SEEK_END); 7339: pTab->szCurrent = pTab->szOrig = (i64)ftell(pTab->pWriteFd); 7340: rc = zipfileLoadDirectory(pTab, 0, 0); 7341: } 7342: 7343: if( rc!=SQLITE_OK ){ 7344: zipfileCleanupTransaction(pTab); 7345: } 7346: 7347: return rc; 7348: } 7349: 7350: /* 7351: ** Return the current time as a 32-bit timestamp in UNIX epoch format (like 7352: ** time(2)). 7353: */ 7354: static u32 zipfileTime(void){ 7355: sqlite3_vfs *pVfs = sqlite3_vfs_find(0); 7356: u32 ret; 7357: if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ 7358: i64 ms; 7359: pVfs->xCurrentTimeInt64(pVfs, &ms); 7360: ret = (u32)((ms/1000) - ((i64)24405875 * 8640)); 7361: }else{ 7362: double day; 7363: pVfs->xCurrentTime(pVfs, &day); 7364: ret = (u32)((day - 2440587.5) * 86400); 7365: } 7366: return ret; 7367: } 7368: 7369: /* 7370: ** Return a 32-bit timestamp in UNIX epoch format. 7371: ** 7372: ** If the value passed as the only argument is either NULL or an SQL NULL, 7373: ** return the current time. Otherwise, return the value stored in (*pVal) 7374: ** cast to a 32-bit unsigned integer. 7375: */ 7376: static u32 zipfileGetTime(sqlite3_value *pVal){ 7377: if( pVal==0 || sqlite3_value_type(pVal)==SQLITE_NULL ){ 7378: return zipfileTime(); 7379: } 7380: return (u32)sqlite3_value_int64(pVal); 7381: } 7382: 7383: /* 7384: ** Unless it is NULL, entry pOld is currently part of the pTab->pFirstEntry 7385: ** linked list. Remove it from the list and free the object. 7386: */ 7387: static void zipfileRemoveEntryFromList(ZipfileTab *pTab, ZipfileEntry *pOld){ 7388: if( pOld ){ 7389: ZipfileEntry **pp; 7390: for(pp=&pTab->pFirstEntry; (*pp)!=pOld; pp=&((*pp)->pNext)); 7391: *pp = (*pp)->pNext; 7392: zipfileEntryFree(pOld); 7393: } 7394: } 7395: 7396: /* 7397: ** xUpdate method. 7398: */ 7399: static int zipfileUpdate( 7400: sqlite3_vtab *pVtab, 7401: int nVal, 7402: sqlite3_value **apVal, 7403: sqlite_int64 *pRowid 7404: ){ 7405: ZipfileTab *pTab = (ZipfileTab*)pVtab; 7406: int rc = SQLITE_OK; /* Return Code */ 7407: ZipfileEntry *pNew = 0; /* New in-memory CDS entry */ 7408: 7409: u32 mode = 0; /* Mode for new entry */ 7410: u32 mTime = 0; /* Modification time for new entry */ 7411: i64 sz = 0; /* Uncompressed size */ 7412: const char *zPath = 0; /* Path for new entry */ 7413: int nPath = 0; /* strlen(zPath) */ 7414: const u8 *pData = 0; /* Pointer to buffer containing content */ 7415: int nData = 0; /* Size of pData buffer in bytes */ 7416: int iMethod = 0; /* Compression method for new entry */ 7417: u8 *pFree = 0; /* Free this */ 7418: char *zFree = 0; /* Also free this */ 7419: ZipfileEntry *pOld = 0; 7420: ZipfileEntry *pOld2 = 0; 7421: int bUpdate = 0; /* True for an update that modifies "name" */ 7422: int bIsDir = 0; 7423: u32 iCrc32 = 0; 7424: 7425: if( pTab->pWriteFd==0 ){ 7426: rc = zipfileBegin(pVtab); 7427: if( rc!=SQLITE_OK ) return rc; 7428: } 7429: 7430: /* If this is a DELETE or UPDATE, find the archive entry to delete. */ 7431: if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){ 7432: const char *zDelete = (const char*)sqlite3_value_text(apVal[0]); 7433: int nDelete = (int)strlen(zDelete); 7434: if( nVal>1 ){ 7435: const char *zUpdate = (const char*)sqlite3_value_text(apVal[1]); 7436: if( zUpdate && zipfileComparePath(zUpdate, zDelete, nDelete)!=0 ){ 7437: bUpdate = 1; 7438: } 7439: } 7440: for(pOld=pTab->pFirstEntry; 1; pOld=pOld->pNext){ 7441: if( zipfileComparePath(pOld->cds.zFile, zDelete, nDelete)==0 ){ 7442: break; 7443: } 7444: assert( pOld->pNext ); 7445: } 7446: } 7447: 7448: if( nVal>1 ){ 7449: /* Check that "sz" and "rawdata" are both NULL: */ 7450: if( sqlite3_value_type(apVal[5])!=SQLITE_NULL ){ 7451: zipfileTableErr(pTab, "sz must be NULL"); 7452: rc = SQLITE_CONSTRAINT; 7453: } 7454: if( sqlite3_value_type(apVal[6])!=SQLITE_NULL ){ 7455: zipfileTableErr(pTab, "rawdata must be NULL"); 7456: rc = SQLITE_CONSTRAINT; 7457: } 7458: 7459: if( rc==SQLITE_OK ){ 7460: if( sqlite3_value_type(apVal[7])==SQLITE_NULL ){ 7461: /* data=NULL. A directory */ 7462: bIsDir = 1; 7463: }else{ 7464: /* Value specified for "data", and possibly "method". This must be 7465: ** a regular file or a symlink. */ 7466: const u8 *aIn = sqlite3_value_blob(apVal[7]); 7467: int nIn = sqlite3_value_bytes(apVal[7]); 7468: int bAuto = sqlite3_value_type(apVal[8])==SQLITE_NULL; 7469: 7470: iMethod = sqlite3_value_int(apVal[8]); 7471: sz = nIn; 7472: pData = aIn; 7473: nData = nIn; 7474: if( iMethod!=0 && iMethod!=8 ){ 7475: zipfileTableErr(pTab, "unknown compression method: %d", iMethod); 7476: rc = SQLITE_CONSTRAINT; 7477: }else{ 7478: if( bAuto || iMethod ){ 7479: int nCmp; 7480: rc = zipfileDeflate(aIn, nIn, &pFree, &nCmp, &pTab->base.zErrMsg); 7481: if( rc==SQLITE_OK ){ 7482: if( iMethod || nCmp<nIn ){ 7483: iMethod = 8; 7484: pData = pFree; 7485: nData = nCmp; 7486: } 7487: } 7488: } 7489: iCrc32 = crc32(0, aIn, nIn); 7490: } 7491: } 7492: } 7493: 7494: if( rc==SQLITE_OK ){ 7495: rc = zipfileGetMode(apVal[3], bIsDir, &mode, &pTab->base.zErrMsg); 7496: } 7497: 7498: if( rc==SQLITE_OK ){ 7499: zPath = (const char*)sqlite3_value_text(apVal[2]); 7500: if( zPath==0 ) zPath = ""; 7501: nPath = (int)strlen(zPath); 7502: mTime = zipfileGetTime(apVal[4]); 7503: } 7504: 7505: if( rc==SQLITE_OK && bIsDir ){ 7506: /* For a directory, check that the last character in the path is a 7507: ** '/'. This appears to be required for compatibility with info-zip 7508: ** (the unzip command on unix). It does not create directories 7509: ** otherwise. */ 7510: if( nPath<=0 || zPath[nPath-1]!='/' ){ 7511: zFree = sqlite3_mprintf("%s/", zPath); 7512: zPath = (const char*)zFree; 7513: if( zFree==0 ){ 7514: rc = SQLITE_NOMEM; 7515: nPath = 0; 7516: }else{ 7517: nPath = (int)strlen(zPath); 7518: } 7519: } 7520: } 7521: 7522: /* Check that we're not inserting a duplicate entry -OR- updating an 7523: ** entry with a path, thereby making it into a duplicate. */ 7524: if( (pOld==0 || bUpdate) && rc==SQLITE_OK ){ 7525: ZipfileEntry *p; 7526: for(p=pTab->pFirstEntry; p; p=p->pNext){ 7527: if( zipfileComparePath(p->cds.zFile, zPath, nPath)==0 ){ 7528: switch( sqlite3_vtab_on_conflict(pTab->db) ){ 7529: case SQLITE_IGNORE: { 7530: goto zipfile_update_done; 7531: } 7532: case SQLITE_REPLACE: { 7533: pOld2 = p; 7534: break; 7535: } 7536: default: { 7537: zipfileTableErr(pTab, "duplicate name: \"%s\"", zPath); 7538: rc = SQLITE_CONSTRAINT; 7539: break; 7540: } 7541: } 7542: break; 7543: } 7544: } 7545: } 7546: 7547: if( rc==SQLITE_OK ){ 7548: /* Create the new CDS record. */ 7549: pNew = zipfileNewEntry(zPath); 7550: if( pNew==0 ){ 7551: rc = SQLITE_NOMEM; 7552: }else{ 7553: pNew->cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY; 7554: pNew->cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED; 7555: pNew->cds.flags = ZIPFILE_NEWENTRY_FLAGS; 7556: pNew->cds.iCompression = (u16)iMethod; 7557: zipfileMtimeToDos(&pNew->cds, mTime); 7558: pNew->cds.crc32 = iCrc32; 7559: pNew->cds.szCompressed = nData; 7560: pNew->cds.szUncompressed = (u32)sz; 7561: pNew->cds.iExternalAttr = (mode<<16); 7562: pNew->cds.iOffset = (u32)pTab->szCurrent; 7563: pNew->cds.nFile = (u16)nPath; 7564: pNew->mUnixTime = (u32)mTime; 7565: rc = zipfileAppendEntry(pTab, pNew, pData, nData); 7566: zipfileAddEntry(pTab, pOld, pNew); 7567: } 7568: } 7569: } 7570: 7571: if( rc==SQLITE_OK && (pOld || pOld2) ){ 7572: ZipfileCsr *pCsr; 7573: for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){ 7574: if( pCsr->pCurrent && (pCsr->pCurrent==pOld || pCsr->pCurrent==pOld2) ){ 7575: pCsr->pCurrent = pCsr->pCurrent->pNext; 7576: pCsr->bNoop = 1; 7577: } 7578: } 7579: 7580: zipfileRemoveEntryFromList(pTab, pOld); 7581: zipfileRemoveEntryFromList(pTab, pOld2); 7582: } 7583: 7584: zipfile_update_done: 7585: sqlite3_free(pFree); 7586: sqlite3_free(zFree); 7587: return rc; 7588: } 7589: 7590: static int zipfileSerializeEOCD(ZipfileEOCD *p, u8 *aBuf){ 7591: u8 *a = aBuf; 7592: zipfileWrite32(a, ZIPFILE_SIGNATURE_EOCD); 7593: zipfileWrite16(a, p->iDisk); 7594: zipfileWrite16(a, p->iFirstDisk); 7595: zipfileWrite16(a, p->nEntry); 7596: zipfileWrite16(a, p->nEntryTotal); 7597: zipfileWrite32(a, p->nSize); 7598: zipfileWrite32(a, p->iOffset); 7599: zipfileWrite16(a, 0); /* Size of trailing comment in bytes*/ 7600: 7601: return a-aBuf; 7602: } 7603: 7604: static int zipfileAppendEOCD(ZipfileTab *pTab, ZipfileEOCD *p){ 7605: int nBuf = zipfileSerializeEOCD(p, pTab->aBuffer); 7606: assert( nBuf==ZIPFILE_EOCD_FIXED_SZ ); 7607: return zipfileAppendData(pTab, pTab->aBuffer, nBuf); 7608: } 7609: 7610: /* 7611: ** Serialize the CDS structure into buffer aBuf[]. Return the number 7612: ** of bytes written. 7613: */ 7614: static int zipfileSerializeCDS(ZipfileEntry *pEntry, u8 *aBuf){ 7615: u8 *a = aBuf; 7616: ZipfileCDS *pCDS = &pEntry->cds; 7617: 7618: if( pEntry->aExtra==0 ){ 7619: pCDS->nExtra = 9; 7620: } 7621: 7622: zipfileWrite32(a, ZIPFILE_SIGNATURE_CDS); 7623: zipfileWrite16(a, pCDS->iVersionMadeBy); 7624: zipfileWrite16(a, pCDS->iVersionExtract); 7625: zipfileWrite16(a, pCDS->flags); 7626: zipfileWrite16(a, pCDS->iCompression); 7627: zipfileWrite16(a, pCDS->mTime); 7628: zipfileWrite16(a, pCDS->mDate); 7629: zipfileWrite32(a, pCDS->crc32); 7630: zipfileWrite32(a, pCDS->szCompressed); 7631: zipfileWrite32(a, pCDS->szUncompressed); 7632: assert( a==&aBuf[ZIPFILE_CDS_NFILE_OFF] ); 7633: zipfileWrite16(a, pCDS->nFile); 7634: zipfileWrite16(a, pCDS->nExtra); 7635: zipfileWrite16(a, pCDS->nComment); 7636: zipfileWrite16(a, pCDS->iDiskStart); 7637: zipfileWrite16(a, pCDS->iInternalAttr); 7638: zipfileWrite32(a, pCDS->iExternalAttr); 7639: zipfileWrite32(a, pCDS->iOffset); 7640: 7641: memcpy(a, pCDS->zFile, pCDS->nFile); 7642: a += pCDS->nFile; 7643: 7644: if( pEntry->aExtra ){ 7645: int n = (int)pCDS->nExtra + (int)pCDS->nComment; 7646: memcpy(a, pEntry->aExtra, n); 7647: a += n; 7648: }else{ 7649: assert( pCDS->nExtra==9 ); 7650: zipfileWrite16(a, ZIPFILE_EXTRA_TIMESTAMP); 7651: zipfileWrite16(a, 5); 7652: *a++ = 0x01; 7653: zipfileWrite32(a, pEntry->mUnixTime); 7654: } 7655: 7656: return a-aBuf; 7657: } 7658: 7659: static int zipfileCommit(sqlite3_vtab *pVtab){ 7660: ZipfileTab *pTab = (ZipfileTab*)pVtab; 7661: int rc = SQLITE_OK; 7662: if( pTab->pWriteFd ){ 7663: i64 iOffset = pTab->szCurrent; 7664: ZipfileEntry *p; 7665: ZipfileEOCD eocd; 7666: int nEntry = 0; 7667: 7668: /* Write out all entries */ 7669: for(p=pTab->pFirstEntry; rc==SQLITE_OK && p; p=p->pNext){ 7670: int n = zipfileSerializeCDS(p, pTab->aBuffer); 7671: rc = zipfileAppendData(pTab, pTab->aBuffer, n); 7672: nEntry++; 7673: } 7674: 7675: /* Write out the EOCD record */ 7676: eocd.iDisk = 0; 7677: eocd.iFirstDisk = 0; 7678: eocd.nEntry = (u16)nEntry; 7679: eocd.nEntryTotal = (u16)nEntry; 7680: eocd.nSize = (u32)(pTab->szCurrent - iOffset); 7681: eocd.iOffset = (u32)iOffset; 7682: rc = zipfileAppendEOCD(pTab, &eocd); 7683: 7684: zipfileCleanupTransaction(pTab); 7685: } 7686: return rc; 7687: } 7688: 7689: static int zipfileRollback(sqlite3_vtab *pVtab){ 7690: return zipfileCommit(pVtab); 7691: } 7692: 7693: static ZipfileCsr *zipfileFindCursor(ZipfileTab *pTab, i64 iId){ 7694: ZipfileCsr *pCsr; 7695: for(pCsr=pTab->pCsrList; pCsr; pCsr=pCsr->pCsrNext){ 7696: if( iId==pCsr->iId ) break; 7697: } 7698: return pCsr; 7699: } 7700: 7701: static void zipfileFunctionCds( 7702: sqlite3_context *context, 7703: int argc, 7704: sqlite3_value **argv 7705: ){ 7706: ZipfileCsr *pCsr; 7707: ZipfileTab *pTab = (ZipfileTab*)sqlite3_user_data(context); 7708: assert( argc>0 ); 7709: 7710: pCsr = zipfileFindCursor(pTab, sqlite3_value_int64(argv[0])); 7711: if( pCsr ){ 7712: ZipfileCDS *p = &pCsr->pCurrent->cds; 7713: char *zRes = sqlite3_mprintf("{" 7714: "\"version-made-by\" : %u, " 7715: "\"version-to-extract\" : %u, " 7716: "\"flags\" : %u, " 7717: "\"compression\" : %u, " 7718: "\"time\" : %u, " 7719: "\"date\" : %u, " 7720: "\"crc32\" : %u, " 7721: "\"compressed-size\" : %u, " 7722: "\"uncompressed-size\" : %u, " 7723: "\"file-name-length\" : %u, " 7724: "\"extra-field-length\" : %u, " 7725: "\"file-comment-length\" : %u, " 7726: "\"disk-number-start\" : %u, " 7727: "\"internal-attr\" : %u, " 7728: "\"external-attr\" : %u, " 7729: "\"offset\" : %u }", 7730: (u32)p->iVersionMadeBy, (u32)p->iVersionExtract, 7731: (u32)p->flags, (u32)p->iCompression, 7732: (u32)p->mTime, (u32)p->mDate, 7733: (u32)p->crc32, (u32)p->szCompressed, 7734: (u32)p->szUncompressed, (u32)p->nFile, 7735: (u32)p->nExtra, (u32)p->nComment, 7736: (u32)p->iDiskStart, (u32)p->iInternalAttr, 7737: (u32)p->iExternalAttr, (u32)p->iOffset 7738: ); 7739: 7740: if( zRes==0 ){ 7741: sqlite3_result_error_nomem(context); 7742: }else{ 7743: sqlite3_result_text(context, zRes, -1, SQLITE_TRANSIENT); 7744: sqlite3_free(zRes); 7745: } 7746: } 7747: } 7748: 7749: /* 7750: ** xFindFunction method. 7751: */ 7752: static int zipfileFindFunction( 7753: sqlite3_vtab *pVtab, /* Virtual table handle */ 7754: int nArg, /* Number of SQL function arguments */ 7755: const char *zName, /* Name of SQL function */ 7756: void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */ 7757: void **ppArg /* OUT: User data for *pxFunc */ 7758: ){ 7759: if( sqlite3_stricmp("zipfile_cds", zName)==0 ){ 7760: *pxFunc = zipfileFunctionCds; 7761: *ppArg = (void*)pVtab; 7762: return 1; 7763: } 7764: return 0; 7765: } 7766: 7767: typedef struct ZipfileBuffer ZipfileBuffer; 7768: struct ZipfileBuffer { 7769: u8 *a; /* Pointer to buffer */ 7770: int n; /* Size of buffer in bytes */ 7771: int nAlloc; /* Byte allocated at a[] */ 7772: }; 7773: 7774: typedef struct ZipfileCtx ZipfileCtx; 7775: struct ZipfileCtx { 7776: int nEntry; 7777: ZipfileBuffer body; 7778: ZipfileBuffer cds; 7779: }; 7780: 7781: static int zipfileBufferGrow(ZipfileBuffer *pBuf, int nByte){ 7782: if( pBuf->n+nByte>pBuf->nAlloc ){ 7783: u8 *aNew; 7784: sqlite3_int64 nNew = pBuf->n ? pBuf->n*2 : 512; 7785: int nReq = pBuf->n + nByte; 7786: 7787: while( nNew<nReq ) nNew = nNew*2; 7788: aNew = sqlite3_realloc64(pBuf->a, nNew); 7789: if( aNew==0 ) return SQLITE_NOMEM; 7790: pBuf->a = aNew; 7791: pBuf->nAlloc = (int)nNew; 7792: } 7793: return SQLITE_OK; 7794: } 7795: 7796: /* 7797: ** xStep() callback for the zipfile() aggregate. This can be called in 7798: ** any of the following ways: 7799: ** 7800: ** SELECT zipfile(name,data) ... 7801: ** SELECT zipfile(name,mode,mtime,data) ... 7802: ** SELECT zipfile(name,mode,mtime,data,method) ... 7803: */ 7804: void zipfileStep(sqlite3_context *pCtx, int nVal, sqlite3_value **apVal){ 7805: ZipfileCtx *p; /* Aggregate function context */ 7806: ZipfileEntry e; /* New entry to add to zip archive */ 7807: 7808: sqlite3_value *pName = 0; 7809: sqlite3_value *pMode = 0; 7810: sqlite3_value *pMtime = 0; 7811: sqlite3_value *pData = 0; 7812: sqlite3_value *pMethod = 0; 7813: 7814: int bIsDir = 0; 7815: u32 mode; 7816: int rc = SQLITE_OK; 7817: char *zErr = 0; 7818: 7819: int iMethod = -1; /* Compression method to use (0 or 8) */ 7820: 7821: const u8 *aData = 0; /* Possibly compressed data for new entry */ 7822: int nData = 0; /* Size of aData[] in bytes */ 7823: int szUncompressed = 0; /* Size of data before compression */ 7824: u8 *aFree = 0; /* Free this before returning */ 7825: u32 iCrc32 = 0; /* crc32 of uncompressed data */ 7826: 7827: char *zName = 0; /* Path (name) of new entry */ 7828: int nName = 0; /* Size of zName in bytes */ 7829: char *zFree = 0; /* Free this before returning */ 7830: int nByte; 7831: 7832: memset(&e, 0, sizeof(e)); 7833: p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx)); 7834: if( p==0 ) return; 7835: 7836: /* Martial the arguments into stack variables */ 7837: if( nVal!=2 && nVal!=4 && nVal!=5 ){ 7838: zErr = sqlite3_mprintf("wrong number of arguments to function zipfile()"); 7839: rc = SQLITE_ERROR; 7840: goto zipfile_step_out; 7841: } 7842: pName = apVal[0]; 7843: if( nVal==2 ){ 7844: pData = apVal[1]; 7845: }else{ 7846: pMode = apVal[1]; 7847: pMtime = apVal[2]; 7848: pData = apVal[3]; 7849: if( nVal==5 ){ 7850: pMethod = apVal[4]; 7851: } 7852: } 7853: 7854: /* Check that the 'name' parameter looks ok. */ 7855: zName = (char*)sqlite3_value_text(pName); 7856: nName = sqlite3_value_bytes(pName); 7857: if( zName==0 ){ 7858: zErr = sqlite3_mprintf("first argument to zipfile() must be non-NULL"); 7859: rc = SQLITE_ERROR; 7860: goto zipfile_step_out; 7861: } 7862: 7863: /* Inspect the 'method' parameter. This must be either 0 (store), 8 (use 7864: ** deflate compression) or NULL (choose automatically). */ 7865: if( pMethod && SQLITE_NULL!=sqlite3_value_type(pMethod) ){ 7866: iMethod = (int)sqlite3_value_int64(pMethod); 7867: if( iMethod!=0 && iMethod!=8 ){ 7868: zErr = sqlite3_mprintf("illegal method value: %d", iMethod); 7869: rc = SQLITE_ERROR; 7870: goto zipfile_step_out; 7871: } 7872: } 7873: 7874: /* Now inspect the data. If this is NULL, then the new entry must be a 7875: ** directory. Otherwise, figure out whether or not the data should 7876: ** be deflated or simply stored in the zip archive. */ 7877: if( sqlite3_value_type(pData)==SQLITE_NULL ){ 7878: bIsDir = 1; 7879: iMethod = 0; 7880: }else{ 7881: aData = sqlite3_value_blob(pData); 7882: szUncompressed = nData = sqlite3_value_bytes(pData); 7883: iCrc32 = crc32(0, aData, nData); 7884: if( iMethod<0 || iMethod==8 ){ 7885: int nOut = 0; 7886: rc = zipfileDeflate(aData, nData, &aFree, &nOut, &zErr); 7887: if( rc!=SQLITE_OK ){ 7888: goto zipfile_step_out; 7889: } 7890: if( iMethod==8 || nOut<nData ){ 7891: aData = aFree; 7892: nData = nOut; 7893: iMethod = 8; 7894: }else{ 7895: iMethod = 0; 7896: } 7897: } 7898: } 7899: 7900: /* Decode the "mode" argument. */ 7901: rc = zipfileGetMode(pMode, bIsDir, &mode, &zErr); 7902: if( rc ) goto zipfile_step_out; 7903: 7904: /* Decode the "mtime" argument. */ 7905: e.mUnixTime = zipfileGetTime(pMtime); 7906: 7907: /* If this is a directory entry, ensure that there is exactly one '/' 7908: ** at the end of the path. Or, if this is not a directory and the path 7909: ** ends in '/' it is an error. */ 7910: if( bIsDir==0 ){ 7911: if( nName>0 && zName[nName-1]=='/' ){ 7912: zErr = sqlite3_mprintf("non-directory name must not end with /"); 7913: rc = SQLITE_ERROR; 7914: goto zipfile_step_out; 7915: } 7916: }else{ 7917: if( nName==0 || zName[nName-1]!='/' ){ 7918: zName = zFree = sqlite3_mprintf("%s/", zName); 7919: if( zName==0 ){ 7920: rc = SQLITE_NOMEM; 7921: goto zipfile_step_out; 7922: } 7923: nName = (int)strlen(zName); 7924: }else{ 7925: while( nName>1 && zName[nName-2]=='/' ) nName--; 7926: } 7927: } 7928: 7929: /* Assemble the ZipfileEntry object for the new zip archive entry */ 7930: e.cds.iVersionMadeBy = ZIPFILE_NEWENTRY_MADEBY; 7931: e.cds.iVersionExtract = ZIPFILE_NEWENTRY_REQUIRED; 7932: e.cds.flags = ZIPFILE_NEWENTRY_FLAGS; 7933: e.cds.iCompression = (u16)iMethod; 7934: zipfileMtimeToDos(&e.cds, (u32)e.mUnixTime); 7935: e.cds.crc32 = iCrc32; 7936: e.cds.szCompressed = nData; 7937: e.cds.szUncompressed = szUncompressed; 7938: e.cds.iExternalAttr = (mode<<16); 7939: e.cds.iOffset = p->body.n; 7940: e.cds.nFile = (u16)nName; 7941: e.cds.zFile = zName; 7942: 7943: /* Append the LFH to the body of the new archive */ 7944: nByte = ZIPFILE_LFH_FIXED_SZ + e.cds.nFile + 9; 7945: if( (rc = zipfileBufferGrow(&p->body, nByte)) ) goto zipfile_step_out; 7946: p->body.n += zipfileSerializeLFH(&e, &p->body.a[p->body.n]); 7947: 7948: /* Append the data to the body of the new archive */ 7949: if( nData>0 ){ 7950: if( (rc = zipfileBufferGrow(&p->body, nData)) ) goto zipfile_step_out; 7951: memcpy(&p->body.a[p->body.n], aData, nData); 7952: p->body.n += nData; 7953: } 7954: 7955: /* Append the CDS record to the directory of the new archive */ 7956: nByte = ZIPFILE_CDS_FIXED_SZ + e.cds.nFile + 9; 7957: if( (rc = zipfileBufferGrow(&p->cds, nByte)) ) goto zipfile_step_out; 7958: p->cds.n += zipfileSerializeCDS(&e, &p->cds.a[p->cds.n]); 7959: 7960: /* Increment the count of entries in the archive */ 7961: p->nEntry++; 7962: 7963: zipfile_step_out: 7964: sqlite3_free(aFree); 7965: sqlite3_free(zFree); 7966: if( rc ){ 7967: if( zErr ){ 7968: sqlite3_result_error(pCtx, zErr, -1); 7969: }else{ 7970: sqlite3_result_error_code(pCtx, rc); 7971: } 7972: } 7973: sqlite3_free(zErr); 7974: } 7975: 7976: /* 7977: ** xFinalize() callback for zipfile aggregate function. 7978: */ 7979: void zipfileFinal(sqlite3_context *pCtx){ 7980: ZipfileCtx *p; 7981: ZipfileEOCD eocd; 7982: sqlite3_int64 nZip; 7983: u8 *aZip; 7984: 7985: p = (ZipfileCtx*)sqlite3_aggregate_context(pCtx, sizeof(ZipfileCtx)); 7986: if( p==0 ) return; 7987: if( p->nEntry>0 ){ 7988: memset(&eocd, 0, sizeof(eocd)); 7989: eocd.nEntry = (u16)p->nEntry; 7990: eocd.nEntryTotal = (u16)p->nEntry; 7991: eocd.nSize = p->cds.n; 7992: eocd.iOffset = p->body.n; 7993: 7994: nZip = p->body.n + p->cds.n + ZIPFILE_EOCD_FIXED_SZ; 7995: aZip = (u8*)sqlite3_malloc64(nZip); 7996: if( aZip==0 ){ 7997: sqlite3_result_error_nomem(pCtx); 7998: }else{ 7999: memcpy(aZip, p->body.a, p->body.n); 8000: memcpy(&aZip[p->body.n], p->cds.a, p->cds.n); 8001: zipfileSerializeEOCD(&eocd, &aZip[p->body.n + p->cds.n]); 8002: sqlite3_result_blob(pCtx, aZip, (int)nZip, zipfileFree); 8003: } 8004: } 8005: 8006: sqlite3_free(p->body.a); 8007: sqlite3_free(p->cds.a); 8008: } 8009: 8010: 8011: /* 8012: ** Register the "zipfile" virtual table. 8013: */ 8014: static int zipfileRegister(sqlite3 *db){ 8015: static sqlite3_module zipfileModule = { 8016: 1, /* iVersion */ 8017: zipfileConnect, /* xCreate */ 8018: zipfileConnect, /* xConnect */ 8019: zipfileBestIndex, /* xBestIndex */ 8020: zipfileDisconnect, /* xDisconnect */ 8021: zipfileDisconnect, /* xDestroy */ 8022: zipfileOpen, /* xOpen - open a cursor */ 8023: zipfileClose, /* xClose - close a cursor */ 8024: zipfileFilter, /* xFilter - configure scan constraints */ 8025: zipfileNext, /* xNext - advance a cursor */ 8026: zipfileEof, /* xEof - check for end of scan */ 8027: zipfileColumn, /* xColumn - read data */ 8028: 0, /* xRowid - read data */ 8029: zipfileUpdate, /* xUpdate */ 8030: zipfileBegin, /* xBegin */ 8031: 0, /* xSync */ 8032: zipfileCommit, /* xCommit */ 8033: zipfileRollback, /* xRollback */ 8034: zipfileFindFunction, /* xFindMethod */ 8035: 0, /* xRename */ 8036: }; 8037: 8038: int rc = sqlite3_create_module(db, "zipfile" , &zipfileModule, 0); 8039: if( rc==SQLITE_OK ) rc = sqlite3_overload_function(db, "zipfile_cds", -1); 8040: if( rc==SQLITE_OK ){ 8041: rc = sqlite3_create_function(db, "zipfile", -1, SQLITE_UTF8, 0, 0, 8042: zipfileStep, zipfileFinal 8043: ); 8044: } 8045: return rc; 8046: } 8047: #else /* SQLITE_OMIT_VIRTUALTABLE */ 8048: # define zipfileRegister(x) SQLITE_OK 8049: #endif 8050: 8051: #ifdef _WIN32 8052: 8053: #endif 8054: int sqlite3_zipfile_init( 8055: sqlite3 *db, 8056: char **pzErrMsg, 8057: const sqlite3_api_routines *pApi 8058: ){ 8059: SQLITE_EXTENSION_INIT2(pApi); 8060: (void)pzErrMsg; /* Unused parameter */ 8061: return zipfileRegister(db); 8062: } 8063: 8064: /************************* End ../ext/misc/zipfile.c ********************/ 8065: /************************* Begin ../ext/misc/sqlar.c ******************/ 8066: /* 8067: ** 2017-12-17 8068: ** 8069: ** The author disclaims copyright to this source code. In place of 8070: ** a legal notice, here is a blessing: 8071: ** 8072: ** May you do good and not evil. 8073: ** May you find forgiveness for yourself and forgive others. 8074: ** May you share freely, never taking more than you give. 8075: ** 8076: ****************************************************************************** 8077: ** 8078: ** Utility functions sqlar_compress() and sqlar_uncompress(). Useful 8079: ** for working with sqlar archives and used by the shell tool's built-in 8080: ** sqlar support. 8081: */ 8082: /* #include "sqlite3ext.h" */ 8083: SQLITE_EXTENSION_INIT1 8084: #include <zlib.h> 8085: #include <assert.h> 8086: 8087: /* 8088: ** Implementation of the "sqlar_compress(X)" SQL function. 8089: ** 8090: ** If the type of X is SQLITE_BLOB, and compressing that blob using 8091: ** zlib utility function compress() yields a smaller blob, return the 8092: ** compressed blob. Otherwise, return a copy of X. 8093: ** 8094: ** SQLar uses the "zlib format" for compressed content. The zlib format 8095: ** contains a two-byte identification header and a four-byte checksum at 8096: ** the end. This is different from ZIP which uses the raw deflate format. 8097: ** 8098: ** Future enhancements to SQLar might add support for new compression formats. 8099: ** If so, those new formats will be identified by alternative headers in the 8100: ** compressed data. 8101: */ 8102: static void sqlarCompressFunc( 8103: sqlite3_context *context, 8104: int argc, 8105: sqlite3_value **argv 8106: ){ 8107: assert( argc==1 ); 8108: if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){ 8109: const Bytef *pData = sqlite3_value_blob(argv[0]); 8110: uLong nData = sqlite3_value_bytes(argv[0]); 8111: uLongf nOut = compressBound(nData); 8112: Bytef *pOut; 8113: 8114: pOut = (Bytef*)sqlite3_malloc(nOut); 8115: if( pOut==0 ){ 8116: sqlite3_result_error_nomem(context); 8117: return; 8118: }else{ 8119: if( Z_OK!=compress(pOut, &nOut, pData, nData) ){ 8120: sqlite3_result_error(context, "error in compress()", -1); 8121: }else if( nOut<nData ){ 8122: sqlite3_result_blob(context, pOut, nOut, SQLITE_TRANSIENT); 8123: }else{ 8124: sqlite3_result_value(context, argv[0]); 8125: } 8126: sqlite3_free(pOut); 8127: } 8128: }else{ 8129: sqlite3_result_value(context, argv[0]); 8130: } 8131: } 8132: 8133: /* 8134: ** Implementation of the "sqlar_uncompress(X,SZ)" SQL function 8135: ** 8136: ** Parameter SZ is interpreted as an integer. If it is less than or 8137: ** equal to zero, then this function returns a copy of X. Or, if 8138: ** SZ is equal to the size of X when interpreted as a blob, also 8139: ** return a copy of X. Otherwise, decompress blob X using zlib 8140: ** utility function uncompress() and return the results (another 8141: ** blob). 8142: */ 8143: static void sqlarUncompressFunc( 8144: sqlite3_context *context, 8145: int argc, 8146: sqlite3_value **argv 8147: ){ 8148: uLong nData; 8149: uLongf sz; 8150: 8151: assert( argc==2 ); 8152: sz = sqlite3_value_int(argv[1]); 8153: 8154: if( sz<=0 || sz==(nData = sqlite3_value_bytes(argv[0])) ){ 8155: sqlite3_result_value(context, argv[0]); 8156: }else{ 8157: const Bytef *pData= sqlite3_value_blob(argv[0]); 8158: Bytef *pOut = sqlite3_malloc(sz); 8159: if( Z_OK!=uncompress(pOut, &sz, pData, nData) ){ 8160: sqlite3_result_error(context, "error in uncompress()", -1); 8161: }else{ 8162: sqlite3_result_blob(context, pOut, sz, SQLITE_TRANSIENT); 8163: } 8164: sqlite3_free(pOut); 8165: } 8166: } 8167: 8168: 8169: #ifdef _WIN32 8170: 8171: #endif 8172: int sqlite3_sqlar_init( 8173: sqlite3 *db, 8174: char **pzErrMsg, 8175: const sqlite3_api_routines *pApi 8176: ){ 8177: int rc = SQLITE_OK; 8178: SQLITE_EXTENSION_INIT2(pApi); 8179: (void)pzErrMsg; /* Unused parameter */ 8180: rc = sqlite3_create_function(db, "sqlar_compress", 1, 8181: SQLITE_UTF8|SQLITE_INNOCUOUS, 0, 8182: sqlarCompressFunc, 0, 0); 8183: if( rc==SQLITE_OK ){ 8184: rc = sqlite3_create_function(db, "sqlar_uncompress", 2, 8185: SQLITE_UTF8|SQLITE_INNOCUOUS, 0, 8186: sqlarUncompressFunc, 0, 0); 8187: } 8188: return rc; 8189: } 8190: 8191: /************************* End ../ext/misc/sqlar.c ********************/ 8192: #endif 8193: /************************* Begin ../ext/expert/sqlite3expert.h ******************/ 8194: /* 8195: ** 2017 April 07 8196: ** 8197: ** The author disclaims copyright to this source code. In place of 8198: ** a legal notice, here is a blessing: 8199: ** 8200: ** May you do good and not evil. 8201: ** May you find forgiveness for yourself and forgive others. 8202: ** May you share freely, never taking more than you give. 8203: ** 8204: ************************************************************************* 8205: */ 8206: #if !defined(SQLITEEXPERT_H) 8207: #define SQLITEEXPERT_H 1 8208: /* #include "sqlite3.h" */ 8209: 8210: typedef struct sqlite3expert sqlite3expert; 8211: 8212: /* 8213: ** Create a new sqlite3expert object. 8214: ** 8215: ** If successful, a pointer to the new object is returned and (*pzErr) set 8216: ** to NULL. Or, if an error occurs, NULL is returned and (*pzErr) set to 8217: ** an English-language error message. In this case it is the responsibility 8218: ** of the caller to eventually free the error message buffer using 8219: ** sqlite3_free(). 8220: */ 8221: sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErr); 8222: 8223: /* 8224: ** Configure an sqlite3expert object. 8225: ** 8226: ** EXPERT_CONFIG_SAMPLE: 8227: ** By default, sqlite3_expert_analyze() generates sqlite_stat1 data for 8228: ** each candidate index. This involves scanning and sorting the entire 8229: ** contents of each user database table once for each candidate index 8230: ** associated with the table. For large databases, this can be 8231: ** prohibitively slow. This option allows the sqlite3expert object to 8232: ** be configured so that sqlite_stat1 data is instead generated based on a 8233: ** subset of each table, or so that no sqlite_stat1 data is used at all. 8234: ** 8235: ** A single integer argument is passed to this option. If the value is less 8236: ** than or equal to zero, then no sqlite_stat1 data is generated or used by 8237: ** the analysis - indexes are recommended based on the database schema only. 8238: ** Or, if the value is 100 or greater, complete sqlite_stat1 data is 8239: ** generated for each candidate index (this is the default). Finally, if the 8240: ** value falls between 0 and 100, then it represents the percentage of user 8241: ** table rows that should be considered when generating sqlite_stat1 data. 8242: ** 8243: ** Examples: 8244: ** 8245: ** // Do not generate any sqlite_stat1 data 8246: ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 0); 8247: ** 8248: ** // Generate sqlite_stat1 data based on 10% of the rows in each table. 8249: ** sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 10); 8250: */ 8251: int sqlite3_expert_config(sqlite3expert *p, int op, ...); 8252: 8253: #define EXPERT_CONFIG_SAMPLE 1 /* int */ 8254: 8255: /* 8256: ** Specify zero or more SQL statements to be included in the analysis. 8257: ** 8258: ** Buffer zSql must contain zero or more complete SQL statements. This 8259: ** function parses all statements contained in the buffer and adds them 8260: ** to the internal list of statements to analyze. If successful, SQLITE_OK 8261: ** is returned and (*pzErr) set to NULL. Or, if an error occurs - for example 8262: ** due to a error in the SQL - an SQLite error code is returned and (*pzErr) 8263: ** may be set to point to an English language error message. In this case 8264: ** the caller is responsible for eventually freeing the error message buffer 8265: ** using sqlite3_free(). 8266: ** 8267: ** If an error does occur while processing one of the statements in the 8268: ** buffer passed as the second argument, none of the statements in the 8269: ** buffer are added to the analysis. 8270: ** 8271: ** This function must be called before sqlite3_expert_analyze(). If a call 8272: ** to this function is made on an sqlite3expert object that has already 8273: ** been passed to sqlite3_expert_analyze() SQLITE_MISUSE is returned 8274: ** immediately and no statements are added to the analysis. 8275: */ 8276: int sqlite3_expert_sql( 8277: sqlite3expert *p, /* From a successful sqlite3_expert_new() */ 8278: const char *zSql, /* SQL statement(s) to add */ 8279: char **pzErr /* OUT: Error message (if any) */ 8280: ); 8281: 8282: 8283: /* 8284: ** This function is called after the sqlite3expert object has been configured 8285: ** with all SQL statements using sqlite3_expert_sql() to actually perform 8286: ** the analysis. Once this function has been called, it is not possible to 8287: ** add further SQL statements to the analysis. 8288: ** 8289: ** If successful, SQLITE_OK is returned and (*pzErr) is set to NULL. Or, if 8290: ** an error occurs, an SQLite error code is returned and (*pzErr) set to 8291: ** point to a buffer containing an English language error message. In this 8292: ** case it is the responsibility of the caller to eventually free the buffer 8293: ** using sqlite3_free(). 8294: ** 8295: ** If an error does occur within this function, the sqlite3expert object 8296: ** is no longer useful for any purpose. At that point it is no longer 8297: ** possible to add further SQL statements to the object or to re-attempt 8298: ** the analysis. The sqlite3expert object must still be freed using a call 8299: ** sqlite3_expert_destroy(). 8300: */ 8301: int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr); 8302: 8303: /* 8304: ** Return the total number of statements loaded using sqlite3_expert_sql(). 8305: ** The total number of SQL statements may be different from the total number 8306: ** to calls to sqlite3_expert_sql(). 8307: */ 8308: int sqlite3_expert_count(sqlite3expert*); 8309: 8310: /* 8311: ** Return a component of the report. 8312: ** 8313: ** This function is called after sqlite3_expert_analyze() to extract the 8314: ** results of the analysis. Each call to this function returns either a 8315: ** NULL pointer or a pointer to a buffer containing a nul-terminated string. 8316: ** The value passed as the third argument must be one of the EXPERT_REPORT_* 8317: ** #define constants defined below. 8318: ** 8319: ** For some EXPERT_REPORT_* parameters, the buffer returned contains 8320: ** information relating to a specific SQL statement. In these cases that 8321: ** SQL statement is identified by the value passed as the second argument. 8322: ** SQL statements are numbered from 0 in the order in which they are parsed. 8323: ** If an out-of-range value (less than zero or equal to or greater than the 8324: ** value returned by sqlite3_expert_count()) is passed as the second argument 8325: ** along with such an EXPERT_REPORT_* parameter, NULL is always returned. 8326: ** 8327: ** EXPERT_REPORT_SQL: 8328: ** Return the text of SQL statement iStmt. 8329: ** 8330: ** EXPERT_REPORT_INDEXES: 8331: ** Return a buffer containing the CREATE INDEX statements for all recommended 8332: ** indexes for statement iStmt. If there are no new recommeded indexes, NULL 8333: ** is returned. 8334: ** 8335: ** EXPERT_REPORT_PLAN: 8336: ** Return a buffer containing the EXPLAIN QUERY PLAN output for SQL query 8337: ** iStmt after the proposed indexes have been added to the database schema. 8338: ** 8339: ** EXPERT_REPORT_CANDIDATES: 8340: ** Return a pointer to a buffer containing the CREATE INDEX statements 8341: ** for all indexes that were tested (for all SQL statements). The iStmt 8342: ** parameter is ignored for EXPERT_REPORT_CANDIDATES calls. 8343: */ 8344: const char *sqlite3_expert_report(sqlite3expert*, int iStmt, int eReport); 8345: 8346: /* 8347: ** Values for the third argument passed to sqlite3_expert_report(). 8348: */ 8349: #define EXPERT_REPORT_SQL 1 8350: #define EXPERT_REPORT_INDEXES 2 8351: #define EXPERT_REPORT_PLAN 3 8352: #define EXPERT_REPORT_CANDIDATES 4 8353: 8354: /* 8355: ** Free an (sqlite3expert*) handle and all associated resources. There 8356: ** should be one call to this function for each successful call to 8357: ** sqlite3-expert_new(). 8358: */ 8359: void sqlite3_expert_destroy(sqlite3expert*); 8360: 8361: #endif /* !defined(SQLITEEXPERT_H) */ 8362: 8363: /************************* End ../ext/expert/sqlite3expert.h ********************/ 8364: /************************* Begin ../ext/expert/sqlite3expert.c ******************/ 8365: /* 8366: ** 2017 April 09 8367: ** 8368: ** The author disclaims copyright to this source code. In place of 8369: ** a legal notice, here is a blessing: 8370: ** 8371: ** May you do good and not evil. 8372: ** May you find forgiveness for yourself and forgive others. 8373: ** May you share freely, never taking more than you give. 8374: ** 8375: ************************************************************************* 8376: */ 8377: /* #include "sqlite3expert.h" */ 8378: #include <assert.h> 8379: #include <string.h> 8380: #include <stdio.h> 8381: 8382: #ifndef SQLITE_OMIT_VIRTUALTABLE 8383: 8384: /* typedef sqlite3_int64 i64; */ 8385: /* typedef sqlite3_uint64 u64; */ 8386: 8387: typedef struct IdxColumn IdxColumn; 8388: typedef struct IdxConstraint IdxConstraint; 8389: typedef struct IdxScan IdxScan; 8390: typedef struct IdxStatement IdxStatement; 8391: typedef struct IdxTable IdxTable; 8392: typedef struct IdxWrite IdxWrite; 8393: 8394: #define STRLEN (int)strlen 8395: 8396: /* 8397: ** A temp table name that we assume no user database will actually use. 8398: ** If this assumption proves incorrect triggers on the table with the 8399: ** conflicting name will be ignored. 8400: */ 8401: #define UNIQUE_TABLE_NAME "t592690916721053953805701627921227776" 8402: 8403: /* 8404: ** A single constraint. Equivalent to either "col = ?" or "col < ?" (or 8405: ** any other type of single-ended range constraint on a column). 8406: ** 8407: ** pLink: 8408: ** Used to temporarily link IdxConstraint objects into lists while 8409: ** creating candidate indexes. 8410: */ 8411: struct IdxConstraint { 8412: char *zColl; /* Collation sequence */ 8413: int bRange; /* True for range, false for eq */ 8414: int iCol; /* Constrained table column */ 8415: int bFlag; /* Used by idxFindCompatible() */ 8416: int bDesc; /* True if ORDER BY <expr> DESC */ 8417: IdxConstraint *pNext; /* Next constraint in pEq or pRange list */ 8418: IdxConstraint *pLink; /* See above */ 8419: }; 8420: 8421: /* 8422: ** A single scan of a single table. 8423: */ 8424: struct IdxScan { 8425: IdxTable *pTab; /* Associated table object */ 8426: int iDb; /* Database containing table zTable */ 8427: i64 covering; /* Mask of columns required for cov. index */ 8428: IdxConstraint *pOrder; /* ORDER BY columns */ 8429: IdxConstraint *pEq; /* List of == constraints */ 8430: IdxConstraint *pRange; /* List of < constraints */ 8431: IdxScan *pNextScan; /* Next IdxScan object for same analysis */ 8432: }; 8433: 8434: /* 8435: ** Information regarding a single database table. Extracted from 8436: ** "PRAGMA table_info" by function idxGetTableInfo(). 8437: */ 8438: struct IdxColumn { 8439: char *zName; 8440: char *zColl; 8441: int iPk; 8442: }; 8443: struct IdxTable { 8444: int nCol; 8445: char *zName; /* Table name */ 8446: IdxColumn *aCol; 8447: IdxTable *pNext; /* Next table in linked list of all tables */ 8448: }; 8449: 8450: /* 8451: ** An object of the following type is created for each unique table/write-op 8452: ** seen. The objects are stored in a singly-linked list beginning at 8453: ** sqlite3expert.pWrite. 8454: */ 8455: struct IdxWrite { 8456: IdxTable *pTab; 8457: int eOp; /* SQLITE_UPDATE, DELETE or INSERT */ 8458: IdxWrite *pNext; 8459: }; 8460: 8461: /* 8462: ** Each statement being analyzed is represented by an instance of this 8463: ** structure. 8464: */ 8465: struct IdxStatement { 8466: int iId; /* Statement number */ 8467: char *zSql; /* SQL statement */ 8468: char *zIdx; /* Indexes */ 8469: char *zEQP; /* Plan */ 8470: IdxStatement *pNext; 8471: }; 8472: 8473: 8474: /* 8475: ** A hash table for storing strings. With space for a payload string 8476: ** with each entry. Methods are: 8477: ** 8478: ** idxHashInit() 8479: ** idxHashClear() 8480: ** idxHashAdd() 8481: ** idxHashSearch() 8482: */ 8483: #define IDX_HASH_SIZE 1023 8484: typedef struct IdxHashEntry IdxHashEntry; 8485: typedef struct IdxHash IdxHash; 8486: struct IdxHashEntry { 8487: char *zKey; /* nul-terminated key */ 8488: char *zVal; /* nul-terminated value string */ 8489: char *zVal2; /* nul-terminated value string 2 */ 8490: IdxHashEntry *pHashNext; /* Next entry in same hash bucket */ 8491: IdxHashEntry *pNext; /* Next entry in hash */ 8492: }; 8493: struct IdxHash { 8494: IdxHashEntry *pFirst; 8495: IdxHashEntry *aHash[IDX_HASH_SIZE]; 8496: }; 8497: 8498: /* 8499: ** sqlite3expert object. 8500: */ 8501: struct sqlite3expert { 8502: int iSample; /* Percentage of tables to sample for stat1 */ 8503: sqlite3 *db; /* User database */ 8504: sqlite3 *dbm; /* In-memory db for this analysis */ 8505: sqlite3 *dbv; /* Vtab schema for this analysis */ 8506: IdxTable *pTable; /* List of all IdxTable objects */ 8507: IdxScan *pScan; /* List of scan objects */ 8508: IdxWrite *pWrite; /* List of write objects */ 8509: IdxStatement *pStatement; /* List of IdxStatement objects */ 8510: int bRun; /* True once analysis has run */ 8511: char **pzErrmsg; 8512: int rc; /* Error code from whereinfo hook */ 8513: IdxHash hIdx; /* Hash containing all candidate indexes */ 8514: char *zCandidates; /* For EXPERT_REPORT_CANDIDATES */ 8515: }; 8516: 8517: 8518: /* 8519: ** Allocate and return nByte bytes of zeroed memory using sqlite3_malloc(). 8520: ** If the allocation fails, set *pRc to SQLITE_NOMEM and return NULL. 8521: */ 8522: static void *idxMalloc(int *pRc, int nByte){ 8523: void *pRet; 8524: assert( *pRc==SQLITE_OK ); 8525: assert( nByte>0 ); 8526: pRet = sqlite3_malloc(nByte); 8527: if( pRet ){ 8528: memset(pRet, 0, nByte); 8529: }else{ 8530: *pRc = SQLITE_NOMEM; 8531: } 8532: return pRet; 8533: } 8534: 8535: /* 8536: ** Initialize an IdxHash hash table. 8537: */ 8538: static void idxHashInit(IdxHash *pHash){ 8539: memset(pHash, 0, sizeof(IdxHash)); 8540: } 8541: 8542: /* 8543: ** Reset an IdxHash hash table. 8544: */ 8545: static void idxHashClear(IdxHash *pHash){ 8546: int i; 8547: for(i=0; i<IDX_HASH_SIZE; i++){ 8548: IdxHashEntry *pEntry; 8549: IdxHashEntry *pNext; 8550: for(pEntry=pHash->aHash[i]; pEntry; pEntry=pNext){ 8551: pNext = pEntry->pHashNext; 8552: sqlite3_free(pEntry->zVal2); 8553: sqlite3_free(pEntry); 8554: } 8555: } 8556: memset(pHash, 0, sizeof(IdxHash)); 8557: } 8558: 8559: /* 8560: ** Return the index of the hash bucket that the string specified by the 8561: ** arguments to this function belongs. 8562: */ 8563: static int idxHashString(const char *z, int n){ 8564: unsigned int ret = 0; 8565: int i; 8566: for(i=0; i<n; i++){ 8567: ret += (ret<<3) + (unsigned char)(z[i]); 8568: } 8569: return (int)(ret % IDX_HASH_SIZE); 8570: } 8571: 8572: /* 8573: ** If zKey is already present in the hash table, return non-zero and do 8574: ** nothing. Otherwise, add an entry with key zKey and payload string zVal to 8575: ** the hash table passed as the second argument. 8576: */ 8577: static int idxHashAdd( 8578: int *pRc, 8579: IdxHash *pHash, 8580: const char *zKey, 8581: const char *zVal 8582: ){ 8583: int nKey = STRLEN(zKey); 8584: int iHash = idxHashString(zKey, nKey); 8585: int nVal = (zVal ? STRLEN(zVal) : 0); 8586: IdxHashEntry *pEntry; 8587: assert( iHash>=0 ); 8588: for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){ 8589: if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){ 8590: return 1; 8591: } 8592: } 8593: pEntry = idxMalloc(pRc, sizeof(IdxHashEntry) + nKey+1 + nVal+1); 8594: if( pEntry ){ 8595: pEntry->zKey = (char*)&pEntry[1]; 8596: memcpy(pEntry->zKey, zKey, nKey); 8597: if( zVal ){ 8598: pEntry->zVal = &pEntry->zKey[nKey+1]; 8599: memcpy(pEntry->zVal, zVal, nVal); 8600: } 8601: pEntry->pHashNext = pHash->aHash[iHash]; 8602: pHash->aHash[iHash] = pEntry; 8603: 8604: pEntry->pNext = pHash->pFirst; 8605: pHash->pFirst = pEntry; 8606: } 8607: return 0; 8608: } 8609: 8610: /* 8611: ** If zKey/nKey is present in the hash table, return a pointer to the 8612: ** hash-entry object. 8613: */ 8614: static IdxHashEntry *idxHashFind(IdxHash *pHash, const char *zKey, int nKey){ 8615: int iHash; 8616: IdxHashEntry *pEntry; 8617: if( nKey<0 ) nKey = STRLEN(zKey); 8618: iHash = idxHashString(zKey, nKey); 8619: assert( iHash>=0 ); 8620: for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){ 8621: if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){ 8622: return pEntry; 8623: } 8624: } 8625: return 0; 8626: } 8627: 8628: /* 8629: ** If the hash table contains an entry with a key equal to the string 8630: ** passed as the final two arguments to this function, return a pointer 8631: ** to the payload string. Otherwise, if zKey/nKey is not present in the 8632: ** hash table, return NULL. 8633: */ 8634: static const char *idxHashSearch(IdxHash *pHash, const char *zKey, int nKey){ 8635: IdxHashEntry *pEntry = idxHashFind(pHash, zKey, nKey); 8636: if( pEntry ) return pEntry->zVal; 8637: return 0; 8638: } 8639: 8640: /* 8641: ** Allocate and return a new IdxConstraint object. Set the IdxConstraint.zColl 8642: ** variable to point to a copy of nul-terminated string zColl. 8643: */ 8644: static IdxConstraint *idxNewConstraint(int *pRc, const char *zColl){ 8645: IdxConstraint *pNew; 8646: int nColl = STRLEN(zColl); 8647: 8648: assert( *pRc==SQLITE_OK ); 8649: pNew = (IdxConstraint*)idxMalloc(pRc, sizeof(IdxConstraint) * nColl + 1); 8650: if( pNew ){ 8651: pNew->zColl = (char*)&pNew[1]; 8652: memcpy(pNew->zColl, zColl, nColl+1); 8653: } 8654: return pNew; 8655: } 8656: 8657: /* 8658: ** An error associated with database handle db has just occurred. Pass 8659: ** the error message to callback function xOut. 8660: */ 8661: static void idxDatabaseError( 8662: sqlite3 *db, /* Database handle */ 8663: char **pzErrmsg /* Write error here */ 8664: ){ 8665: *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); 8666: } 8667: 8668: /* 8669: ** Prepare an SQL statement. 8670: */ 8671: static int idxPrepareStmt( 8672: sqlite3 *db, /* Database handle to compile against */ 8673: sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */ 8674: char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */ 8675: const char *zSql /* SQL statement to compile */ 8676: ){ 8677: int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); 8678: if( rc!=SQLITE_OK ){ 8679: *ppStmt = 0; 8680: idxDatabaseError(db, pzErrmsg); 8681: } 8682: return rc; 8683: } 8684: 8685: /* 8686: ** Prepare an SQL statement using the results of a printf() formatting. 8687: */ 8688: static int idxPrintfPrepareStmt( 8689: sqlite3 *db, /* Database handle to compile against */ 8690: sqlite3_stmt **ppStmt, /* OUT: Compiled SQL statement */ 8691: char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */ 8692: const char *zFmt, /* printf() format of SQL statement */ 8693: ... /* Trailing printf() arguments */ 8694: ){ 8695: va_list ap; 8696: int rc; 8697: char *zSql; 8698: va_start(ap, zFmt); 8699: zSql = sqlite3_vmprintf(zFmt, ap); 8700: if( zSql==0 ){ 8701: rc = SQLITE_NOMEM; 8702: }else{ 8703: rc = idxPrepareStmt(db, ppStmt, pzErrmsg, zSql); 8704: sqlite3_free(zSql); 8705: } 8706: va_end(ap); 8707: return rc; 8708: } 8709: 8710: 8711: /************************************************************************* 8712: ** Beginning of virtual table implementation. 8713: */ 8714: typedef struct ExpertVtab ExpertVtab; 8715: struct ExpertVtab { 8716: sqlite3_vtab base; 8717: IdxTable *pTab; 8718: sqlite3expert *pExpert; 8719: }; 8720: 8721: typedef struct ExpertCsr ExpertCsr; 8722: struct ExpertCsr { 8723: sqlite3_vtab_cursor base; 8724: sqlite3_stmt *pData; 8725: }; 8726: 8727: static char *expertDequote(const char *zIn){ 8728: int n = STRLEN(zIn); 8729: char *zRet = sqlite3_malloc(n); 8730: 8731: assert( zIn[0]=='\'' ); 8732: assert( zIn[n-1]=='\'' ); 8733: 8734: if( zRet ){ 8735: int iOut = 0; 8736: int iIn = 0; 8737: for(iIn=1; iIn<(n-1); iIn++){ 8738: if( zIn[iIn]=='\'' ){ 8739: assert( zIn[iIn+1]=='\'' ); 8740: iIn++; 8741: } 8742: zRet[iOut++] = zIn[iIn]; 8743: } 8744: zRet[iOut] = '\0'; 8745: } 8746: 8747: return zRet; 8748: } 8749: 8750: /* 8751: ** This function is the implementation of both the xConnect and xCreate 8752: ** methods of the r-tree virtual table. 8753: ** 8754: ** argv[0] -> module name 8755: ** argv[1] -> database name 8756: ** argv[2] -> table name 8757: ** argv[...] -> column names... 8758: */ 8759: static int expertConnect( 8760: sqlite3 *db, 8761: void *pAux, 8762: int argc, const char *const*argv, 8763: sqlite3_vtab **ppVtab, 8764: char **pzErr 8765: ){ 8766: sqlite3expert *pExpert = (sqlite3expert*)pAux; 8767: ExpertVtab *p = 0; 8768: int rc; 8769: 8770: if( argc!=4 ){ 8771: *pzErr = sqlite3_mprintf("internal error!"); 8772: rc = SQLITE_ERROR; 8773: }else{ 8774: char *zCreateTable = expertDequote(argv[3]); 8775: if( zCreateTable ){ 8776: rc = sqlite3_declare_vtab(db, zCreateTable); 8777: if( rc==SQLITE_OK ){ 8778: p = idxMalloc(&rc, sizeof(ExpertVtab)); 8779: } 8780: if( rc==SQLITE_OK ){ 8781: p->pExpert = pExpert; 8782: p->pTab = pExpert->pTable; 8783: assert( sqlite3_stricmp(p->pTab->zName, argv[2])==0 ); 8784: } 8785: sqlite3_free(zCreateTable); 8786: }else{ 8787: rc = SQLITE_NOMEM; 8788: } 8789: } 8790: 8791: *ppVtab = (sqlite3_vtab*)p; 8792: return rc; 8793: } 8794: 8795: static int expertDisconnect(sqlite3_vtab *pVtab){ 8796: ExpertVtab *p = (ExpertVtab*)pVtab; 8797: sqlite3_free(p); 8798: return SQLITE_OK; 8799: } 8800: 8801: static int expertBestIndex(sqlite3_vtab *pVtab, sqlite3_index_info *pIdxInfo){ 8802: ExpertVtab *p = (ExpertVtab*)pVtab; 8803: int rc = SQLITE_OK; 8804: int n = 0; 8805: IdxScan *pScan; 8806: const int opmask = 8807: SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_GT | 8808: SQLITE_INDEX_CONSTRAINT_LT | SQLITE_INDEX_CONSTRAINT_GE | 8809: SQLITE_INDEX_CONSTRAINT_LE; 8810: 8811: pScan = idxMalloc(&rc, sizeof(IdxScan)); 8812: if( pScan ){ 8813: int i; 8814: 8815: /* Link the new scan object into the list */ 8816: pScan->pTab = p->pTab; 8817: pScan->pNextScan = p->pExpert->pScan; 8818: p->pExpert->pScan = pScan; 8819: 8820: /* Add the constraints to the IdxScan object */ 8821: for(i=0; i<pIdxInfo->nConstraint; i++){ 8822: struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i]; 8823: if( pCons->usable 8824: && pCons->iColumn>=0 8825: && p->pTab->aCol[pCons->iColumn].iPk==0 8826: && (pCons->op & opmask) 8827: ){ 8828: IdxConstraint *pNew; 8829: const char *zColl = sqlite3_vtab_collation(pIdxInfo, i); 8830: pNew = idxNewConstraint(&rc, zColl); 8831: if( pNew ){ 8832: pNew->iCol = pCons->iColumn; 8833: if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 8834: pNew->pNext = pScan->pEq; 8835: pScan->pEq = pNew; 8836: }else{ 8837: pNew->bRange = 1; 8838: pNew->pNext = pScan->pRange; 8839: pScan->pRange = pNew; 8840: } 8841: } 8842: n++; 8843: pIdxInfo->aConstraintUsage[i].argvIndex = n; 8844: } 8845: } 8846: 8847: /* Add the ORDER BY to the IdxScan object */ 8848: for(i=pIdxInfo->nOrderBy-1; i>=0; i--){ 8849: int iCol = pIdxInfo->aOrderBy[i].iColumn; 8850: if( iCol>=0 ){ 8851: IdxConstraint *pNew = idxNewConstraint(&rc, p->pTab->aCol[iCol].zColl); 8852: if( pNew ){ 8853: pNew->iCol = iCol; 8854: pNew->bDesc = pIdxInfo->aOrderBy[i].desc; 8855: pNew->pNext = pScan->pOrder; 8856: pNew->pLink = pScan->pOrder; 8857: pScan->pOrder = pNew; 8858: n++; 8859: } 8860: } 8861: } 8862: } 8863: 8864: pIdxInfo->estimatedCost = 1000000.0 / (n+1); 8865: return rc; 8866: } 8867: 8868: static int expertUpdate( 8869: sqlite3_vtab *pVtab, 8870: int nData, 8871: sqlite3_value **azData, 8872: sqlite_int64 *pRowid 8873: ){ 8874: (void)pVtab; 8875: (void)nData; 8876: (void)azData; 8877: (void)pRowid; 8878: return SQLITE_OK; 8879: } 8880: 8881: /* 8882: ** Virtual table module xOpen method. 8883: */ 8884: static int expertOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ 8885: int rc = SQLITE_OK; 8886: ExpertCsr *pCsr; 8887: (void)pVTab; 8888: pCsr = idxMalloc(&rc, sizeof(ExpertCsr)); 8889: *ppCursor = (sqlite3_vtab_cursor*)pCsr; 8890: return rc; 8891: } 8892: 8893: /* 8894: ** Virtual table module xClose method. 8895: */ 8896: static int expertClose(sqlite3_vtab_cursor *cur){ 8897: ExpertCsr *pCsr = (ExpertCsr*)cur; 8898: sqlite3_finalize(pCsr->pData); 8899: sqlite3_free(pCsr); 8900: return SQLITE_OK; 8901: } 8902: 8903: /* 8904: ** Virtual table module xEof method. 8905: ** 8906: ** Return non-zero if the cursor does not currently point to a valid 8907: ** record (i.e if the scan has finished), or zero otherwise. 8908: */ 8909: static int expertEof(sqlite3_vtab_cursor *cur){ 8910: ExpertCsr *pCsr = (ExpertCsr*)cur; 8911: return pCsr->pData==0; 8912: } 8913: 8914: /* 8915: ** Virtual table module xNext method. 8916: */ 8917: static int expertNext(sqlite3_vtab_cursor *cur){ 8918: ExpertCsr *pCsr = (ExpertCsr*)cur; 8919: int rc = SQLITE_OK; 8920: 8921: assert( pCsr->pData ); 8922: rc = sqlite3_step(pCsr->pData); 8923: if( rc!=SQLITE_ROW ){ 8924: rc = sqlite3_finalize(pCsr->pData); 8925: pCsr->pData = 0; 8926: }else{ 8927: rc = SQLITE_OK; 8928: } 8929: 8930: return rc; 8931: } 8932: 8933: /* 8934: ** Virtual table module xRowid method. 8935: */ 8936: static int expertRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 8937: (void)cur; 8938: *pRowid = 0; 8939: return SQLITE_OK; 8940: } 8941: 8942: /* 8943: ** Virtual table module xColumn method. 8944: */ 8945: static int expertColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ 8946: ExpertCsr *pCsr = (ExpertCsr*)cur; 8947: sqlite3_value *pVal; 8948: pVal = sqlite3_column_value(pCsr->pData, i); 8949: if( pVal ){ 8950: sqlite3_result_value(ctx, pVal); 8951: } 8952: return SQLITE_OK; 8953: } 8954: 8955: /* 8956: ** Virtual table module xFilter method. 8957: */ 8958: static int expertFilter( 8959: sqlite3_vtab_cursor *cur, 8960: int idxNum, const char *idxStr, 8961: int argc, sqlite3_value **argv 8962: ){ 8963: ExpertCsr *pCsr = (ExpertCsr*)cur; 8964: ExpertVtab *pVtab = (ExpertVtab*)(cur->pVtab); 8965: sqlite3expert *pExpert = pVtab->pExpert; 8966: int rc; 8967: 8968: (void)idxNum; 8969: (void)idxStr; 8970: (void)argc; 8971: (void)argv; 8972: rc = sqlite3_finalize(pCsr->pData); 8973: pCsr->pData = 0; 8974: if( rc==SQLITE_OK ){ 8975: rc = idxPrintfPrepareStmt(pExpert->db, &pCsr->pData, &pVtab->base.zErrMsg, 8976: "SELECT * FROM main.%Q WHERE sample()", pVtab->pTab->zName 8977: ); 8978: } 8979: 8980: if( rc==SQLITE_OK ){ 8981: rc = expertNext(cur); 8982: } 8983: return rc; 8984: } 8985: 8986: static int idxRegisterVtab(sqlite3expert *p){ 8987: static sqlite3_module expertModule = { 8988: 2, /* iVersion */ 8989: expertConnect, /* xCreate - create a table */ 8990: expertConnect, /* xConnect - connect to an existing table */ 8991: expertBestIndex, /* xBestIndex - Determine search strategy */ 8992: expertDisconnect, /* xDisconnect - Disconnect from a table */ 8993: expertDisconnect, /* xDestroy - Drop a table */ 8994: expertOpen, /* xOpen - open a cursor */ 8995: expertClose, /* xClose - close a cursor */ 8996: expertFilter, /* xFilter - configure scan constraints */ 8997: expertNext, /* xNext - advance a cursor */ 8998: expertEof, /* xEof */ 8999: expertColumn, /* xColumn - read data */ 9000: expertRowid, /* xRowid - read data */ 9001: expertUpdate, /* xUpdate - write data */ 9002: 0, /* xBegin - begin transaction */ 9003: 0, /* xSync - sync transaction */ 9004: 0, /* xCommit - commit transaction */ 9005: 0, /* xRollback - rollback transaction */ 9006: 0, /* xFindFunction - function overloading */ 9007: 0, /* xRename - rename the table */ 9008: 0, /* xSavepoint */ 9009: 0, /* xRelease */ 9010: 0, /* xRollbackTo */ 9011: 0, /* xShadowName */ 9012: }; 9013: 9014: return sqlite3_create_module(p->dbv, "expert", &expertModule, (void*)p); 9015: } 9016: /* 9017: ** End of virtual table implementation. 9018: *************************************************************************/ 9019: /* 9020: ** Finalize SQL statement pStmt. If (*pRc) is SQLITE_OK when this function 9021: ** is called, set it to the return value of sqlite3_finalize() before 9022: ** returning. Otherwise, discard the sqlite3_finalize() return value. 9023: */ 9024: static void idxFinalize(int *pRc, sqlite3_stmt *pStmt){ 9025: int rc = sqlite3_finalize(pStmt); 9026: if( *pRc==SQLITE_OK ) *pRc = rc; 9027: } 9028: 9029: /* 9030: ** Attempt to allocate an IdxTable structure corresponding to table zTab 9031: ** in the main database of connection db. If successful, set (*ppOut) to 9032: ** point to the new object and return SQLITE_OK. Otherwise, return an 9033: ** SQLite error code and set (*ppOut) to NULL. In this case *pzErrmsg may be 9034: ** set to point to an error string. 9035: ** 9036: ** It is the responsibility of the caller to eventually free either the 9037: ** IdxTable object or error message using sqlite3_free(). 9038: */ 9039: static int idxGetTableInfo( 9040: sqlite3 *db, /* Database connection to read details from */ 9041: const char *zTab, /* Table name */ 9042: IdxTable **ppOut, /* OUT: New object (if successful) */ 9043: char **pzErrmsg /* OUT: Error message (if not) */ 9044: ){ 9045: sqlite3_stmt *p1 = 0; 9046: int nCol = 0; 9047: int nTab = STRLEN(zTab); 9048: int nByte = sizeof(IdxTable) + nTab + 1; 9049: IdxTable *pNew = 0; 9050: int rc, rc2; 9051: char *pCsr = 0; 1.6 ! misho 9052: int nPk = 0; 1.5 misho 9053: 1.6 ! misho 9054: rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_xinfo=%Q", zTab); 1.5 misho 9055: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){ 9056: const char *zCol = (const char*)sqlite3_column_text(p1, 1); 9057: nByte += 1 + STRLEN(zCol); 9058: rc = sqlite3_table_column_metadata( 9059: db, "main", zTab, zCol, 0, &zCol, 0, 0, 0 9060: ); 9061: nByte += 1 + STRLEN(zCol); 9062: nCol++; 1.6 ! misho 9063: nPk += (sqlite3_column_int(p1, 5)>0); 1.5 misho 9064: } 9065: rc2 = sqlite3_reset(p1); 9066: if( rc==SQLITE_OK ) rc = rc2; 9067: 9068: nByte += sizeof(IdxColumn) * nCol; 9069: if( rc==SQLITE_OK ){ 9070: pNew = idxMalloc(&rc, nByte); 9071: } 9072: if( rc==SQLITE_OK ){ 9073: pNew->aCol = (IdxColumn*)&pNew[1]; 9074: pNew->nCol = nCol; 9075: pCsr = (char*)&pNew->aCol[nCol]; 9076: } 9077: 9078: nCol = 0; 9079: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){ 9080: const char *zCol = (const char*)sqlite3_column_text(p1, 1); 9081: int nCopy = STRLEN(zCol) + 1; 9082: pNew->aCol[nCol].zName = pCsr; 1.6 ! misho 9083: pNew->aCol[nCol].iPk = (sqlite3_column_int(p1, 5)==1 && nPk==1); 1.5 misho 9084: memcpy(pCsr, zCol, nCopy); 9085: pCsr += nCopy; 9086: 9087: rc = sqlite3_table_column_metadata( 9088: db, "main", zTab, zCol, 0, &zCol, 0, 0, 0 9089: ); 9090: if( rc==SQLITE_OK ){ 9091: nCopy = STRLEN(zCol) + 1; 9092: pNew->aCol[nCol].zColl = pCsr; 9093: memcpy(pCsr, zCol, nCopy); 9094: pCsr += nCopy; 9095: } 9096: 9097: nCol++; 9098: } 9099: idxFinalize(&rc, p1); 9100: 9101: if( rc!=SQLITE_OK ){ 9102: sqlite3_free(pNew); 9103: pNew = 0; 9104: }else{ 9105: pNew->zName = pCsr; 9106: memcpy(pNew->zName, zTab, nTab+1); 9107: } 9108: 9109: *ppOut = pNew; 9110: return rc; 9111: } 9112: 9113: /* 9114: ** This function is a no-op if *pRc is set to anything other than 9115: ** SQLITE_OK when it is called. 9116: ** 9117: ** If *pRc is initially set to SQLITE_OK, then the text specified by 9118: ** the printf() style arguments is appended to zIn and the result returned 9119: ** in a buffer allocated by sqlite3_malloc(). sqlite3_free() is called on 9120: ** zIn before returning. 9121: */ 9122: static char *idxAppendText(int *pRc, char *zIn, const char *zFmt, ...){ 9123: va_list ap; 9124: char *zAppend = 0; 9125: char *zRet = 0; 9126: int nIn = zIn ? STRLEN(zIn) : 0; 9127: int nAppend = 0; 9128: va_start(ap, zFmt); 9129: if( *pRc==SQLITE_OK ){ 9130: zAppend = sqlite3_vmprintf(zFmt, ap); 9131: if( zAppend ){ 9132: nAppend = STRLEN(zAppend); 9133: zRet = (char*)sqlite3_malloc(nIn + nAppend + 1); 9134: } 9135: if( zAppend && zRet ){ 9136: if( nIn ) memcpy(zRet, zIn, nIn); 9137: memcpy(&zRet[nIn], zAppend, nAppend+1); 9138: }else{ 9139: sqlite3_free(zRet); 9140: zRet = 0; 9141: *pRc = SQLITE_NOMEM; 9142: } 9143: sqlite3_free(zAppend); 9144: sqlite3_free(zIn); 9145: } 9146: va_end(ap); 9147: return zRet; 9148: } 9149: 9150: /* 9151: ** Return true if zId must be quoted in order to use it as an SQL 9152: ** identifier, or false otherwise. 9153: */ 9154: static int idxIdentifierRequiresQuotes(const char *zId){ 9155: int i; 9156: for(i=0; zId[i]; i++){ 9157: if( !(zId[i]=='_') 9158: && !(zId[i]>='0' && zId[i]<='9') 9159: && !(zId[i]>='a' && zId[i]<='z') 9160: && !(zId[i]>='A' && zId[i]<='Z') 9161: ){ 9162: return 1; 9163: } 9164: } 9165: return 0; 9166: } 9167: 9168: /* 9169: ** This function appends an index column definition suitable for constraint 9170: ** pCons to the string passed as zIn and returns the result. 9171: */ 9172: static char *idxAppendColDefn( 9173: int *pRc, /* IN/OUT: Error code */ 9174: char *zIn, /* Column defn accumulated so far */ 9175: IdxTable *pTab, /* Table index will be created on */ 9176: IdxConstraint *pCons 9177: ){ 9178: char *zRet = zIn; 9179: IdxColumn *p = &pTab->aCol[pCons->iCol]; 9180: if( zRet ) zRet = idxAppendText(pRc, zRet, ", "); 9181: 9182: if( idxIdentifierRequiresQuotes(p->zName) ){ 9183: zRet = idxAppendText(pRc, zRet, "%Q", p->zName); 9184: }else{ 9185: zRet = idxAppendText(pRc, zRet, "%s", p->zName); 9186: } 9187: 9188: if( sqlite3_stricmp(p->zColl, pCons->zColl) ){ 9189: if( idxIdentifierRequiresQuotes(pCons->zColl) ){ 9190: zRet = idxAppendText(pRc, zRet, " COLLATE %Q", pCons->zColl); 9191: }else{ 9192: zRet = idxAppendText(pRc, zRet, " COLLATE %s", pCons->zColl); 9193: } 9194: } 9195: 9196: if( pCons->bDesc ){ 9197: zRet = idxAppendText(pRc, zRet, " DESC"); 9198: } 9199: return zRet; 9200: } 9201: 9202: /* 9203: ** Search database dbm for an index compatible with the one idxCreateFromCons() 9204: ** would create from arguments pScan, pEq and pTail. If no error occurs and 9205: ** such an index is found, return non-zero. Or, if no such index is found, 9206: ** return zero. 9207: ** 9208: ** If an error occurs, set *pRc to an SQLite error code and return zero. 9209: */ 9210: static int idxFindCompatible( 9211: int *pRc, /* OUT: Error code */ 9212: sqlite3* dbm, /* Database to search */ 9213: IdxScan *pScan, /* Scan for table to search for index on */ 9214: IdxConstraint *pEq, /* List of == constraints */ 9215: IdxConstraint *pTail /* List of range constraints */ 9216: ){ 9217: const char *zTbl = pScan->pTab->zName; 9218: sqlite3_stmt *pIdxList = 0; 9219: IdxConstraint *pIter; 9220: int nEq = 0; /* Number of elements in pEq */ 9221: int rc; 9222: 9223: /* Count the elements in list pEq */ 9224: for(pIter=pEq; pIter; pIter=pIter->pLink) nEq++; 9225: 9226: rc = idxPrintfPrepareStmt(dbm, &pIdxList, 0, "PRAGMA index_list=%Q", zTbl); 9227: while( rc==SQLITE_OK && sqlite3_step(pIdxList)==SQLITE_ROW ){ 9228: int bMatch = 1; 9229: IdxConstraint *pT = pTail; 9230: sqlite3_stmt *pInfo = 0; 9231: const char *zIdx = (const char*)sqlite3_column_text(pIdxList, 1); 9232: 9233: /* Zero the IdxConstraint.bFlag values in the pEq list */ 9234: for(pIter=pEq; pIter; pIter=pIter->pLink) pIter->bFlag = 0; 9235: 9236: rc = idxPrintfPrepareStmt(dbm, &pInfo, 0, "PRAGMA index_xInfo=%Q", zIdx); 9237: while( rc==SQLITE_OK && sqlite3_step(pInfo)==SQLITE_ROW ){ 9238: int iIdx = sqlite3_column_int(pInfo, 0); 9239: int iCol = sqlite3_column_int(pInfo, 1); 9240: const char *zColl = (const char*)sqlite3_column_text(pInfo, 4); 9241: 9242: if( iIdx<nEq ){ 9243: for(pIter=pEq; pIter; pIter=pIter->pLink){ 9244: if( pIter->bFlag ) continue; 9245: if( pIter->iCol!=iCol ) continue; 9246: if( sqlite3_stricmp(pIter->zColl, zColl) ) continue; 9247: pIter->bFlag = 1; 9248: break; 9249: } 9250: if( pIter==0 ){ 9251: bMatch = 0; 9252: break; 9253: } 9254: }else{ 9255: if( pT ){ 9256: if( pT->iCol!=iCol || sqlite3_stricmp(pT->zColl, zColl) ){ 9257: bMatch = 0; 9258: break; 9259: } 9260: pT = pT->pLink; 9261: } 9262: } 9263: } 9264: idxFinalize(&rc, pInfo); 9265: 9266: if( rc==SQLITE_OK && bMatch ){ 9267: sqlite3_finalize(pIdxList); 9268: return 1; 9269: } 9270: } 9271: idxFinalize(&rc, pIdxList); 9272: 9273: *pRc = rc; 9274: return 0; 9275: } 9276: 9277: static int idxCreateFromCons( 9278: sqlite3expert *p, 9279: IdxScan *pScan, 9280: IdxConstraint *pEq, 9281: IdxConstraint *pTail 9282: ){ 9283: sqlite3 *dbm = p->dbm; 9284: int rc = SQLITE_OK; 9285: if( (pEq || pTail) && 0==idxFindCompatible(&rc, dbm, pScan, pEq, pTail) ){ 9286: IdxTable *pTab = pScan->pTab; 9287: char *zCols = 0; 9288: char *zIdx = 0; 9289: IdxConstraint *pCons; 9290: unsigned int h = 0; 9291: const char *zFmt; 9292: 9293: for(pCons=pEq; pCons; pCons=pCons->pLink){ 9294: zCols = idxAppendColDefn(&rc, zCols, pTab, pCons); 9295: } 9296: for(pCons=pTail; pCons; pCons=pCons->pLink){ 9297: zCols = idxAppendColDefn(&rc, zCols, pTab, pCons); 9298: } 9299: 9300: if( rc==SQLITE_OK ){ 9301: /* Hash the list of columns to come up with a name for the index */ 9302: const char *zTable = pScan->pTab->zName; 9303: char *zName; /* Index name */ 9304: int i; 9305: for(i=0; zCols[i]; i++){ 9306: h += ((h<<3) + zCols[i]); 9307: } 9308: zName = sqlite3_mprintf("%s_idx_%08x", zTable, h); 9309: if( zName==0 ){ 9310: rc = SQLITE_NOMEM; 9311: }else{ 9312: if( idxIdentifierRequiresQuotes(zTable) ){ 9313: zFmt = "CREATE INDEX '%q' ON %Q(%s)"; 9314: }else{ 9315: zFmt = "CREATE INDEX %s ON %s(%s)"; 9316: } 9317: zIdx = sqlite3_mprintf(zFmt, zName, zTable, zCols); 9318: if( !zIdx ){ 9319: rc = SQLITE_NOMEM; 9320: }else{ 9321: rc = sqlite3_exec(dbm, zIdx, 0, 0, p->pzErrmsg); 9322: idxHashAdd(&rc, &p->hIdx, zName, zIdx); 9323: } 9324: sqlite3_free(zName); 9325: sqlite3_free(zIdx); 9326: } 9327: } 9328: 9329: sqlite3_free(zCols); 9330: } 9331: return rc; 9332: } 9333: 9334: /* 9335: ** Return true if list pList (linked by IdxConstraint.pLink) contains 9336: ** a constraint compatible with *p. Otherwise return false. 9337: */ 9338: static int idxFindConstraint(IdxConstraint *pList, IdxConstraint *p){ 9339: IdxConstraint *pCmp; 9340: for(pCmp=pList; pCmp; pCmp=pCmp->pLink){ 9341: if( p->iCol==pCmp->iCol ) return 1; 9342: } 9343: return 0; 9344: } 9345: 9346: static int idxCreateFromWhere( 9347: sqlite3expert *p, 9348: IdxScan *pScan, /* Create indexes for this scan */ 9349: IdxConstraint *pTail /* range/ORDER BY constraints for inclusion */ 9350: ){ 9351: IdxConstraint *p1 = 0; 9352: IdxConstraint *pCon; 9353: int rc; 9354: 9355: /* Gather up all the == constraints. */ 9356: for(pCon=pScan->pEq; pCon; pCon=pCon->pNext){ 9357: if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){ 9358: pCon->pLink = p1; 9359: p1 = pCon; 9360: } 9361: } 9362: 9363: /* Create an index using the == constraints collected above. And the 9364: ** range constraint/ORDER BY terms passed in by the caller, if any. */ 9365: rc = idxCreateFromCons(p, pScan, p1, pTail); 9366: 9367: /* If no range/ORDER BY passed by the caller, create a version of the 9368: ** index for each range constraint. */ 9369: if( pTail==0 ){ 9370: for(pCon=pScan->pRange; rc==SQLITE_OK && pCon; pCon=pCon->pNext){ 9371: assert( pCon->pLink==0 ); 9372: if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){ 9373: rc = idxCreateFromCons(p, pScan, p1, pCon); 9374: } 9375: } 9376: } 9377: 9378: return rc; 9379: } 9380: 9381: /* 9382: ** Create candidate indexes in database [dbm] based on the data in 9383: ** linked-list pScan. 9384: */ 9385: static int idxCreateCandidates(sqlite3expert *p){ 9386: int rc = SQLITE_OK; 9387: IdxScan *pIter; 9388: 9389: for(pIter=p->pScan; pIter && rc==SQLITE_OK; pIter=pIter->pNextScan){ 9390: rc = idxCreateFromWhere(p, pIter, 0); 9391: if( rc==SQLITE_OK && pIter->pOrder ){ 9392: rc = idxCreateFromWhere(p, pIter, pIter->pOrder); 9393: } 9394: } 9395: 9396: return rc; 9397: } 9398: 9399: /* 9400: ** Free all elements of the linked list starting at pConstraint. 9401: */ 9402: static void idxConstraintFree(IdxConstraint *pConstraint){ 9403: IdxConstraint *pNext; 9404: IdxConstraint *p; 9405: 9406: for(p=pConstraint; p; p=pNext){ 9407: pNext = p->pNext; 9408: sqlite3_free(p); 9409: } 9410: } 9411: 9412: /* 9413: ** Free all elements of the linked list starting from pScan up until pLast 9414: ** (pLast is not freed). 9415: */ 9416: static void idxScanFree(IdxScan *pScan, IdxScan *pLast){ 9417: IdxScan *p; 9418: IdxScan *pNext; 9419: for(p=pScan; p!=pLast; p=pNext){ 9420: pNext = p->pNextScan; 9421: idxConstraintFree(p->pOrder); 9422: idxConstraintFree(p->pEq); 9423: idxConstraintFree(p->pRange); 9424: sqlite3_free(p); 9425: } 9426: } 9427: 9428: /* 9429: ** Free all elements of the linked list starting from pStatement up 9430: ** until pLast (pLast is not freed). 9431: */ 9432: static void idxStatementFree(IdxStatement *pStatement, IdxStatement *pLast){ 9433: IdxStatement *p; 9434: IdxStatement *pNext; 9435: for(p=pStatement; p!=pLast; p=pNext){ 9436: pNext = p->pNext; 9437: sqlite3_free(p->zEQP); 9438: sqlite3_free(p->zIdx); 9439: sqlite3_free(p); 9440: } 9441: } 9442: 9443: /* 9444: ** Free the linked list of IdxTable objects starting at pTab. 9445: */ 9446: static void idxTableFree(IdxTable *pTab){ 9447: IdxTable *pIter; 9448: IdxTable *pNext; 9449: for(pIter=pTab; pIter; pIter=pNext){ 9450: pNext = pIter->pNext; 9451: sqlite3_free(pIter); 9452: } 9453: } 9454: 9455: /* 9456: ** Free the linked list of IdxWrite objects starting at pTab. 9457: */ 9458: static void idxWriteFree(IdxWrite *pTab){ 9459: IdxWrite *pIter; 9460: IdxWrite *pNext; 9461: for(pIter=pTab; pIter; pIter=pNext){ 9462: pNext = pIter->pNext; 9463: sqlite3_free(pIter); 9464: } 9465: } 9466: 9467: 9468: 9469: /* 9470: ** This function is called after candidate indexes have been created. It 9471: ** runs all the queries to see which indexes they prefer, and populates 9472: ** IdxStatement.zIdx and IdxStatement.zEQP with the results. 9473: */ 9474: int idxFindIndexes( 9475: sqlite3expert *p, 9476: char **pzErr /* OUT: Error message (sqlite3_malloc) */ 9477: ){ 9478: IdxStatement *pStmt; 9479: sqlite3 *dbm = p->dbm; 9480: int rc = SQLITE_OK; 9481: 9482: IdxHash hIdx; 9483: idxHashInit(&hIdx); 9484: 9485: for(pStmt=p->pStatement; rc==SQLITE_OK && pStmt; pStmt=pStmt->pNext){ 9486: IdxHashEntry *pEntry; 9487: sqlite3_stmt *pExplain = 0; 9488: idxHashClear(&hIdx); 9489: rc = idxPrintfPrepareStmt(dbm, &pExplain, pzErr, 9490: "EXPLAIN QUERY PLAN %s", pStmt->zSql 9491: ); 9492: while( rc==SQLITE_OK && sqlite3_step(pExplain)==SQLITE_ROW ){ 9493: /* int iId = sqlite3_column_int(pExplain, 0); */ 9494: /* int iParent = sqlite3_column_int(pExplain, 1); */ 9495: /* int iNotUsed = sqlite3_column_int(pExplain, 2); */ 9496: const char *zDetail = (const char*)sqlite3_column_text(pExplain, 3); 9497: int nDetail; 9498: int i; 9499: 9500: if( !zDetail ) continue; 9501: nDetail = STRLEN(zDetail); 9502: 9503: for(i=0; i<nDetail; i++){ 9504: const char *zIdx = 0; 9505: if( i+13<nDetail && memcmp(&zDetail[i], " USING INDEX ", 13)==0 ){ 9506: zIdx = &zDetail[i+13]; 9507: }else if( i+22<nDetail 9508: && memcmp(&zDetail[i], " USING COVERING INDEX ", 22)==0 9509: ){ 9510: zIdx = &zDetail[i+22]; 9511: } 9512: if( zIdx ){ 9513: const char *zSql; 9514: int nIdx = 0; 9515: while( zIdx[nIdx]!='\0' && (zIdx[nIdx]!=' ' || zIdx[nIdx+1]!='(') ){ 9516: nIdx++; 9517: } 9518: zSql = idxHashSearch(&p->hIdx, zIdx, nIdx); 9519: if( zSql ){ 9520: idxHashAdd(&rc, &hIdx, zSql, 0); 9521: if( rc ) goto find_indexes_out; 9522: } 9523: break; 9524: } 9525: } 9526: 9527: if( zDetail[0]!='-' ){ 9528: pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail); 9529: } 9530: } 9531: 9532: for(pEntry=hIdx.pFirst; pEntry; pEntry=pEntry->pNext){ 9533: pStmt->zIdx = idxAppendText(&rc, pStmt->zIdx, "%s;\n", pEntry->zKey); 9534: } 9535: 9536: idxFinalize(&rc, pExplain); 9537: } 9538: 9539: find_indexes_out: 9540: idxHashClear(&hIdx); 9541: return rc; 9542: } 9543: 9544: static int idxAuthCallback( 9545: void *pCtx, 9546: int eOp, 9547: const char *z3, 9548: const char *z4, 9549: const char *zDb, 9550: const char *zTrigger 9551: ){ 9552: int rc = SQLITE_OK; 9553: (void)z4; 9554: (void)zTrigger; 9555: if( eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE || eOp==SQLITE_DELETE ){ 9556: if( sqlite3_stricmp(zDb, "main")==0 ){ 9557: sqlite3expert *p = (sqlite3expert*)pCtx; 9558: IdxTable *pTab; 9559: for(pTab=p->pTable; pTab; pTab=pTab->pNext){ 9560: if( 0==sqlite3_stricmp(z3, pTab->zName) ) break; 9561: } 9562: if( pTab ){ 9563: IdxWrite *pWrite; 9564: for(pWrite=p->pWrite; pWrite; pWrite=pWrite->pNext){ 9565: if( pWrite->pTab==pTab && pWrite->eOp==eOp ) break; 9566: } 9567: if( pWrite==0 ){ 9568: pWrite = idxMalloc(&rc, sizeof(IdxWrite)); 9569: if( rc==SQLITE_OK ){ 9570: pWrite->pTab = pTab; 9571: pWrite->eOp = eOp; 9572: pWrite->pNext = p->pWrite; 9573: p->pWrite = pWrite; 9574: } 9575: } 9576: } 9577: } 9578: } 9579: return rc; 9580: } 9581: 9582: static int idxProcessOneTrigger( 9583: sqlite3expert *p, 9584: IdxWrite *pWrite, 9585: char **pzErr 9586: ){ 9587: static const char *zInt = UNIQUE_TABLE_NAME; 9588: static const char *zDrop = "DROP TABLE " UNIQUE_TABLE_NAME; 9589: IdxTable *pTab = pWrite->pTab; 9590: const char *zTab = pTab->zName; 9591: const char *zSql = 9592: "SELECT 'CREATE TEMP' || substr(sql, 7) FROM sqlite_schema " 9593: "WHERE tbl_name = %Q AND type IN ('table', 'trigger') " 9594: "ORDER BY type;"; 9595: sqlite3_stmt *pSelect = 0; 9596: int rc = SQLITE_OK; 9597: char *zWrite = 0; 9598: 9599: /* Create the table and its triggers in the temp schema */ 9600: rc = idxPrintfPrepareStmt(p->db, &pSelect, pzErr, zSql, zTab, zTab); 9601: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSelect) ){ 9602: const char *zCreate = (const char*)sqlite3_column_text(pSelect, 0); 9603: rc = sqlite3_exec(p->dbv, zCreate, 0, 0, pzErr); 9604: } 9605: idxFinalize(&rc, pSelect); 9606: 9607: /* Rename the table in the temp schema to zInt */ 9608: if( rc==SQLITE_OK ){ 9609: char *z = sqlite3_mprintf("ALTER TABLE temp.%Q RENAME TO %Q", zTab, zInt); 9610: if( z==0 ){ 9611: rc = SQLITE_NOMEM; 9612: }else{ 9613: rc = sqlite3_exec(p->dbv, z, 0, 0, pzErr); 9614: sqlite3_free(z); 9615: } 9616: } 9617: 9618: switch( pWrite->eOp ){ 9619: case SQLITE_INSERT: { 9620: int i; 9621: zWrite = idxAppendText(&rc, zWrite, "INSERT INTO %Q VALUES(", zInt); 9622: for(i=0; i<pTab->nCol; i++){ 9623: zWrite = idxAppendText(&rc, zWrite, "%s?", i==0 ? "" : ", "); 9624: } 9625: zWrite = idxAppendText(&rc, zWrite, ")"); 9626: break; 9627: } 9628: case SQLITE_UPDATE: { 9629: int i; 9630: zWrite = idxAppendText(&rc, zWrite, "UPDATE %Q SET ", zInt); 9631: for(i=0; i<pTab->nCol; i++){ 9632: zWrite = idxAppendText(&rc, zWrite, "%s%Q=?", i==0 ? "" : ", ", 9633: pTab->aCol[i].zName 9634: ); 9635: } 9636: break; 9637: } 9638: default: { 9639: assert( pWrite->eOp==SQLITE_DELETE ); 9640: if( rc==SQLITE_OK ){ 9641: zWrite = sqlite3_mprintf("DELETE FROM %Q", zInt); 9642: if( zWrite==0 ) rc = SQLITE_NOMEM; 9643: } 9644: } 9645: } 9646: 9647: if( rc==SQLITE_OK ){ 9648: sqlite3_stmt *pX = 0; 9649: rc = sqlite3_prepare_v2(p->dbv, zWrite, -1, &pX, 0); 9650: idxFinalize(&rc, pX); 9651: if( rc!=SQLITE_OK ){ 9652: idxDatabaseError(p->dbv, pzErr); 9653: } 9654: } 9655: sqlite3_free(zWrite); 9656: 9657: if( rc==SQLITE_OK ){ 9658: rc = sqlite3_exec(p->dbv, zDrop, 0, 0, pzErr); 9659: } 9660: 9661: return rc; 9662: } 9663: 9664: static int idxProcessTriggers(sqlite3expert *p, char **pzErr){ 9665: int rc = SQLITE_OK; 9666: IdxWrite *pEnd = 0; 9667: IdxWrite *pFirst = p->pWrite; 9668: 9669: while( rc==SQLITE_OK && pFirst!=pEnd ){ 9670: IdxWrite *pIter; 9671: for(pIter=pFirst; rc==SQLITE_OK && pIter!=pEnd; pIter=pIter->pNext){ 9672: rc = idxProcessOneTrigger(p, pIter, pzErr); 9673: } 9674: pEnd = pFirst; 9675: pFirst = p->pWrite; 9676: } 9677: 9678: return rc; 9679: } 9680: 9681: 9682: static int idxCreateVtabSchema(sqlite3expert *p, char **pzErrmsg){ 9683: int rc = idxRegisterVtab(p); 9684: sqlite3_stmt *pSchema = 0; 9685: 9686: /* For each table in the main db schema: 9687: ** 9688: ** 1) Add an entry to the p->pTable list, and 9689: ** 2) Create the equivalent virtual table in dbv. 9690: */ 9691: rc = idxPrepareStmt(p->db, &pSchema, pzErrmsg, 9692: "SELECT type, name, sql, 1 FROM sqlite_schema " 9693: "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%%' " 9694: " UNION ALL " 9695: "SELECT type, name, sql, 2 FROM sqlite_schema " 9696: "WHERE type = 'trigger'" 9697: " AND tbl_name IN(SELECT name FROM sqlite_schema WHERE type = 'view') " 9698: "ORDER BY 4, 1" 9699: ); 9700: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSchema) ){ 9701: const char *zType = (const char*)sqlite3_column_text(pSchema, 0); 9702: const char *zName = (const char*)sqlite3_column_text(pSchema, 1); 9703: const char *zSql = (const char*)sqlite3_column_text(pSchema, 2); 9704: 9705: if( zType[0]=='v' || zType[1]=='r' ){ 9706: rc = sqlite3_exec(p->dbv, zSql, 0, 0, pzErrmsg); 9707: }else{ 9708: IdxTable *pTab; 9709: rc = idxGetTableInfo(p->db, zName, &pTab, pzErrmsg); 9710: if( rc==SQLITE_OK ){ 9711: int i; 9712: char *zInner = 0; 9713: char *zOuter = 0; 9714: pTab->pNext = p->pTable; 9715: p->pTable = pTab; 9716: 9717: /* The statement the vtab will pass to sqlite3_declare_vtab() */ 9718: zInner = idxAppendText(&rc, 0, "CREATE TABLE x("); 9719: for(i=0; i<pTab->nCol; i++){ 9720: zInner = idxAppendText(&rc, zInner, "%s%Q COLLATE %s", 9721: (i==0 ? "" : ", "), pTab->aCol[i].zName, pTab->aCol[i].zColl 9722: ); 9723: } 9724: zInner = idxAppendText(&rc, zInner, ")"); 9725: 9726: /* The CVT statement to create the vtab */ 9727: zOuter = idxAppendText(&rc, 0, 9728: "CREATE VIRTUAL TABLE %Q USING expert(%Q)", zName, zInner 9729: ); 9730: if( rc==SQLITE_OK ){ 9731: rc = sqlite3_exec(p->dbv, zOuter, 0, 0, pzErrmsg); 9732: } 9733: sqlite3_free(zInner); 9734: sqlite3_free(zOuter); 9735: } 9736: } 9737: } 9738: idxFinalize(&rc, pSchema); 9739: return rc; 9740: } 9741: 9742: struct IdxSampleCtx { 9743: int iTarget; 9744: double target; /* Target nRet/nRow value */ 9745: double nRow; /* Number of rows seen */ 9746: double nRet; /* Number of rows returned */ 9747: }; 9748: 9749: static void idxSampleFunc( 9750: sqlite3_context *pCtx, 9751: int argc, 9752: sqlite3_value **argv 9753: ){ 9754: struct IdxSampleCtx *p = (struct IdxSampleCtx*)sqlite3_user_data(pCtx); 9755: int bRet; 9756: 9757: (void)argv; 9758: assert( argc==0 ); 9759: if( p->nRow==0.0 ){ 9760: bRet = 1; 9761: }else{ 9762: bRet = (p->nRet / p->nRow) <= p->target; 9763: if( bRet==0 ){ 9764: unsigned short rnd; 9765: sqlite3_randomness(2, (void*)&rnd); 9766: bRet = ((int)rnd % 100) <= p->iTarget; 9767: } 9768: } 9769: 9770: sqlite3_result_int(pCtx, bRet); 9771: p->nRow += 1.0; 9772: p->nRet += (double)bRet; 9773: } 9774: 9775: struct IdxRemCtx { 9776: int nSlot; 9777: struct IdxRemSlot { 9778: int eType; /* SQLITE_NULL, INTEGER, REAL, TEXT, BLOB */ 9779: i64 iVal; /* SQLITE_INTEGER value */ 9780: double rVal; /* SQLITE_FLOAT value */ 9781: int nByte; /* Bytes of space allocated at z */ 9782: int n; /* Size of buffer z */ 9783: char *z; /* SQLITE_TEXT/BLOB value */ 9784: } aSlot[1]; 9785: }; 9786: 9787: /* 9788: ** Implementation of scalar function rem(). 9789: */ 9790: static void idxRemFunc( 9791: sqlite3_context *pCtx, 9792: int argc, 9793: sqlite3_value **argv 9794: ){ 9795: struct IdxRemCtx *p = (struct IdxRemCtx*)sqlite3_user_data(pCtx); 9796: struct IdxRemSlot *pSlot; 9797: int iSlot; 9798: assert( argc==2 ); 9799: 9800: iSlot = sqlite3_value_int(argv[0]); 9801: assert( iSlot<=p->nSlot ); 9802: pSlot = &p->aSlot[iSlot]; 9803: 9804: switch( pSlot->eType ){ 9805: case SQLITE_NULL: 9806: /* no-op */ 9807: break; 9808: 9809: case SQLITE_INTEGER: 9810: sqlite3_result_int64(pCtx, pSlot->iVal); 9811: break; 9812: 9813: case SQLITE_FLOAT: 9814: sqlite3_result_double(pCtx, pSlot->rVal); 9815: break; 9816: 9817: case SQLITE_BLOB: 9818: sqlite3_result_blob(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT); 9819: break; 9820: 9821: case SQLITE_TEXT: 9822: sqlite3_result_text(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT); 9823: break; 9824: } 9825: 9826: pSlot->eType = sqlite3_value_type(argv[1]); 9827: switch( pSlot->eType ){ 9828: case SQLITE_NULL: 9829: /* no-op */ 9830: break; 9831: 9832: case SQLITE_INTEGER: 9833: pSlot->iVal = sqlite3_value_int64(argv[1]); 9834: break; 9835: 9836: case SQLITE_FLOAT: 9837: pSlot->rVal = sqlite3_value_double(argv[1]); 9838: break; 9839: 9840: case SQLITE_BLOB: 9841: case SQLITE_TEXT: { 9842: int nByte = sqlite3_value_bytes(argv[1]); 9843: if( nByte>pSlot->nByte ){ 9844: char *zNew = (char*)sqlite3_realloc(pSlot->z, nByte*2); 9845: if( zNew==0 ){ 9846: sqlite3_result_error_nomem(pCtx); 9847: return; 9848: } 9849: pSlot->nByte = nByte*2; 9850: pSlot->z = zNew; 9851: } 9852: pSlot->n = nByte; 9853: if( pSlot->eType==SQLITE_BLOB ){ 9854: memcpy(pSlot->z, sqlite3_value_blob(argv[1]), nByte); 9855: }else{ 9856: memcpy(pSlot->z, sqlite3_value_text(argv[1]), nByte); 9857: } 9858: break; 9859: } 9860: } 9861: } 9862: 9863: static int idxLargestIndex(sqlite3 *db, int *pnMax, char **pzErr){ 9864: int rc = SQLITE_OK; 9865: const char *zMax = 9866: "SELECT max(i.seqno) FROM " 9867: " sqlite_schema AS s, " 9868: " pragma_index_list(s.name) AS l, " 9869: " pragma_index_info(l.name) AS i " 9870: "WHERE s.type = 'table'"; 9871: sqlite3_stmt *pMax = 0; 9872: 9873: *pnMax = 0; 9874: rc = idxPrepareStmt(db, &pMax, pzErr, zMax); 9875: if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ 9876: *pnMax = sqlite3_column_int(pMax, 0) + 1; 9877: } 9878: idxFinalize(&rc, pMax); 9879: 9880: return rc; 9881: } 9882: 9883: static int idxPopulateOneStat1( 9884: sqlite3expert *p, 9885: sqlite3_stmt *pIndexXInfo, 9886: sqlite3_stmt *pWriteStat, 9887: const char *zTab, 9888: const char *zIdx, 9889: char **pzErr 9890: ){ 9891: char *zCols = 0; 9892: char *zOrder = 0; 9893: char *zQuery = 0; 9894: int nCol = 0; 9895: int i; 9896: sqlite3_stmt *pQuery = 0; 9897: int *aStat = 0; 9898: int rc = SQLITE_OK; 9899: 9900: assert( p->iSample>0 ); 9901: 9902: /* Formulate the query text */ 9903: sqlite3_bind_text(pIndexXInfo, 1, zIdx, -1, SQLITE_STATIC); 9904: while( SQLITE_OK==rc && SQLITE_ROW==sqlite3_step(pIndexXInfo) ){ 9905: const char *zComma = zCols==0 ? "" : ", "; 9906: const char *zName = (const char*)sqlite3_column_text(pIndexXInfo, 0); 9907: const char *zColl = (const char*)sqlite3_column_text(pIndexXInfo, 1); 9908: zCols = idxAppendText(&rc, zCols, 9909: "%sx.%Q IS rem(%d, x.%Q) COLLATE %s", zComma, zName, nCol, zName, zColl 9910: ); 9911: zOrder = idxAppendText(&rc, zOrder, "%s%d", zComma, ++nCol); 9912: } 9913: sqlite3_reset(pIndexXInfo); 9914: if( rc==SQLITE_OK ){ 9915: if( p->iSample==100 ){ 9916: zQuery = sqlite3_mprintf( 9917: "SELECT %s FROM %Q x ORDER BY %s", zCols, zTab, zOrder 9918: ); 9919: }else{ 9920: zQuery = sqlite3_mprintf( 9921: "SELECT %s FROM temp."UNIQUE_TABLE_NAME" x ORDER BY %s", zCols, zOrder 9922: ); 9923: } 9924: } 9925: sqlite3_free(zCols); 9926: sqlite3_free(zOrder); 9927: 9928: /* Formulate the query text */ 9929: if( rc==SQLITE_OK ){ 9930: sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv); 9931: rc = idxPrepareStmt(dbrem, &pQuery, pzErr, zQuery); 9932: } 9933: sqlite3_free(zQuery); 9934: 9935: if( rc==SQLITE_OK ){ 9936: aStat = (int*)idxMalloc(&rc, sizeof(int)*(nCol+1)); 9937: } 9938: if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){ 9939: IdxHashEntry *pEntry; 9940: char *zStat = 0; 9941: for(i=0; i<=nCol; i++) aStat[i] = 1; 9942: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){ 9943: aStat[0]++; 9944: for(i=0; i<nCol; i++){ 9945: if( sqlite3_column_int(pQuery, i)==0 ) break; 9946: } 9947: for(/*no-op*/; i<nCol; i++){ 9948: aStat[i+1]++; 9949: } 9950: } 9951: 9952: if( rc==SQLITE_OK ){ 9953: int s0 = aStat[0]; 9954: zStat = sqlite3_mprintf("%d", s0); 9955: if( zStat==0 ) rc = SQLITE_NOMEM; 9956: for(i=1; rc==SQLITE_OK && i<=nCol; i++){ 9957: zStat = idxAppendText(&rc, zStat, " %d", (s0+aStat[i]/2) / aStat[i]); 9958: } 9959: } 9960: 9961: if( rc==SQLITE_OK ){ 9962: sqlite3_bind_text(pWriteStat, 1, zTab, -1, SQLITE_STATIC); 9963: sqlite3_bind_text(pWriteStat, 2, zIdx, -1, SQLITE_STATIC); 9964: sqlite3_bind_text(pWriteStat, 3, zStat, -1, SQLITE_STATIC); 9965: sqlite3_step(pWriteStat); 9966: rc = sqlite3_reset(pWriteStat); 9967: } 9968: 9969: pEntry = idxHashFind(&p->hIdx, zIdx, STRLEN(zIdx)); 9970: if( pEntry ){ 9971: assert( pEntry->zVal2==0 ); 9972: pEntry->zVal2 = zStat; 9973: }else{ 9974: sqlite3_free(zStat); 9975: } 9976: } 9977: sqlite3_free(aStat); 9978: idxFinalize(&rc, pQuery); 9979: 9980: return rc; 9981: } 9982: 9983: static int idxBuildSampleTable(sqlite3expert *p, const char *zTab){ 9984: int rc; 9985: char *zSql; 9986: 9987: rc = sqlite3_exec(p->dbv,"DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0); 9988: if( rc!=SQLITE_OK ) return rc; 9989: 9990: zSql = sqlite3_mprintf( 9991: "CREATE TABLE temp." UNIQUE_TABLE_NAME " AS SELECT * FROM %Q", zTab 9992: ); 9993: if( zSql==0 ) return SQLITE_NOMEM; 9994: rc = sqlite3_exec(p->dbv, zSql, 0, 0, 0); 9995: sqlite3_free(zSql); 9996: 9997: return rc; 9998: } 9999: 10000: /* 10001: ** This function is called as part of sqlite3_expert_analyze(). Candidate 10002: ** indexes have already been created in database sqlite3expert.dbm, this 10003: ** function populates sqlite_stat1 table in the same database. 10004: ** 10005: ** The stat1 data is generated by querying the 10006: */ 10007: static int idxPopulateStat1(sqlite3expert *p, char **pzErr){ 10008: int rc = SQLITE_OK; 10009: int nMax =0; 10010: struct IdxRemCtx *pCtx = 0; 10011: struct IdxSampleCtx samplectx; 10012: int i; 10013: i64 iPrev = -100000; 10014: sqlite3_stmt *pAllIndex = 0; 10015: sqlite3_stmt *pIndexXInfo = 0; 10016: sqlite3_stmt *pWrite = 0; 10017: 10018: const char *zAllIndex = 10019: "SELECT s.rowid, s.name, l.name FROM " 10020: " sqlite_schema AS s, " 10021: " pragma_index_list(s.name) AS l " 10022: "WHERE s.type = 'table'"; 10023: const char *zIndexXInfo = 10024: "SELECT name, coll FROM pragma_index_xinfo(?) WHERE key"; 10025: const char *zWrite = "INSERT INTO sqlite_stat1 VALUES(?, ?, ?)"; 10026: 10027: /* If iSample==0, no sqlite_stat1 data is required. */ 10028: if( p->iSample==0 ) return SQLITE_OK; 10029: 10030: rc = idxLargestIndex(p->dbm, &nMax, pzErr); 10031: if( nMax<=0 || rc!=SQLITE_OK ) return rc; 10032: 10033: rc = sqlite3_exec(p->dbm, "ANALYZE; PRAGMA writable_schema=1", 0, 0, 0); 10034: 10035: if( rc==SQLITE_OK ){ 10036: int nByte = sizeof(struct IdxRemCtx) + (sizeof(struct IdxRemSlot) * nMax); 10037: pCtx = (struct IdxRemCtx*)idxMalloc(&rc, nByte); 10038: } 10039: 10040: if( rc==SQLITE_OK ){ 10041: sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv); 10042: rc = sqlite3_create_function( 10043: dbrem, "rem", 2, SQLITE_UTF8, (void*)pCtx, idxRemFunc, 0, 0 10044: ); 10045: } 10046: if( rc==SQLITE_OK ){ 10047: rc = sqlite3_create_function( 10048: p->db, "sample", 0, SQLITE_UTF8, (void*)&samplectx, idxSampleFunc, 0, 0 10049: ); 10050: } 10051: 10052: if( rc==SQLITE_OK ){ 10053: pCtx->nSlot = nMax+1; 10054: rc = idxPrepareStmt(p->dbm, &pAllIndex, pzErr, zAllIndex); 10055: } 10056: if( rc==SQLITE_OK ){ 10057: rc = idxPrepareStmt(p->dbm, &pIndexXInfo, pzErr, zIndexXInfo); 10058: } 10059: if( rc==SQLITE_OK ){ 10060: rc = idxPrepareStmt(p->dbm, &pWrite, pzErr, zWrite); 10061: } 10062: 10063: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pAllIndex) ){ 10064: i64 iRowid = sqlite3_column_int64(pAllIndex, 0); 10065: const char *zTab = (const char*)sqlite3_column_text(pAllIndex, 1); 10066: const char *zIdx = (const char*)sqlite3_column_text(pAllIndex, 2); 10067: if( p->iSample<100 && iPrev!=iRowid ){ 10068: samplectx.target = (double)p->iSample / 100.0; 10069: samplectx.iTarget = p->iSample; 10070: samplectx.nRow = 0.0; 10071: samplectx.nRet = 0.0; 10072: rc = idxBuildSampleTable(p, zTab); 10073: if( rc!=SQLITE_OK ) break; 10074: } 10075: rc = idxPopulateOneStat1(p, pIndexXInfo, pWrite, zTab, zIdx, pzErr); 10076: iPrev = iRowid; 10077: } 10078: if( rc==SQLITE_OK && p->iSample<100 ){ 10079: rc = sqlite3_exec(p->dbv, 10080: "DROP TABLE IF EXISTS temp." UNIQUE_TABLE_NAME, 0,0,0 10081: ); 10082: } 10083: 10084: idxFinalize(&rc, pAllIndex); 10085: idxFinalize(&rc, pIndexXInfo); 10086: idxFinalize(&rc, pWrite); 10087: 1.6 ! misho 10088: if( pCtx ){ ! 10089: for(i=0; i<pCtx->nSlot; i++){ ! 10090: sqlite3_free(pCtx->aSlot[i].z); ! 10091: } ! 10092: sqlite3_free(pCtx); 1.5 misho 10093: } 10094: 10095: if( rc==SQLITE_OK ){ 10096: rc = sqlite3_exec(p->dbm, "ANALYZE sqlite_schema", 0, 0, 0); 10097: } 10098: 10099: sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0); 10100: return rc; 10101: } 10102: 10103: /* 10104: ** Allocate a new sqlite3expert object. 10105: */ 10106: sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErrmsg){ 10107: int rc = SQLITE_OK; 10108: sqlite3expert *pNew; 10109: 10110: pNew = (sqlite3expert*)idxMalloc(&rc, sizeof(sqlite3expert)); 10111: 10112: /* Open two in-memory databases to work with. The "vtab database" (dbv) 10113: ** will contain a virtual table corresponding to each real table in 10114: ** the user database schema, and a copy of each view. It is used to 10115: ** collect information regarding the WHERE, ORDER BY and other clauses 10116: ** of the user's query. 10117: */ 10118: if( rc==SQLITE_OK ){ 10119: pNew->db = db; 10120: pNew->iSample = 100; 10121: rc = sqlite3_open(":memory:", &pNew->dbv); 10122: } 10123: if( rc==SQLITE_OK ){ 10124: rc = sqlite3_open(":memory:", &pNew->dbm); 10125: if( rc==SQLITE_OK ){ 10126: sqlite3_db_config(pNew->dbm, SQLITE_DBCONFIG_TRIGGER_EQP, 1, (int*)0); 10127: } 10128: } 10129: 10130: 10131: /* Copy the entire schema of database [db] into [dbm]. */ 10132: if( rc==SQLITE_OK ){ 10133: sqlite3_stmt *pSql; 10134: rc = idxPrintfPrepareStmt(pNew->db, &pSql, pzErrmsg, 10135: "SELECT sql FROM sqlite_schema WHERE name NOT LIKE 'sqlite_%%'" 10136: " AND sql NOT LIKE 'CREATE VIRTUAL %%'" 10137: ); 10138: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 10139: const char *zSql = (const char*)sqlite3_column_text(pSql, 0); 10140: rc = sqlite3_exec(pNew->dbm, zSql, 0, 0, pzErrmsg); 10141: } 10142: idxFinalize(&rc, pSql); 10143: } 10144: 10145: /* Create the vtab schema */ 10146: if( rc==SQLITE_OK ){ 10147: rc = idxCreateVtabSchema(pNew, pzErrmsg); 10148: } 10149: 10150: /* Register the auth callback with dbv */ 10151: if( rc==SQLITE_OK ){ 10152: sqlite3_set_authorizer(pNew->dbv, idxAuthCallback, (void*)pNew); 10153: } 10154: 10155: /* If an error has occurred, free the new object and reutrn NULL. Otherwise, 10156: ** return the new sqlite3expert handle. */ 10157: if( rc!=SQLITE_OK ){ 10158: sqlite3_expert_destroy(pNew); 10159: pNew = 0; 10160: } 10161: return pNew; 10162: } 10163: 10164: /* 10165: ** Configure an sqlite3expert object. 10166: */ 10167: int sqlite3_expert_config(sqlite3expert *p, int op, ...){ 10168: int rc = SQLITE_OK; 10169: va_list ap; 10170: va_start(ap, op); 10171: switch( op ){ 10172: case EXPERT_CONFIG_SAMPLE: { 10173: int iVal = va_arg(ap, int); 10174: if( iVal<0 ) iVal = 0; 10175: if( iVal>100 ) iVal = 100; 10176: p->iSample = iVal; 10177: break; 10178: } 10179: default: 10180: rc = SQLITE_NOTFOUND; 10181: break; 10182: } 10183: 10184: va_end(ap); 10185: return rc; 10186: } 10187: 10188: /* 10189: ** Add an SQL statement to the analysis. 10190: */ 10191: int sqlite3_expert_sql( 10192: sqlite3expert *p, /* From sqlite3_expert_new() */ 10193: const char *zSql, /* SQL statement to add */ 10194: char **pzErr /* OUT: Error message (if any) */ 10195: ){ 10196: IdxScan *pScanOrig = p->pScan; 10197: IdxStatement *pStmtOrig = p->pStatement; 10198: int rc = SQLITE_OK; 10199: const char *zStmt = zSql; 10200: 10201: if( p->bRun ) return SQLITE_MISUSE; 10202: 10203: while( rc==SQLITE_OK && zStmt && zStmt[0] ){ 10204: sqlite3_stmt *pStmt = 0; 10205: rc = sqlite3_prepare_v2(p->dbv, zStmt, -1, &pStmt, &zStmt); 10206: if( rc==SQLITE_OK ){ 10207: if( pStmt ){ 10208: IdxStatement *pNew; 10209: const char *z = sqlite3_sql(pStmt); 10210: int n = STRLEN(z); 10211: pNew = (IdxStatement*)idxMalloc(&rc, sizeof(IdxStatement) + n+1); 10212: if( rc==SQLITE_OK ){ 10213: pNew->zSql = (char*)&pNew[1]; 10214: memcpy(pNew->zSql, z, n+1); 10215: pNew->pNext = p->pStatement; 10216: if( p->pStatement ) pNew->iId = p->pStatement->iId+1; 10217: p->pStatement = pNew; 10218: } 10219: sqlite3_finalize(pStmt); 10220: } 10221: }else{ 10222: idxDatabaseError(p->dbv, pzErr); 10223: } 10224: } 10225: 10226: if( rc!=SQLITE_OK ){ 10227: idxScanFree(p->pScan, pScanOrig); 10228: idxStatementFree(p->pStatement, pStmtOrig); 10229: p->pScan = pScanOrig; 10230: p->pStatement = pStmtOrig; 10231: } 10232: 10233: return rc; 10234: } 10235: 10236: int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr){ 10237: int rc; 10238: IdxHashEntry *pEntry; 10239: 10240: /* Do trigger processing to collect any extra IdxScan structures */ 10241: rc = idxProcessTriggers(p, pzErr); 10242: 10243: /* Create candidate indexes within the in-memory database file */ 10244: if( rc==SQLITE_OK ){ 10245: rc = idxCreateCandidates(p); 10246: } 10247: 10248: /* Generate the stat1 data */ 10249: if( rc==SQLITE_OK ){ 10250: rc = idxPopulateStat1(p, pzErr); 10251: } 10252: 10253: /* Formulate the EXPERT_REPORT_CANDIDATES text */ 10254: for(pEntry=p->hIdx.pFirst; pEntry; pEntry=pEntry->pNext){ 10255: p->zCandidates = idxAppendText(&rc, p->zCandidates, 10256: "%s;%s%s\n", pEntry->zVal, 10257: pEntry->zVal2 ? " -- stat1: " : "", pEntry->zVal2 10258: ); 10259: } 10260: 10261: /* Figure out which of the candidate indexes are preferred by the query 10262: ** planner and report the results to the user. */ 10263: if( rc==SQLITE_OK ){ 10264: rc = idxFindIndexes(p, pzErr); 10265: } 10266: 10267: if( rc==SQLITE_OK ){ 10268: p->bRun = 1; 10269: } 10270: return rc; 10271: } 10272: 10273: /* 10274: ** Return the total number of statements that have been added to this 10275: ** sqlite3expert using sqlite3_expert_sql(). 10276: */ 10277: int sqlite3_expert_count(sqlite3expert *p){ 10278: int nRet = 0; 10279: if( p->pStatement ) nRet = p->pStatement->iId+1; 10280: return nRet; 10281: } 10282: 10283: /* 10284: ** Return a component of the report. 10285: */ 10286: const char *sqlite3_expert_report(sqlite3expert *p, int iStmt, int eReport){ 10287: const char *zRet = 0; 10288: IdxStatement *pStmt; 10289: 10290: if( p->bRun==0 ) return 0; 10291: for(pStmt=p->pStatement; pStmt && pStmt->iId!=iStmt; pStmt=pStmt->pNext); 10292: switch( eReport ){ 10293: case EXPERT_REPORT_SQL: 10294: if( pStmt ) zRet = pStmt->zSql; 10295: break; 10296: case EXPERT_REPORT_INDEXES: 10297: if( pStmt ) zRet = pStmt->zIdx; 10298: break; 10299: case EXPERT_REPORT_PLAN: 10300: if( pStmt ) zRet = pStmt->zEQP; 10301: break; 10302: case EXPERT_REPORT_CANDIDATES: 10303: zRet = p->zCandidates; 10304: break; 10305: } 10306: return zRet; 10307: } 10308: 10309: /* 10310: ** Free an sqlite3expert object. 10311: */ 10312: void sqlite3_expert_destroy(sqlite3expert *p){ 10313: if( p ){ 10314: sqlite3_close(p->dbm); 10315: sqlite3_close(p->dbv); 10316: idxScanFree(p->pScan, 0); 10317: idxStatementFree(p->pStatement, 0); 10318: idxTableFree(p->pTable); 10319: idxWriteFree(p->pWrite); 10320: idxHashClear(&p->hIdx); 10321: sqlite3_free(p->zCandidates); 10322: sqlite3_free(p); 10323: } 10324: } 10325: 10326: #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ 10327: 10328: /************************* End ../ext/expert/sqlite3expert.c ********************/ 10329: 10330: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 10331: /************************* Begin ../ext/misc/dbdata.c ******************/ 10332: /* 10333: ** 2019-04-17 10334: ** 10335: ** The author disclaims copyright to this source code. In place of 10336: ** a legal notice, here is a blessing: 10337: ** 10338: ** May you do good and not evil. 10339: ** May you find forgiveness for yourself and forgive others. 10340: ** May you share freely, never taking more than you give. 10341: ** 10342: ****************************************************************************** 10343: ** 10344: ** This file contains an implementation of two eponymous virtual tables, 10345: ** "sqlite_dbdata" and "sqlite_dbptr". Both modules require that the 10346: ** "sqlite_dbpage" eponymous virtual table be available. 10347: ** 10348: ** SQLITE_DBDATA: 10349: ** sqlite_dbdata is used to extract data directly from a database b-tree 10350: ** page and its associated overflow pages, bypassing the b-tree layer. 10351: ** The table schema is equivalent to: 10352: ** 10353: ** CREATE TABLE sqlite_dbdata( 10354: ** pgno INTEGER, 10355: ** cell INTEGER, 10356: ** field INTEGER, 10357: ** value ANY, 10358: ** schema TEXT HIDDEN 10359: ** ); 10360: ** 10361: ** IMPORTANT: THE VIRTUAL TABLE SCHEMA ABOVE IS SUBJECT TO CHANGE. IN THE 10362: ** FUTURE NEW NON-HIDDEN COLUMNS MAY BE ADDED BETWEEN "value" AND 10363: ** "schema". 10364: ** 10365: ** Each page of the database is inspected. If it cannot be interpreted as 10366: ** a b-tree page, or if it is a b-tree page containing 0 entries, the 10367: ** sqlite_dbdata table contains no rows for that page. Otherwise, the 10368: ** table contains one row for each field in the record associated with 10369: ** each cell on the page. For intkey b-trees, the key value is stored in 10370: ** field -1. 10371: ** 10372: ** For example, for the database: 10373: ** 10374: ** CREATE TABLE t1(a, b); -- root page is page 2 10375: ** INSERT INTO t1(rowid, a, b) VALUES(5, 'v', 'five'); 10376: ** INSERT INTO t1(rowid, a, b) VALUES(10, 'x', 'ten'); 10377: ** 10378: ** the sqlite_dbdata table contains, as well as from entries related to 10379: ** page 1, content equivalent to: 10380: ** 10381: ** INSERT INTO sqlite_dbdata(pgno, cell, field, value) VALUES 10382: ** (2, 0, -1, 5 ), 10383: ** (2, 0, 0, 'v' ), 10384: ** (2, 0, 1, 'five'), 10385: ** (2, 1, -1, 10 ), 10386: ** (2, 1, 0, 'x' ), 10387: ** (2, 1, 1, 'ten' ); 10388: ** 10389: ** If database corruption is encountered, this module does not report an 10390: ** error. Instead, it attempts to extract as much data as possible and 10391: ** ignores the corruption. 10392: ** 10393: ** SQLITE_DBPTR: 10394: ** The sqlite_dbptr table has the following schema: 10395: ** 10396: ** CREATE TABLE sqlite_dbptr( 10397: ** pgno INTEGER, 10398: ** child INTEGER, 10399: ** schema TEXT HIDDEN 10400: ** ); 10401: ** 10402: ** It contains one entry for each b-tree pointer between a parent and 10403: ** child page in the database. 10404: */ 10405: #if !defined(SQLITEINT_H) 10406: /* #include "sqlite3ext.h" */ 10407: 10408: /* typedef unsigned char u8; */ 10409: 10410: #endif 10411: SQLITE_EXTENSION_INIT1 10412: #include <string.h> 10413: #include <assert.h> 10414: 10415: #define DBDATA_PADDING_BYTES 100 10416: 10417: typedef struct DbdataTable DbdataTable; 10418: typedef struct DbdataCursor DbdataCursor; 10419: 10420: /* Cursor object */ 10421: struct DbdataCursor { 10422: sqlite3_vtab_cursor base; /* Base class. Must be first */ 10423: sqlite3_stmt *pStmt; /* For fetching database pages */ 10424: 10425: int iPgno; /* Current page number */ 10426: u8 *aPage; /* Buffer containing page */ 10427: int nPage; /* Size of aPage[] in bytes */ 10428: int nCell; /* Number of cells on aPage[] */ 10429: int iCell; /* Current cell number */ 10430: int bOnePage; /* True to stop after one page */ 10431: int szDb; 10432: sqlite3_int64 iRowid; 10433: 10434: /* Only for the sqlite_dbdata table */ 10435: u8 *pRec; /* Buffer containing current record */ 10436: int nRec; /* Size of pRec[] in bytes */ 10437: int nHdr; /* Size of header in bytes */ 10438: int iField; /* Current field number */ 10439: u8 *pHdrPtr; 10440: u8 *pPtr; 10441: 10442: sqlite3_int64 iIntkey; /* Integer key value */ 10443: }; 10444: 10445: /* Table object */ 10446: struct DbdataTable { 10447: sqlite3_vtab base; /* Base class. Must be first */ 10448: sqlite3 *db; /* The database connection */ 10449: sqlite3_stmt *pStmt; /* For fetching database pages */ 10450: int bPtr; /* True for sqlite3_dbptr table */ 10451: }; 10452: 10453: /* Column and schema definitions for sqlite_dbdata */ 10454: #define DBDATA_COLUMN_PGNO 0 10455: #define DBDATA_COLUMN_CELL 1 10456: #define DBDATA_COLUMN_FIELD 2 10457: #define DBDATA_COLUMN_VALUE 3 10458: #define DBDATA_COLUMN_SCHEMA 4 10459: #define DBDATA_SCHEMA \ 10460: "CREATE TABLE x(" \ 10461: " pgno INTEGER," \ 10462: " cell INTEGER," \ 10463: " field INTEGER," \ 10464: " value ANY," \ 10465: " schema TEXT HIDDEN" \ 10466: ")" 10467: 10468: /* Column and schema definitions for sqlite_dbptr */ 10469: #define DBPTR_COLUMN_PGNO 0 10470: #define DBPTR_COLUMN_CHILD 1 10471: #define DBPTR_COLUMN_SCHEMA 2 10472: #define DBPTR_SCHEMA \ 10473: "CREATE TABLE x(" \ 10474: " pgno INTEGER," \ 10475: " child INTEGER," \ 10476: " schema TEXT HIDDEN" \ 10477: ")" 10478: 10479: /* 10480: ** Connect to an sqlite_dbdata (pAux==0) or sqlite_dbptr (pAux!=0) virtual 10481: ** table. 10482: */ 10483: static int dbdataConnect( 10484: sqlite3 *db, 10485: void *pAux, 10486: int argc, const char *const*argv, 10487: sqlite3_vtab **ppVtab, 10488: char **pzErr 10489: ){ 10490: DbdataTable *pTab = 0; 10491: int rc = sqlite3_declare_vtab(db, pAux ? DBPTR_SCHEMA : DBDATA_SCHEMA); 10492: 10493: if( rc==SQLITE_OK ){ 10494: pTab = (DbdataTable*)sqlite3_malloc64(sizeof(DbdataTable)); 10495: if( pTab==0 ){ 10496: rc = SQLITE_NOMEM; 10497: }else{ 10498: memset(pTab, 0, sizeof(DbdataTable)); 10499: pTab->db = db; 10500: pTab->bPtr = (pAux!=0); 10501: } 10502: } 10503: 10504: *ppVtab = (sqlite3_vtab*)pTab; 10505: return rc; 10506: } 10507: 10508: /* 10509: ** Disconnect from or destroy a sqlite_dbdata or sqlite_dbptr virtual table. 10510: */ 10511: static int dbdataDisconnect(sqlite3_vtab *pVtab){ 10512: DbdataTable *pTab = (DbdataTable*)pVtab; 10513: if( pTab ){ 10514: sqlite3_finalize(pTab->pStmt); 10515: sqlite3_free(pVtab); 10516: } 10517: return SQLITE_OK; 10518: } 10519: 10520: /* 10521: ** This function interprets two types of constraints: 10522: ** 10523: ** schema=? 10524: ** pgno=? 10525: ** 10526: ** If neither are present, idxNum is set to 0. If schema=? is present, 10527: ** the 0x01 bit in idxNum is set. If pgno=? is present, the 0x02 bit 10528: ** in idxNum is set. 10529: ** 10530: ** If both parameters are present, schema is in position 0 and pgno in 10531: ** position 1. 10532: */ 10533: static int dbdataBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdx){ 10534: DbdataTable *pTab = (DbdataTable*)tab; 10535: int i; 10536: int iSchema = -1; 10537: int iPgno = -1; 10538: int colSchema = (pTab->bPtr ? DBPTR_COLUMN_SCHEMA : DBDATA_COLUMN_SCHEMA); 10539: 10540: for(i=0; i<pIdx->nConstraint; i++){ 10541: struct sqlite3_index_constraint *p = &pIdx->aConstraint[i]; 10542: if( p->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 10543: if( p->iColumn==colSchema ){ 10544: if( p->usable==0 ) return SQLITE_CONSTRAINT; 10545: iSchema = i; 10546: } 10547: if( p->iColumn==DBDATA_COLUMN_PGNO && p->usable ){ 10548: iPgno = i; 10549: } 10550: } 10551: } 10552: 10553: if( iSchema>=0 ){ 10554: pIdx->aConstraintUsage[iSchema].argvIndex = 1; 10555: pIdx->aConstraintUsage[iSchema].omit = 1; 10556: } 10557: if( iPgno>=0 ){ 10558: pIdx->aConstraintUsage[iPgno].argvIndex = 1 + (iSchema>=0); 10559: pIdx->aConstraintUsage[iPgno].omit = 1; 10560: pIdx->estimatedCost = 100; 10561: pIdx->estimatedRows = 50; 10562: 10563: if( pTab->bPtr==0 && pIdx->nOrderBy && pIdx->aOrderBy[0].desc==0 ){ 10564: int iCol = pIdx->aOrderBy[0].iColumn; 10565: if( pIdx->nOrderBy==1 ){ 10566: pIdx->orderByConsumed = (iCol==0 || iCol==1); 10567: }else if( pIdx->nOrderBy==2 && pIdx->aOrderBy[1].desc==0 && iCol==0 ){ 10568: pIdx->orderByConsumed = (pIdx->aOrderBy[1].iColumn==1); 10569: } 10570: } 10571: 10572: }else{ 10573: pIdx->estimatedCost = 100000000; 10574: pIdx->estimatedRows = 1000000000; 10575: } 10576: pIdx->idxNum = (iSchema>=0 ? 0x01 : 0x00) | (iPgno>=0 ? 0x02 : 0x00); 10577: return SQLITE_OK; 10578: } 10579: 10580: /* 10581: ** Open a new sqlite_dbdata or sqlite_dbptr cursor. 10582: */ 10583: static int dbdataOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ 10584: DbdataCursor *pCsr; 10585: 10586: pCsr = (DbdataCursor*)sqlite3_malloc64(sizeof(DbdataCursor)); 10587: if( pCsr==0 ){ 10588: return SQLITE_NOMEM; 10589: }else{ 10590: memset(pCsr, 0, sizeof(DbdataCursor)); 10591: pCsr->base.pVtab = pVTab; 10592: } 10593: 10594: *ppCursor = (sqlite3_vtab_cursor *)pCsr; 10595: return SQLITE_OK; 10596: } 10597: 10598: /* 10599: ** Restore a cursor object to the state it was in when first allocated 10600: ** by dbdataOpen(). 10601: */ 10602: static void dbdataResetCursor(DbdataCursor *pCsr){ 10603: DbdataTable *pTab = (DbdataTable*)(pCsr->base.pVtab); 10604: if( pTab->pStmt==0 ){ 10605: pTab->pStmt = pCsr->pStmt; 10606: }else{ 10607: sqlite3_finalize(pCsr->pStmt); 10608: } 10609: pCsr->pStmt = 0; 10610: pCsr->iPgno = 1; 10611: pCsr->iCell = 0; 10612: pCsr->iField = 0; 10613: pCsr->bOnePage = 0; 10614: sqlite3_free(pCsr->aPage); 10615: sqlite3_free(pCsr->pRec); 10616: pCsr->pRec = 0; 10617: pCsr->aPage = 0; 10618: } 10619: 10620: /* 10621: ** Close an sqlite_dbdata or sqlite_dbptr cursor. 10622: */ 10623: static int dbdataClose(sqlite3_vtab_cursor *pCursor){ 10624: DbdataCursor *pCsr = (DbdataCursor*)pCursor; 10625: dbdataResetCursor(pCsr); 10626: sqlite3_free(pCsr); 10627: return SQLITE_OK; 10628: } 10629: 10630: /* 10631: ** Utility methods to decode 16 and 32-bit big-endian unsigned integers. 10632: */ 10633: static unsigned int get_uint16(unsigned char *a){ 10634: return (a[0]<<8)|a[1]; 10635: } 10636: static unsigned int get_uint32(unsigned char *a){ 10637: return ((unsigned int)a[0]<<24) 10638: | ((unsigned int)a[1]<<16) 10639: | ((unsigned int)a[2]<<8) 10640: | ((unsigned int)a[3]); 10641: } 10642: 10643: /* 10644: ** Load page pgno from the database via the sqlite_dbpage virtual table. 10645: ** If successful, set (*ppPage) to point to a buffer containing the page 10646: ** data, (*pnPage) to the size of that buffer in bytes and return 10647: ** SQLITE_OK. In this case it is the responsibility of the caller to 10648: ** eventually free the buffer using sqlite3_free(). 10649: ** 10650: ** Or, if an error occurs, set both (*ppPage) and (*pnPage) to 0 and 10651: ** return an SQLite error code. 10652: */ 10653: static int dbdataLoadPage( 10654: DbdataCursor *pCsr, /* Cursor object */ 10655: unsigned int pgno, /* Page number of page to load */ 10656: u8 **ppPage, /* OUT: pointer to page buffer */ 10657: int *pnPage /* OUT: Size of (*ppPage) in bytes */ 10658: ){ 10659: int rc2; 10660: int rc = SQLITE_OK; 10661: sqlite3_stmt *pStmt = pCsr->pStmt; 10662: 10663: *ppPage = 0; 10664: *pnPage = 0; 10665: sqlite3_bind_int64(pStmt, 2, pgno); 10666: if( SQLITE_ROW==sqlite3_step(pStmt) ){ 10667: int nCopy = sqlite3_column_bytes(pStmt, 0); 10668: if( nCopy>0 ){ 10669: u8 *pPage; 10670: pPage = (u8*)sqlite3_malloc64(nCopy + DBDATA_PADDING_BYTES); 10671: if( pPage==0 ){ 10672: rc = SQLITE_NOMEM; 10673: }else{ 10674: const u8 *pCopy = sqlite3_column_blob(pStmt, 0); 10675: memcpy(pPage, pCopy, nCopy); 10676: memset(&pPage[nCopy], 0, DBDATA_PADDING_BYTES); 10677: } 10678: *ppPage = pPage; 10679: *pnPage = nCopy; 10680: } 10681: } 10682: rc2 = sqlite3_reset(pStmt); 10683: if( rc==SQLITE_OK ) rc = rc2; 10684: 10685: return rc; 10686: } 10687: 10688: /* 10689: ** Read a varint. Put the value in *pVal and return the number of bytes. 10690: */ 10691: static int dbdataGetVarint(const u8 *z, sqlite3_int64 *pVal){ 10692: sqlite3_int64 v = 0; 10693: int i; 10694: for(i=0; i<8; i++){ 10695: v = (v<<7) + (z[i]&0x7f); 10696: if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; } 10697: } 10698: v = (v<<8) + (z[i]&0xff); 10699: *pVal = v; 10700: return 9; 10701: } 10702: 10703: /* 10704: ** Return the number of bytes of space used by an SQLite value of type 10705: ** eType. 10706: */ 10707: static int dbdataValueBytes(int eType){ 10708: switch( eType ){ 10709: case 0: case 8: case 9: 10710: case 10: case 11: 10711: return 0; 10712: case 1: 10713: return 1; 10714: case 2: 10715: return 2; 10716: case 3: 10717: return 3; 10718: case 4: 10719: return 4; 10720: case 5: 10721: return 6; 10722: case 6: 10723: case 7: 10724: return 8; 10725: default: 10726: if( eType>0 ){ 10727: return ((eType-12) / 2); 10728: } 10729: return 0; 10730: } 10731: } 10732: 10733: /* 10734: ** Load a value of type eType from buffer pData and use it to set the 10735: ** result of context object pCtx. 10736: */ 10737: static void dbdataValue( 10738: sqlite3_context *pCtx, 10739: int eType, 10740: u8 *pData, 10741: int nData 10742: ){ 10743: if( eType>=0 && dbdataValueBytes(eType)<=nData ){ 10744: switch( eType ){ 10745: case 0: 10746: case 10: 10747: case 11: 10748: sqlite3_result_null(pCtx); 10749: break; 10750: 10751: case 8: 10752: sqlite3_result_int(pCtx, 0); 10753: break; 10754: case 9: 10755: sqlite3_result_int(pCtx, 1); 10756: break; 10757: 10758: case 1: case 2: case 3: case 4: case 5: case 6: case 7: { 10759: sqlite3_uint64 v = (signed char)pData[0]; 10760: pData++; 10761: switch( eType ){ 10762: case 7: 10763: case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; 10764: case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; 10765: case 4: v = (v<<8) + pData[0]; pData++; 10766: case 3: v = (v<<8) + pData[0]; pData++; 10767: case 2: v = (v<<8) + pData[0]; pData++; 10768: } 10769: 10770: if( eType==7 ){ 10771: double r; 10772: memcpy(&r, &v, sizeof(r)); 10773: sqlite3_result_double(pCtx, r); 10774: }else{ 10775: sqlite3_result_int64(pCtx, (sqlite3_int64)v); 10776: } 10777: break; 10778: } 10779: 10780: default: { 10781: int n = ((eType-12) / 2); 10782: if( eType % 2 ){ 10783: sqlite3_result_text(pCtx, (const char*)pData, n, SQLITE_TRANSIENT); 10784: }else{ 10785: sqlite3_result_blob(pCtx, pData, n, SQLITE_TRANSIENT); 10786: } 10787: } 10788: } 10789: } 10790: } 10791: 10792: /* 10793: ** Move an sqlite_dbdata or sqlite_dbptr cursor to the next entry. 10794: */ 10795: static int dbdataNext(sqlite3_vtab_cursor *pCursor){ 10796: DbdataCursor *pCsr = (DbdataCursor*)pCursor; 10797: DbdataTable *pTab = (DbdataTable*)pCursor->pVtab; 10798: 10799: pCsr->iRowid++; 10800: while( 1 ){ 10801: int rc; 10802: int iOff = (pCsr->iPgno==1 ? 100 : 0); 10803: int bNextPage = 0; 10804: 10805: if( pCsr->aPage==0 ){ 10806: while( 1 ){ 10807: if( pCsr->bOnePage==0 && pCsr->iPgno>pCsr->szDb ) return SQLITE_OK; 10808: rc = dbdataLoadPage(pCsr, pCsr->iPgno, &pCsr->aPage, &pCsr->nPage); 10809: if( rc!=SQLITE_OK ) return rc; 10810: if( pCsr->aPage ) break; 10811: pCsr->iPgno++; 10812: } 10813: pCsr->iCell = pTab->bPtr ? -2 : 0; 10814: pCsr->nCell = get_uint16(&pCsr->aPage[iOff+3]); 10815: } 10816: 10817: if( pTab->bPtr ){ 10818: if( pCsr->aPage[iOff]!=0x02 && pCsr->aPage[iOff]!=0x05 ){ 10819: pCsr->iCell = pCsr->nCell; 10820: } 10821: pCsr->iCell++; 10822: if( pCsr->iCell>=pCsr->nCell ){ 10823: sqlite3_free(pCsr->aPage); 10824: pCsr->aPage = 0; 10825: if( pCsr->bOnePage ) return SQLITE_OK; 10826: pCsr->iPgno++; 10827: }else{ 10828: return SQLITE_OK; 10829: } 10830: }else{ 10831: /* If there is no record loaded, load it now. */ 10832: if( pCsr->pRec==0 ){ 10833: int bHasRowid = 0; 10834: int nPointer = 0; 10835: sqlite3_int64 nPayload = 0; 10836: sqlite3_int64 nHdr = 0; 10837: int iHdr; 10838: int U, X; 10839: int nLocal; 10840: 10841: switch( pCsr->aPage[iOff] ){ 10842: case 0x02: 10843: nPointer = 4; 10844: break; 10845: case 0x0a: 10846: break; 10847: case 0x0d: 10848: bHasRowid = 1; 10849: break; 10850: default: 10851: /* This is not a b-tree page with records on it. Continue. */ 10852: pCsr->iCell = pCsr->nCell; 10853: break; 10854: } 10855: 10856: if( pCsr->iCell>=pCsr->nCell ){ 10857: bNextPage = 1; 10858: }else{ 10859: 10860: iOff += 8 + nPointer + pCsr->iCell*2; 10861: if( iOff>pCsr->nPage ){ 10862: bNextPage = 1; 10863: }else{ 10864: iOff = get_uint16(&pCsr->aPage[iOff]); 10865: } 10866: 10867: /* For an interior node cell, skip past the child-page number */ 10868: iOff += nPointer; 10869: 10870: /* Load the "byte of payload including overflow" field */ 10871: if( bNextPage || iOff>pCsr->nPage ){ 10872: bNextPage = 1; 10873: }else{ 10874: iOff += dbdataGetVarint(&pCsr->aPage[iOff], &nPayload); 10875: } 10876: 10877: /* If this is a leaf intkey cell, load the rowid */ 10878: if( bHasRowid && !bNextPage && iOff<pCsr->nPage ){ 10879: iOff += dbdataGetVarint(&pCsr->aPage[iOff], &pCsr->iIntkey); 10880: } 10881: 10882: /* Figure out how much data to read from the local page */ 10883: U = pCsr->nPage; 10884: if( bHasRowid ){ 10885: X = U-35; 10886: }else{ 10887: X = ((U-12)*64/255)-23; 10888: } 10889: if( nPayload<=X ){ 10890: nLocal = nPayload; 10891: }else{ 10892: int M, K; 10893: M = ((U-12)*32/255)-23; 10894: K = M+((nPayload-M)%(U-4)); 10895: if( K<=X ){ 10896: nLocal = K; 10897: }else{ 10898: nLocal = M; 10899: } 10900: } 10901: 10902: if( bNextPage || nLocal+iOff>pCsr->nPage ){ 10903: bNextPage = 1; 10904: }else{ 10905: 10906: /* Allocate space for payload. And a bit more to catch small buffer 10907: ** overruns caused by attempting to read a varint or similar from 10908: ** near the end of a corrupt record. */ 10909: pCsr->pRec = (u8*)sqlite3_malloc64(nPayload+DBDATA_PADDING_BYTES); 10910: if( pCsr->pRec==0 ) return SQLITE_NOMEM; 10911: memset(pCsr->pRec, 0, nPayload+DBDATA_PADDING_BYTES); 10912: pCsr->nRec = nPayload; 10913: 10914: /* Load the nLocal bytes of payload */ 10915: memcpy(pCsr->pRec, &pCsr->aPage[iOff], nLocal); 10916: iOff += nLocal; 10917: 10918: /* Load content from overflow pages */ 10919: if( nPayload>nLocal ){ 10920: sqlite3_int64 nRem = nPayload - nLocal; 10921: unsigned int pgnoOvfl = get_uint32(&pCsr->aPage[iOff]); 10922: while( nRem>0 ){ 10923: u8 *aOvfl = 0; 10924: int nOvfl = 0; 10925: int nCopy; 10926: rc = dbdataLoadPage(pCsr, pgnoOvfl, &aOvfl, &nOvfl); 10927: assert( rc!=SQLITE_OK || aOvfl==0 || nOvfl==pCsr->nPage ); 10928: if( rc!=SQLITE_OK ) return rc; 10929: if( aOvfl==0 ) break; 10930: 10931: nCopy = U-4; 10932: if( nCopy>nRem ) nCopy = nRem; 10933: memcpy(&pCsr->pRec[nPayload-nRem], &aOvfl[4], nCopy); 10934: nRem -= nCopy; 10935: 10936: pgnoOvfl = get_uint32(aOvfl); 10937: sqlite3_free(aOvfl); 10938: } 10939: } 10940: 10941: iHdr = dbdataGetVarint(pCsr->pRec, &nHdr); 10942: pCsr->nHdr = nHdr; 10943: pCsr->pHdrPtr = &pCsr->pRec[iHdr]; 10944: pCsr->pPtr = &pCsr->pRec[pCsr->nHdr]; 10945: pCsr->iField = (bHasRowid ? -1 : 0); 10946: } 10947: } 10948: }else{ 10949: pCsr->iField++; 10950: if( pCsr->iField>0 ){ 10951: sqlite3_int64 iType; 10952: if( pCsr->pHdrPtr>&pCsr->pRec[pCsr->nRec] ){ 10953: bNextPage = 1; 10954: }else{ 10955: pCsr->pHdrPtr += dbdataGetVarint(pCsr->pHdrPtr, &iType); 10956: pCsr->pPtr += dbdataValueBytes(iType); 10957: } 10958: } 10959: } 10960: 10961: if( bNextPage ){ 10962: sqlite3_free(pCsr->aPage); 10963: sqlite3_free(pCsr->pRec); 10964: pCsr->aPage = 0; 10965: pCsr->pRec = 0; 10966: if( pCsr->bOnePage ) return SQLITE_OK; 10967: pCsr->iPgno++; 10968: }else{ 10969: if( pCsr->iField<0 || pCsr->pHdrPtr<&pCsr->pRec[pCsr->nHdr] ){ 10970: return SQLITE_OK; 10971: } 10972: 10973: /* Advance to the next cell. The next iteration of the loop will load 10974: ** the record and so on. */ 10975: sqlite3_free(pCsr->pRec); 10976: pCsr->pRec = 0; 10977: pCsr->iCell++; 10978: } 10979: } 10980: } 10981: 10982: assert( !"can't get here" ); 10983: return SQLITE_OK; 10984: } 10985: 10986: /* 10987: ** Return true if the cursor is at EOF. 10988: */ 10989: static int dbdataEof(sqlite3_vtab_cursor *pCursor){ 10990: DbdataCursor *pCsr = (DbdataCursor*)pCursor; 10991: return pCsr->aPage==0; 10992: } 10993: 10994: /* 10995: ** Determine the size in pages of database zSchema (where zSchema is 10996: ** "main", "temp" or the name of an attached database) and set 10997: ** pCsr->szDb accordingly. If successful, return SQLITE_OK. Otherwise, 10998: ** an SQLite error code. 10999: */ 11000: static int dbdataDbsize(DbdataCursor *pCsr, const char *zSchema){ 11001: DbdataTable *pTab = (DbdataTable*)pCsr->base.pVtab; 11002: char *zSql = 0; 11003: int rc, rc2; 11004: sqlite3_stmt *pStmt = 0; 11005: 11006: zSql = sqlite3_mprintf("PRAGMA %Q.page_count", zSchema); 11007: if( zSql==0 ) return SQLITE_NOMEM; 11008: rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0); 11009: sqlite3_free(zSql); 11010: if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ 11011: pCsr->szDb = sqlite3_column_int(pStmt, 0); 11012: } 11013: rc2 = sqlite3_finalize(pStmt); 11014: if( rc==SQLITE_OK ) rc = rc2; 11015: return rc; 11016: } 11017: 11018: /* 11019: ** xFilter method for sqlite_dbdata and sqlite_dbptr. 11020: */ 11021: static int dbdataFilter( 11022: sqlite3_vtab_cursor *pCursor, 11023: int idxNum, const char *idxStr, 11024: int argc, sqlite3_value **argv 11025: ){ 11026: DbdataCursor *pCsr = (DbdataCursor*)pCursor; 11027: DbdataTable *pTab = (DbdataTable*)pCursor->pVtab; 11028: int rc = SQLITE_OK; 11029: const char *zSchema = "main"; 11030: 11031: dbdataResetCursor(pCsr); 11032: assert( pCsr->iPgno==1 ); 11033: if( idxNum & 0x01 ){ 11034: zSchema = (const char*)sqlite3_value_text(argv[0]); 11035: } 11036: if( idxNum & 0x02 ){ 11037: pCsr->iPgno = sqlite3_value_int(argv[(idxNum & 0x01)]); 11038: pCsr->bOnePage = 1; 11039: }else{ 11040: pCsr->nPage = dbdataDbsize(pCsr, zSchema); 11041: rc = dbdataDbsize(pCsr, zSchema); 11042: } 11043: 11044: if( rc==SQLITE_OK ){ 11045: if( pTab->pStmt ){ 11046: pCsr->pStmt = pTab->pStmt; 11047: pTab->pStmt = 0; 11048: }else{ 11049: rc = sqlite3_prepare_v2(pTab->db, 11050: "SELECT data FROM sqlite_dbpage(?) WHERE pgno=?", -1, 11051: &pCsr->pStmt, 0 11052: ); 11053: } 11054: } 11055: if( rc==SQLITE_OK ){ 11056: rc = sqlite3_bind_text(pCsr->pStmt, 1, zSchema, -1, SQLITE_TRANSIENT); 11057: }else{ 11058: pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db)); 11059: } 11060: if( rc==SQLITE_OK ){ 11061: rc = dbdataNext(pCursor); 11062: } 11063: return rc; 11064: } 11065: 11066: /* 11067: ** Return a column for the sqlite_dbdata or sqlite_dbptr table. 11068: */ 11069: static int dbdataColumn( 11070: sqlite3_vtab_cursor *pCursor, 11071: sqlite3_context *ctx, 11072: int i 11073: ){ 11074: DbdataCursor *pCsr = (DbdataCursor*)pCursor; 11075: DbdataTable *pTab = (DbdataTable*)pCursor->pVtab; 11076: if( pTab->bPtr ){ 11077: switch( i ){ 11078: case DBPTR_COLUMN_PGNO: 11079: sqlite3_result_int64(ctx, pCsr->iPgno); 11080: break; 11081: case DBPTR_COLUMN_CHILD: { 11082: int iOff = pCsr->iPgno==1 ? 100 : 0; 11083: if( pCsr->iCell<0 ){ 11084: iOff += 8; 11085: }else{ 11086: iOff += 12 + pCsr->iCell*2; 11087: if( iOff>pCsr->nPage ) return SQLITE_OK; 11088: iOff = get_uint16(&pCsr->aPage[iOff]); 11089: } 11090: if( iOff<=pCsr->nPage ){ 11091: sqlite3_result_int64(ctx, get_uint32(&pCsr->aPage[iOff])); 11092: } 11093: break; 11094: } 11095: } 11096: }else{ 11097: switch( i ){ 11098: case DBDATA_COLUMN_PGNO: 11099: sqlite3_result_int64(ctx, pCsr->iPgno); 11100: break; 11101: case DBDATA_COLUMN_CELL: 11102: sqlite3_result_int(ctx, pCsr->iCell); 11103: break; 11104: case DBDATA_COLUMN_FIELD: 11105: sqlite3_result_int(ctx, pCsr->iField); 11106: break; 11107: case DBDATA_COLUMN_VALUE: { 11108: if( pCsr->iField<0 ){ 11109: sqlite3_result_int64(ctx, pCsr->iIntkey); 11110: }else{ 11111: sqlite3_int64 iType; 11112: dbdataGetVarint(pCsr->pHdrPtr, &iType); 11113: dbdataValue( 11114: ctx, iType, pCsr->pPtr, &pCsr->pRec[pCsr->nRec] - pCsr->pPtr 11115: ); 11116: } 11117: break; 11118: } 11119: } 11120: } 11121: return SQLITE_OK; 11122: } 11123: 11124: /* 11125: ** Return the rowid for an sqlite_dbdata or sqlite_dptr table. 11126: */ 11127: static int dbdataRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){ 11128: DbdataCursor *pCsr = (DbdataCursor*)pCursor; 11129: *pRowid = pCsr->iRowid; 11130: return SQLITE_OK; 11131: } 11132: 11133: 11134: /* 11135: ** Invoke this routine to register the "sqlite_dbdata" virtual table module 11136: */ 11137: static int sqlite3DbdataRegister(sqlite3 *db){ 11138: static sqlite3_module dbdata_module = { 11139: 0, /* iVersion */ 11140: 0, /* xCreate */ 11141: dbdataConnect, /* xConnect */ 11142: dbdataBestIndex, /* xBestIndex */ 11143: dbdataDisconnect, /* xDisconnect */ 11144: 0, /* xDestroy */ 11145: dbdataOpen, /* xOpen - open a cursor */ 11146: dbdataClose, /* xClose - close a cursor */ 11147: dbdataFilter, /* xFilter - configure scan constraints */ 11148: dbdataNext, /* xNext - advance a cursor */ 11149: dbdataEof, /* xEof - check for end of scan */ 11150: dbdataColumn, /* xColumn - read data */ 11151: dbdataRowid, /* xRowid - read data */ 11152: 0, /* xUpdate */ 11153: 0, /* xBegin */ 11154: 0, /* xSync */ 11155: 0, /* xCommit */ 11156: 0, /* xRollback */ 11157: 0, /* xFindMethod */ 11158: 0, /* xRename */ 11159: 0, /* xSavepoint */ 11160: 0, /* xRelease */ 11161: 0, /* xRollbackTo */ 11162: 0 /* xShadowName */ 11163: }; 11164: 11165: int rc = sqlite3_create_module(db, "sqlite_dbdata", &dbdata_module, 0); 11166: if( rc==SQLITE_OK ){ 11167: rc = sqlite3_create_module(db, "sqlite_dbptr", &dbdata_module, (void*)1); 11168: } 11169: return rc; 11170: } 11171: 11172: #ifdef _WIN32 11173: 11174: #endif 11175: int sqlite3_dbdata_init( 11176: sqlite3 *db, 11177: char **pzErrMsg, 11178: const sqlite3_api_routines *pApi 11179: ){ 11180: SQLITE_EXTENSION_INIT2(pApi); 11181: return sqlite3DbdataRegister(db); 11182: } 11183: 11184: /************************* End ../ext/misc/dbdata.c ********************/ 11185: #endif 11186: 11187: #if defined(SQLITE_ENABLE_SESSION) 11188: /* 11189: ** State information for a single open session 11190: */ 11191: typedef struct OpenSession OpenSession; 11192: struct OpenSession { 11193: char *zName; /* Symbolic name for this session */ 11194: int nFilter; /* Number of xFilter rejection GLOB patterns */ 11195: char **azFilter; /* Array of xFilter rejection GLOB patterns */ 11196: sqlite3_session *p; /* The open session */ 11197: }; 11198: #endif 11199: 11200: typedef struct ExpertInfo ExpertInfo; 11201: struct ExpertInfo { 11202: sqlite3expert *pExpert; 11203: int bVerbose; 11204: }; 11205: 11206: /* A single line in the EQP output */ 11207: typedef struct EQPGraphRow EQPGraphRow; 11208: struct EQPGraphRow { 11209: int iEqpId; /* ID for this row */ 11210: int iParentId; /* ID of the parent row */ 11211: EQPGraphRow *pNext; /* Next row in sequence */ 11212: char zText[1]; /* Text to display for this row */ 11213: }; 11214: 11215: /* All EQP output is collected into an instance of the following */ 11216: typedef struct EQPGraph EQPGraph; 11217: struct EQPGraph { 11218: EQPGraphRow *pRow; /* Linked list of all rows of the EQP output */ 11219: EQPGraphRow *pLast; /* Last element of the pRow list */ 11220: char zPrefix[100]; /* Graph prefix */ 11221: }; 11222: 11223: /* 11224: ** State information about the database connection is contained in an 11225: ** instance of the following structure. 11226: */ 11227: typedef struct ShellState ShellState; 11228: struct ShellState { 11229: sqlite3 *db; /* The database */ 11230: u8 autoExplain; /* Automatically turn on .explain mode */ 11231: u8 autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */ 11232: u8 autoEQPtest; /* autoEQP is in test mode */ 11233: u8 autoEQPtrace; /* autoEQP is in trace mode */ 11234: u8 scanstatsOn; /* True to display scan stats before each finalize */ 11235: u8 openMode; /* SHELL_OPEN_NORMAL, _APPENDVFS, or _ZIPFILE */ 11236: u8 doXdgOpen; /* Invoke start/open/xdg-open in output_reset() */ 11237: u8 nEqpLevel; /* Depth of the EQP output graph */ 11238: u8 eTraceType; /* SHELL_TRACE_* value for type of trace */ 1.6 ! misho 11239: unsigned statsOn; /* True to display memory stats before each finalize */ 1.5 misho 11240: unsigned mEqpLines; /* Mask of veritical lines in the EQP output graph */ 11241: int outCount; /* Revert to stdout when reaching zero */ 11242: int cnt; /* Number of records displayed so far */ 11243: int lineno; /* Line number of last line read from in */ 11244: int openFlags; /* Additional flags to open. (SQLITE_OPEN_NOFOLLOW) */ 11245: FILE *in; /* Read commands from this stream */ 11246: FILE *out; /* Write results here */ 11247: FILE *traceOut; /* Output for sqlite3_trace() */ 11248: int nErr; /* Number of errors seen */ 11249: int mode; /* An output mode setting */ 11250: int modePrior; /* Saved mode */ 11251: int cMode; /* temporary output mode for the current query */ 11252: int normalMode; /* Output mode before ".explain on" */ 11253: int writableSchema; /* True if PRAGMA writable_schema=ON */ 11254: int showHeader; /* True to show column names in List or Column mode */ 11255: int nCheck; /* Number of ".check" commands run */ 11256: unsigned nProgress; /* Number of progress callbacks encountered */ 11257: unsigned mxProgress; /* Maximum progress callbacks before failing */ 11258: unsigned flgProgress; /* Flags for the progress callback */ 11259: unsigned shellFlgs; /* Various flags */ 11260: unsigned priorShFlgs; /* Saved copy of flags */ 11261: sqlite3_int64 szMax; /* --maxsize argument to .open */ 11262: char *zDestTable; /* Name of destination table when MODE_Insert */ 11263: char *zTempFile; /* Temporary file that might need deleting */ 11264: char zTestcase[30]; /* Name of current test case */ 11265: char colSeparator[20]; /* Column separator character for several modes */ 11266: char rowSeparator[20]; /* Row separator character for MODE_Ascii */ 11267: char colSepPrior[20]; /* Saved column separator */ 11268: char rowSepPrior[20]; /* Saved row separator */ 11269: int *colWidth; /* Requested width of each column in columnar modes */ 11270: int *actualWidth; /* Actual width of each column */ 11271: int nWidth; /* Number of slots in colWidth[] and actualWidth[] */ 11272: char nullValue[20]; /* The text to print when a NULL comes back from 11273: ** the database */ 11274: char outfile[FILENAME_MAX]; /* Filename for *out */ 11275: const char *zDbFilename; /* name of the database file */ 11276: char *zFreeOnClose; /* Filename to free when closing */ 11277: const char *zVfs; /* Name of VFS to use */ 11278: sqlite3_stmt *pStmt; /* Current statement if any. */ 11279: FILE *pLog; /* Write log output here */ 11280: int *aiIndent; /* Array of indents used in MODE_Explain */ 11281: int nIndent; /* Size of array aiIndent[] */ 11282: int iIndent; /* Index of current op in aiIndent[] */ 11283: EQPGraph sGraph; /* Information for the graphical EXPLAIN QUERY PLAN */ 11284: #if defined(SQLITE_ENABLE_SESSION) 11285: int nSession; /* Number of active sessions */ 11286: OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */ 11287: #endif 11288: ExpertInfo expert; /* Valid if previous command was ".expert OPT..." */ 11289: }; 11290: 11291: 11292: /* Allowed values for ShellState.autoEQP 11293: */ 11294: #define AUTOEQP_off 0 /* Automatic EXPLAIN QUERY PLAN is off */ 11295: #define AUTOEQP_on 1 /* Automatic EQP is on */ 11296: #define AUTOEQP_trigger 2 /* On and also show plans for triggers */ 11297: #define AUTOEQP_full 3 /* Show full EXPLAIN */ 11298: 11299: /* Allowed values for ShellState.openMode 11300: */ 11301: #define SHELL_OPEN_UNSPEC 0 /* No open-mode specified */ 11302: #define SHELL_OPEN_NORMAL 1 /* Normal database file */ 11303: #define SHELL_OPEN_APPENDVFS 2 /* Use appendvfs */ 11304: #define SHELL_OPEN_ZIPFILE 3 /* Use the zipfile virtual table */ 11305: #define SHELL_OPEN_READONLY 4 /* Open a normal database read-only */ 11306: #define SHELL_OPEN_DESERIALIZE 5 /* Open using sqlite3_deserialize() */ 11307: #define SHELL_OPEN_HEXDB 6 /* Use "dbtotxt" output as data source */ 11308: 11309: /* Allowed values for ShellState.eTraceType 11310: */ 11311: #define SHELL_TRACE_PLAIN 0 /* Show input SQL text */ 11312: #define SHELL_TRACE_EXPANDED 1 /* Show expanded SQL text */ 11313: #define SHELL_TRACE_NORMALIZED 2 /* Show normalized SQL text */ 11314: 11315: /* Bits in the ShellState.flgProgress variable */ 11316: #define SHELL_PROGRESS_QUIET 0x01 /* Omit announcing every progress callback */ 11317: #define SHELL_PROGRESS_RESET 0x02 /* Reset the count when the progres 11318: ** callback limit is reached, and for each 11319: ** top-level SQL statement */ 11320: #define SHELL_PROGRESS_ONCE 0x04 /* Cancel the --limit after firing once */ 11321: 11322: /* 11323: ** These are the allowed shellFlgs values 11324: */ 11325: #define SHFLG_Pagecache 0x00000001 /* The --pagecache option is used */ 11326: #define SHFLG_Lookaside 0x00000002 /* Lookaside memory is used */ 11327: #define SHFLG_Backslash 0x00000004 /* The --backslash option is used */ 11328: #define SHFLG_PreserveRowid 0x00000008 /* .dump preserves rowid values */ 11329: #define SHFLG_Newlines 0x00000010 /* .dump --newline flag */ 11330: #define SHFLG_CountChanges 0x00000020 /* .changes setting */ 11331: #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */ 11332: #define SHFLG_HeaderSet 0x00000080 /* .header has been used */ 1.6 ! misho 11333: #define SHFLG_DumpDataOnly 0x00000100 /* .dump show data only */ ! 11334: #define SHFLG_DumpNoSys 0x00000200 /* .dump omits system tables */ 1.5 misho 11335: 11336: /* 11337: ** Macros for testing and setting shellFlgs 11338: */ 11339: #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0) 11340: #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X)) 11341: #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X))) 11342: 11343: /* 11344: ** These are the allowed modes. 11345: */ 11346: #define MODE_Line 0 /* One column per line. Blank line between records */ 11347: #define MODE_Column 1 /* One record per line in neat columns */ 11348: #define MODE_List 2 /* One record per line with a separator */ 11349: #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ 11350: #define MODE_Html 4 /* Generate an XHTML table */ 11351: #define MODE_Insert 5 /* Generate SQL "insert" statements */ 11352: #define MODE_Quote 6 /* Quote values as for SQL */ 11353: #define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */ 11354: #define MODE_Csv 8 /* Quote strings, numbers are plain */ 11355: #define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */ 11356: #define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */ 11357: #define MODE_Pretty 11 /* Pretty-print schemas */ 11358: #define MODE_EQP 12 /* Converts EXPLAIN QUERY PLAN output into a graph */ 11359: #define MODE_Json 13 /* Output JSON */ 11360: #define MODE_Markdown 14 /* Markdown formatting */ 11361: #define MODE_Table 15 /* MySQL-style table formatting */ 11362: #define MODE_Box 16 /* Unicode box-drawing characters */ 11363: 11364: static const char *modeDescr[] = { 11365: "line", 11366: "column", 11367: "list", 11368: "semi", 11369: "html", 11370: "insert", 11371: "quote", 11372: "tcl", 11373: "csv", 11374: "explain", 11375: "ascii", 11376: "prettyprint", 11377: "eqp", 11378: "json", 11379: "markdown", 11380: "table", 11381: "box" 11382: }; 11383: 11384: /* 11385: ** These are the column/row/line separators used by the various 11386: ** import/export modes. 11387: */ 11388: #define SEP_Column "|" 11389: #define SEP_Row "\n" 11390: #define SEP_Tab "\t" 11391: #define SEP_Space " " 11392: #define SEP_Comma "," 11393: #define SEP_CrLf "\r\n" 11394: #define SEP_Unit "\x1F" 11395: #define SEP_Record "\x1E" 11396: 11397: /* 11398: ** A callback for the sqlite3_log() interface. 11399: */ 11400: static void shellLog(void *pArg, int iErrCode, const char *zMsg){ 11401: ShellState *p = (ShellState*)pArg; 11402: if( p->pLog==0 ) return; 11403: utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg); 11404: fflush(p->pLog); 11405: } 11406: 11407: /* 11408: ** SQL function: shell_putsnl(X) 11409: ** 11410: ** Write the text X to the screen (or whatever output is being directed) 11411: ** adding a newline at the end, and then return X. 11412: */ 11413: static void shellPutsFunc( 11414: sqlite3_context *pCtx, 11415: int nVal, 11416: sqlite3_value **apVal 11417: ){ 11418: ShellState *p = (ShellState*)sqlite3_user_data(pCtx); 11419: (void)nVal; 11420: utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0])); 11421: sqlite3_result_value(pCtx, apVal[0]); 11422: } 11423: 11424: /* 11425: ** SQL function: edit(VALUE) 11426: ** edit(VALUE,EDITOR) 11427: ** 11428: ** These steps: 11429: ** 11430: ** (1) Write VALUE into a temporary file. 11431: ** (2) Run program EDITOR on that temporary file. 11432: ** (3) Read the temporary file back and return its content as the result. 11433: ** (4) Delete the temporary file 11434: ** 11435: ** If the EDITOR argument is omitted, use the value in the VISUAL 11436: ** environment variable. If still there is no EDITOR, through an error. 11437: ** 11438: ** Also throw an error if the EDITOR program returns a non-zero exit code. 11439: */ 11440: #ifndef SQLITE_NOHAVE_SYSTEM 11441: static void editFunc( 11442: sqlite3_context *context, 11443: int argc, 11444: sqlite3_value **argv 11445: ){ 11446: const char *zEditor; 11447: char *zTempFile = 0; 11448: sqlite3 *db; 11449: char *zCmd = 0; 11450: int bBin; 11451: int rc; 11452: int hasCRNL = 0; 11453: FILE *f = 0; 11454: sqlite3_int64 sz; 11455: sqlite3_int64 x; 11456: unsigned char *p = 0; 11457: 11458: if( argc==2 ){ 11459: zEditor = (const char*)sqlite3_value_text(argv[1]); 11460: }else{ 11461: zEditor = getenv("VISUAL"); 11462: } 11463: if( zEditor==0 ){ 11464: sqlite3_result_error(context, "no editor for edit()", -1); 11465: return; 11466: } 11467: if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 11468: sqlite3_result_error(context, "NULL input to edit()", -1); 11469: return; 11470: } 11471: db = sqlite3_context_db_handle(context); 11472: zTempFile = 0; 11473: sqlite3_file_control(db, 0, SQLITE_FCNTL_TEMPFILENAME, &zTempFile); 11474: if( zTempFile==0 ){ 11475: sqlite3_uint64 r = 0; 11476: sqlite3_randomness(sizeof(r), &r); 11477: zTempFile = sqlite3_mprintf("temp%llx", r); 11478: if( zTempFile==0 ){ 11479: sqlite3_result_error_nomem(context); 11480: return; 11481: } 11482: } 11483: bBin = sqlite3_value_type(argv[0])==SQLITE_BLOB; 11484: /* When writing the file to be edited, do \n to \r\n conversions on systems 11485: ** that want \r\n line endings */ 11486: f = fopen(zTempFile, bBin ? "wb" : "w"); 11487: if( f==0 ){ 11488: sqlite3_result_error(context, "edit() cannot open temp file", -1); 11489: goto edit_func_end; 11490: } 11491: sz = sqlite3_value_bytes(argv[0]); 11492: if( bBin ){ 11493: x = fwrite(sqlite3_value_blob(argv[0]), 1, (size_t)sz, f); 11494: }else{ 11495: const char *z = (const char*)sqlite3_value_text(argv[0]); 11496: /* Remember whether or not the value originally contained \r\n */ 11497: if( z && strstr(z,"\r\n")!=0 ) hasCRNL = 1; 11498: x = fwrite(sqlite3_value_text(argv[0]), 1, (size_t)sz, f); 11499: } 11500: fclose(f); 11501: f = 0; 11502: if( x!=sz ){ 11503: sqlite3_result_error(context, "edit() could not write the whole file", -1); 11504: goto edit_func_end; 11505: } 11506: zCmd = sqlite3_mprintf("%s \"%s\"", zEditor, zTempFile); 11507: if( zCmd==0 ){ 11508: sqlite3_result_error_nomem(context); 11509: goto edit_func_end; 11510: } 11511: rc = system(zCmd); 11512: sqlite3_free(zCmd); 11513: if( rc ){ 11514: sqlite3_result_error(context, "EDITOR returned non-zero", -1); 11515: goto edit_func_end; 11516: } 11517: f = fopen(zTempFile, "rb"); 11518: if( f==0 ){ 11519: sqlite3_result_error(context, 11520: "edit() cannot reopen temp file after edit", -1); 11521: goto edit_func_end; 11522: } 11523: fseek(f, 0, SEEK_END); 11524: sz = ftell(f); 11525: rewind(f); 11526: p = sqlite3_malloc64( sz+1 ); 11527: if( p==0 ){ 11528: sqlite3_result_error_nomem(context); 11529: goto edit_func_end; 11530: } 11531: x = fread(p, 1, (size_t)sz, f); 11532: fclose(f); 11533: f = 0; 11534: if( x!=sz ){ 11535: sqlite3_result_error(context, "could not read back the whole file", -1); 11536: goto edit_func_end; 11537: } 11538: if( bBin ){ 11539: sqlite3_result_blob64(context, p, sz, sqlite3_free); 11540: }else{ 11541: sqlite3_int64 i, j; 11542: if( hasCRNL ){ 11543: /* If the original contains \r\n then do no conversions back to \n */ 11544: j = sz; 11545: }else{ 11546: /* If the file did not originally contain \r\n then convert any new 11547: ** \r\n back into \n */ 11548: for(i=j=0; i<sz; i++){ 11549: if( p[i]=='\r' && p[i+1]=='\n' ) i++; 11550: p[j++] = p[i]; 11551: } 11552: sz = j; 11553: p[sz] = 0; 11554: } 11555: sqlite3_result_text64(context, (const char*)p, sz, 11556: sqlite3_free, SQLITE_UTF8); 11557: } 11558: p = 0; 11559: 11560: edit_func_end: 11561: if( f ) fclose(f); 11562: unlink(zTempFile); 11563: sqlite3_free(zTempFile); 11564: sqlite3_free(p); 11565: } 11566: #endif /* SQLITE_NOHAVE_SYSTEM */ 11567: 11568: /* 11569: ** Save or restore the current output mode 11570: */ 11571: static void outputModePush(ShellState *p){ 11572: p->modePrior = p->mode; 11573: p->priorShFlgs = p->shellFlgs; 11574: memcpy(p->colSepPrior, p->colSeparator, sizeof(p->colSeparator)); 11575: memcpy(p->rowSepPrior, p->rowSeparator, sizeof(p->rowSeparator)); 11576: } 11577: static void outputModePop(ShellState *p){ 11578: p->mode = p->modePrior; 11579: p->shellFlgs = p->priorShFlgs; 11580: memcpy(p->colSeparator, p->colSepPrior, sizeof(p->colSeparator)); 11581: memcpy(p->rowSeparator, p->rowSepPrior, sizeof(p->rowSeparator)); 11582: } 11583: 11584: /* 11585: ** Output the given string as a hex-encoded blob (eg. X'1234' ) 11586: */ 11587: static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ 11588: int i; 11589: char *zBlob = (char *)pBlob; 11590: raw_printf(out,"X'"); 11591: for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); } 11592: raw_printf(out,"'"); 11593: } 11594: 11595: /* 11596: ** Find a string that is not found anywhere in z[]. Return a pointer 11597: ** to that string. 11598: ** 11599: ** Try to use zA and zB first. If both of those are already found in z[] 11600: ** then make up some string and store it in the buffer zBuf. 11601: */ 11602: static const char *unused_string( 11603: const char *z, /* Result must not appear anywhere in z */ 11604: const char *zA, const char *zB, /* Try these first */ 11605: char *zBuf /* Space to store a generated string */ 11606: ){ 11607: unsigned i = 0; 11608: if( strstr(z, zA)==0 ) return zA; 11609: if( strstr(z, zB)==0 ) return zB; 11610: do{ 11611: sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++); 11612: }while( strstr(z,zBuf)!=0 ); 11613: return zBuf; 11614: } 11615: 11616: /* 11617: ** Output the given string as a quoted string using SQL quoting conventions. 11618: ** 11619: ** See also: output_quoted_escaped_string() 11620: */ 11621: static void output_quoted_string(FILE *out, const char *z){ 11622: int i; 11623: char c; 11624: setBinaryMode(out, 1); 11625: for(i=0; (c = z[i])!=0 && c!='\''; i++){} 11626: if( c==0 ){ 11627: utf8_printf(out,"'%s'",z); 11628: }else{ 11629: raw_printf(out, "'"); 11630: while( *z ){ 11631: for(i=0; (c = z[i])!=0 && c!='\''; i++){} 11632: if( c=='\'' ) i++; 11633: if( i ){ 11634: utf8_printf(out, "%.*s", i, z); 11635: z += i; 11636: } 11637: if( c=='\'' ){ 11638: raw_printf(out, "'"); 11639: continue; 11640: } 11641: if( c==0 ){ 11642: break; 11643: } 11644: z++; 11645: } 11646: raw_printf(out, "'"); 11647: } 11648: setTextMode(out, 1); 11649: } 11650: 11651: /* 11652: ** Output the given string as a quoted string using SQL quoting conventions. 11653: ** Additionallly , escape the "\n" and "\r" characters so that they do not 11654: ** get corrupted by end-of-line translation facilities in some operating 11655: ** systems. 11656: ** 11657: ** This is like output_quoted_string() but with the addition of the \r\n 11658: ** escape mechanism. 11659: */ 11660: static void output_quoted_escaped_string(FILE *out, const char *z){ 11661: int i; 11662: char c; 11663: setBinaryMode(out, 1); 11664: for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){} 11665: if( c==0 ){ 11666: utf8_printf(out,"'%s'",z); 11667: }else{ 11668: const char *zNL = 0; 11669: const char *zCR = 0; 11670: int nNL = 0; 11671: int nCR = 0; 11672: char zBuf1[20], zBuf2[20]; 11673: for(i=0; z[i]; i++){ 11674: if( z[i]=='\n' ) nNL++; 11675: if( z[i]=='\r' ) nCR++; 11676: } 11677: if( nNL ){ 11678: raw_printf(out, "replace("); 11679: zNL = unused_string(z, "\\n", "\\012", zBuf1); 11680: } 11681: if( nCR ){ 11682: raw_printf(out, "replace("); 11683: zCR = unused_string(z, "\\r", "\\015", zBuf2); 11684: } 11685: raw_printf(out, "'"); 11686: while( *z ){ 11687: for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){} 11688: if( c=='\'' ) i++; 11689: if( i ){ 11690: utf8_printf(out, "%.*s", i, z); 11691: z += i; 11692: } 11693: if( c=='\'' ){ 11694: raw_printf(out, "'"); 11695: continue; 11696: } 11697: if( c==0 ){ 11698: break; 11699: } 11700: z++; 11701: if( c=='\n' ){ 11702: raw_printf(out, "%s", zNL); 11703: continue; 11704: } 11705: raw_printf(out, "%s", zCR); 11706: } 11707: raw_printf(out, "'"); 11708: if( nCR ){ 11709: raw_printf(out, ",'%s',char(13))", zCR); 11710: } 11711: if( nNL ){ 11712: raw_printf(out, ",'%s',char(10))", zNL); 11713: } 11714: } 11715: setTextMode(out, 1); 11716: } 11717: 11718: /* 11719: ** Output the given string as a quoted according to C or TCL quoting rules. 11720: */ 11721: static void output_c_string(FILE *out, const char *z){ 11722: unsigned int c; 11723: fputc('"', out); 11724: while( (c = *(z++))!=0 ){ 11725: if( c=='\\' ){ 11726: fputc(c, out); 11727: fputc(c, out); 11728: }else if( c=='"' ){ 11729: fputc('\\', out); 11730: fputc('"', out); 11731: }else if( c=='\t' ){ 11732: fputc('\\', out); 11733: fputc('t', out); 11734: }else if( c=='\n' ){ 11735: fputc('\\', out); 11736: fputc('n', out); 11737: }else if( c=='\r' ){ 11738: fputc('\\', out); 11739: fputc('r', out); 11740: }else if( !isprint(c&0xff) ){ 11741: raw_printf(out, "\\%03o", c&0xff); 11742: }else{ 11743: fputc(c, out); 11744: } 11745: } 11746: fputc('"', out); 11747: } 11748: 11749: /* 11750: ** Output the given string as a quoted according to JSON quoting rules. 11751: */ 11752: static void output_json_string(FILE *out, const char *z, int n){ 11753: unsigned int c; 11754: if( n<0 ) n = (int)strlen(z); 11755: fputc('"', out); 11756: while( n-- ){ 11757: c = *(z++); 11758: if( c=='\\' || c=='"' ){ 11759: fputc('\\', out); 11760: fputc(c, out); 11761: }else if( c<=0x1f ){ 11762: fputc('\\', out); 11763: if( c=='\b' ){ 11764: fputc('b', out); 11765: }else if( c=='\f' ){ 11766: fputc('f', out); 11767: }else if( c=='\n' ){ 11768: fputc('n', out); 11769: }else if( c=='\r' ){ 11770: fputc('r', out); 11771: }else if( c=='\t' ){ 11772: fputc('t', out); 11773: }else{ 11774: raw_printf(out, "u%04x",c); 11775: } 11776: }else{ 11777: fputc(c, out); 11778: } 11779: } 11780: fputc('"', out); 11781: } 11782: 11783: /* 11784: ** Output the given string with characters that are special to 11785: ** HTML escaped. 11786: */ 11787: static void output_html_string(FILE *out, const char *z){ 11788: int i; 11789: if( z==0 ) z = ""; 11790: while( *z ){ 11791: for(i=0; z[i] 11792: && z[i]!='<' 11793: && z[i]!='&' 11794: && z[i]!='>' 11795: && z[i]!='\"' 11796: && z[i]!='\''; 11797: i++){} 11798: if( i>0 ){ 11799: utf8_printf(out,"%.*s",i,z); 11800: } 11801: if( z[i]=='<' ){ 11802: raw_printf(out,"<"); 11803: }else if( z[i]=='&' ){ 11804: raw_printf(out,"&"); 11805: }else if( z[i]=='>' ){ 11806: raw_printf(out,">"); 11807: }else if( z[i]=='\"' ){ 11808: raw_printf(out,"""); 11809: }else if( z[i]=='\'' ){ 11810: raw_printf(out,"'"); 11811: }else{ 11812: break; 11813: } 11814: z += i + 1; 11815: } 11816: } 11817: 11818: /* 11819: ** If a field contains any character identified by a 1 in the following 11820: ** array, then the string must be quoted for CSV. 11821: */ 11822: static const char needCsvQuote[] = { 11823: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11824: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11825: 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 11826: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11827: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11828: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11829: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11830: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 11831: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11832: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11833: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11834: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11835: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11836: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11837: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11838: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11839: }; 11840: 11841: /* 11842: ** Output a single term of CSV. Actually, p->colSeparator is used for 11843: ** the separator, which may or may not be a comma. p->nullValue is 11844: ** the null value. Strings are quoted if necessary. The separator 11845: ** is only issued if bSep is true. 11846: */ 11847: static void output_csv(ShellState *p, const char *z, int bSep){ 11848: FILE *out = p->out; 11849: if( z==0 ){ 11850: utf8_printf(out,"%s",p->nullValue); 11851: }else{ 11852: int i; 11853: int nSep = strlen30(p->colSeparator); 11854: for(i=0; z[i]; i++){ 11855: if( needCsvQuote[((unsigned char*)z)[i]] 11856: || (z[i]==p->colSeparator[0] && 11857: (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){ 11858: i = 0; 11859: break; 11860: } 11861: } 11862: if( i==0 ){ 11863: char *zQuoted = sqlite3_mprintf("\"%w\"", z); 11864: utf8_printf(out, "%s", zQuoted); 11865: sqlite3_free(zQuoted); 11866: }else{ 11867: utf8_printf(out, "%s", z); 11868: } 11869: } 11870: if( bSep ){ 11871: utf8_printf(p->out, "%s", p->colSeparator); 11872: } 11873: } 11874: 11875: /* 11876: ** This routine runs when the user presses Ctrl-C 11877: */ 11878: static void interrupt_handler(int NotUsed){ 11879: UNUSED_PARAMETER(NotUsed); 11880: seenInterrupt++; 11881: if( seenInterrupt>2 ) exit(1); 11882: if( globalDb ) sqlite3_interrupt(globalDb); 11883: } 11884: 11885: #if (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 11886: /* 11887: ** This routine runs for console events (e.g. Ctrl-C) on Win32 11888: */ 11889: static BOOL WINAPI ConsoleCtrlHandler( 11890: DWORD dwCtrlType /* One of the CTRL_*_EVENT constants */ 11891: ){ 11892: if( dwCtrlType==CTRL_C_EVENT ){ 11893: interrupt_handler(0); 11894: return TRUE; 11895: } 11896: return FALSE; 11897: } 11898: #endif 11899: 11900: #ifndef SQLITE_OMIT_AUTHORIZATION 11901: /* 11902: ** When the ".auth ON" is set, the following authorizer callback is 11903: ** invoked. It always returns SQLITE_OK. 11904: */ 11905: static int shellAuth( 11906: void *pClientData, 11907: int op, 11908: const char *zA1, 11909: const char *zA2, 11910: const char *zA3, 11911: const char *zA4 11912: ){ 11913: ShellState *p = (ShellState*)pClientData; 11914: static const char *azAction[] = { 0, 11915: "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX", 11916: "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW", 11917: "CREATE_TRIGGER", "CREATE_VIEW", "DELETE", 11918: "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX", 11919: "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW", 11920: "DROP_TRIGGER", "DROP_VIEW", "INSERT", 11921: "PRAGMA", "READ", "SELECT", 11922: "TRANSACTION", "UPDATE", "ATTACH", 11923: "DETACH", "ALTER_TABLE", "REINDEX", 11924: "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE", 11925: "FUNCTION", "SAVEPOINT", "RECURSIVE" 11926: }; 11927: int i; 11928: const char *az[4]; 11929: az[0] = zA1; 11930: az[1] = zA2; 11931: az[2] = zA3; 11932: az[3] = zA4; 11933: utf8_printf(p->out, "authorizer: %s", azAction[op]); 11934: for(i=0; i<4; i++){ 11935: raw_printf(p->out, " "); 11936: if( az[i] ){ 11937: output_c_string(p->out, az[i]); 11938: }else{ 11939: raw_printf(p->out, "NULL"); 11940: } 11941: } 11942: raw_printf(p->out, "\n"); 11943: return SQLITE_OK; 11944: } 11945: #endif 11946: 11947: /* 11948: ** Print a schema statement. Part of MODE_Semi and MODE_Pretty output. 11949: ** 11950: ** This routine converts some CREATE TABLE statements for shadow tables 11951: ** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements. 11952: */ 11953: static void printSchemaLine(FILE *out, const char *z, const char *zTail){ 11954: if( z==0 ) return; 11955: if( zTail==0 ) return; 11956: if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){ 11957: utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail); 11958: }else{ 11959: utf8_printf(out, "%s%s", z, zTail); 11960: } 11961: } 11962: static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){ 11963: char c = z[n]; 11964: z[n] = 0; 11965: printSchemaLine(out, z, zTail); 11966: z[n] = c; 11967: } 11968: 11969: /* 11970: ** Return true if string z[] has nothing but whitespace and comments to the 11971: ** end of the first line. 11972: */ 11973: static int wsToEol(const char *z){ 11974: int i; 11975: for(i=0; z[i]; i++){ 11976: if( z[i]=='\n' ) return 1; 11977: if( IsSpace(z[i]) ) continue; 11978: if( z[i]=='-' && z[i+1]=='-' ) return 1; 11979: return 0; 11980: } 11981: return 1; 11982: } 11983: 11984: /* 11985: ** Add a new entry to the EXPLAIN QUERY PLAN data 11986: */ 11987: static void eqp_append(ShellState *p, int iEqpId, int p2, const char *zText){ 11988: EQPGraphRow *pNew; 11989: int nText = strlen30(zText); 11990: if( p->autoEQPtest ){ 11991: utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText); 11992: } 11993: pNew = sqlite3_malloc64( sizeof(*pNew) + nText ); 11994: if( pNew==0 ) shell_out_of_memory(); 11995: pNew->iEqpId = iEqpId; 11996: pNew->iParentId = p2; 11997: memcpy(pNew->zText, zText, nText+1); 11998: pNew->pNext = 0; 11999: if( p->sGraph.pLast ){ 12000: p->sGraph.pLast->pNext = pNew; 12001: }else{ 12002: p->sGraph.pRow = pNew; 12003: } 12004: p->sGraph.pLast = pNew; 12005: } 12006: 12007: /* 12008: ** Free and reset the EXPLAIN QUERY PLAN data that has been collected 12009: ** in p->sGraph. 12010: */ 12011: static void eqp_reset(ShellState *p){ 12012: EQPGraphRow *pRow, *pNext; 12013: for(pRow = p->sGraph.pRow; pRow; pRow = pNext){ 12014: pNext = pRow->pNext; 12015: sqlite3_free(pRow); 12016: } 12017: memset(&p->sGraph, 0, sizeof(p->sGraph)); 12018: } 12019: 12020: /* Return the next EXPLAIN QUERY PLAN line with iEqpId that occurs after 12021: ** pOld, or return the first such line if pOld is NULL 12022: */ 12023: static EQPGraphRow *eqp_next_row(ShellState *p, int iEqpId, EQPGraphRow *pOld){ 12024: EQPGraphRow *pRow = pOld ? pOld->pNext : p->sGraph.pRow; 12025: while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext; 12026: return pRow; 12027: } 12028: 12029: /* Render a single level of the graph that has iEqpId as its parent. Called 12030: ** recursively to render sublevels. 12031: */ 12032: static void eqp_render_level(ShellState *p, int iEqpId){ 12033: EQPGraphRow *pRow, *pNext; 12034: int n = strlen30(p->sGraph.zPrefix); 12035: char *z; 12036: for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){ 12037: pNext = eqp_next_row(p, iEqpId, pRow); 12038: z = pRow->zText; 12039: utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix, 12040: pNext ? "|--" : "`--", z); 12041: if( n<(int)sizeof(p->sGraph.zPrefix)-7 ){ 12042: memcpy(&p->sGraph.zPrefix[n], pNext ? "| " : " ", 4); 12043: eqp_render_level(p, pRow->iEqpId); 12044: p->sGraph.zPrefix[n] = 0; 12045: } 12046: } 12047: } 12048: 12049: /* 12050: ** Display and reset the EXPLAIN QUERY PLAN data 12051: */ 12052: static void eqp_render(ShellState *p){ 12053: EQPGraphRow *pRow = p->sGraph.pRow; 12054: if( pRow ){ 12055: if( pRow->zText[0]=='-' ){ 12056: if( pRow->pNext==0 ){ 12057: eqp_reset(p); 12058: return; 12059: } 12060: utf8_printf(p->out, "%s\n", pRow->zText+3); 12061: p->sGraph.pRow = pRow->pNext; 12062: sqlite3_free(pRow); 12063: }else{ 12064: utf8_printf(p->out, "QUERY PLAN\n"); 12065: } 12066: p->sGraph.zPrefix[0] = 0; 12067: eqp_render_level(p, 0); 12068: eqp_reset(p); 12069: } 12070: } 12071: 12072: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 12073: /* 12074: ** Progress handler callback. 12075: */ 12076: static int progress_handler(void *pClientData) { 12077: ShellState *p = (ShellState*)pClientData; 12078: p->nProgress++; 12079: if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){ 12080: raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress); 12081: if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 12082: if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0; 12083: return 1; 12084: } 12085: if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){ 12086: raw_printf(p->out, "Progress %u\n", p->nProgress); 12087: } 12088: return 0; 12089: } 12090: #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 12091: 12092: /* 12093: ** Print N dashes 12094: */ 12095: static void print_dashes(FILE *out, int N){ 12096: const char zDash[] = "--------------------------------------------------"; 12097: const int nDash = sizeof(zDash) - 1; 12098: while( N>nDash ){ 12099: fputs(zDash, out); 12100: N -= nDash; 12101: } 12102: raw_printf(out, "%.*s", N, zDash); 12103: } 12104: 12105: /* 12106: ** Print a markdown or table-style row separator using ascii-art 12107: */ 12108: static void print_row_separator( 12109: ShellState *p, 12110: int nArg, 12111: const char *zSep 12112: ){ 12113: int i; 12114: if( nArg>0 ){ 12115: fputs(zSep, p->out); 12116: print_dashes(p->out, p->actualWidth[0]+2); 12117: for(i=1; i<nArg; i++){ 12118: fputs(zSep, p->out); 12119: print_dashes(p->out, p->actualWidth[i]+2); 12120: } 12121: fputs(zSep, p->out); 12122: } 12123: fputs("\n", p->out); 12124: } 12125: 12126: /* 12127: ** This is the callback routine that the shell 12128: ** invokes for each row of a query result. 12129: */ 12130: static int shell_callback( 12131: void *pArg, 12132: int nArg, /* Number of result columns */ 12133: char **azArg, /* Text of each result column */ 12134: char **azCol, /* Column names */ 12135: int *aiType /* Column types. Might be NULL */ 12136: ){ 12137: int i; 12138: ShellState *p = (ShellState*)pArg; 12139: 12140: if( azArg==0 ) return 0; 12141: switch( p->cMode ){ 12142: case MODE_Line: { 12143: int w = 5; 12144: if( azArg==0 ) break; 12145: for(i=0; i<nArg; i++){ 12146: int len = strlen30(azCol[i] ? azCol[i] : ""); 12147: if( len>w ) w = len; 12148: } 12149: if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator); 12150: for(i=0; i<nArg; i++){ 12151: utf8_printf(p->out,"%*s = %s%s", w, azCol[i], 12152: azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator); 12153: } 12154: break; 12155: } 12156: case MODE_Explain: { 12157: static const int aExplainWidth[] = {4, 13, 4, 4, 4, 13, 2, 13}; 12158: if( nArg>ArraySize(aExplainWidth) ){ 12159: nArg = ArraySize(aExplainWidth); 12160: } 12161: if( p->cnt++==0 ){ 12162: for(i=0; i<nArg; i++){ 12163: int w = aExplainWidth[i]; 12164: utf8_width_print(p->out, w, azCol[i]); 12165: fputs(i==nArg-1 ? "\n" : " ", p->out); 12166: } 12167: for(i=0; i<nArg; i++){ 12168: int w = aExplainWidth[i]; 12169: print_dashes(p->out, w); 12170: fputs(i==nArg-1 ? "\n" : " ", p->out); 12171: } 12172: } 12173: if( azArg==0 ) break; 12174: for(i=0; i<nArg; i++){ 12175: int w = aExplainWidth[i]; 1.6 ! misho 12176: if( i==nArg-1 ) w = 0; 1.5 misho 12177: if( azArg[i] && strlenChar(azArg[i])>w ){ 12178: w = strlenChar(azArg[i]); 12179: } 12180: if( i==1 && p->aiIndent && p->pStmt ){ 12181: if( p->iIndent<p->nIndent ){ 12182: utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], ""); 12183: } 12184: p->iIndent++; 12185: } 12186: utf8_width_print(p->out, w, azArg[i] ? azArg[i] : p->nullValue); 12187: fputs(i==nArg-1 ? "\n" : " ", p->out); 12188: } 12189: break; 12190: } 12191: case MODE_Semi: { /* .schema and .fullschema output */ 12192: printSchemaLine(p->out, azArg[0], ";\n"); 12193: break; 12194: } 12195: case MODE_Pretty: { /* .schema and .fullschema with --indent */ 12196: char *z; 12197: int j; 12198: int nParen = 0; 12199: char cEnd = 0; 12200: char c; 12201: int nLine = 0; 12202: assert( nArg==1 ); 12203: if( azArg[0]==0 ) break; 12204: if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0 12205: || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0 12206: ){ 12207: utf8_printf(p->out, "%s;\n", azArg[0]); 12208: break; 12209: } 12210: z = sqlite3_mprintf("%s", azArg[0]); 12211: j = 0; 12212: for(i=0; IsSpace(z[i]); i++){} 12213: for(; (c = z[i])!=0; i++){ 12214: if( IsSpace(c) ){ 12215: if( z[j-1]=='\r' ) z[j-1] = '\n'; 12216: if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue; 12217: }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){ 12218: j--; 12219: } 12220: z[j++] = c; 12221: } 12222: while( j>0 && IsSpace(z[j-1]) ){ j--; } 12223: z[j] = 0; 12224: if( strlen30(z)>=79 ){ 12225: for(i=j=0; (c = z[i])!=0; i++){ /* Copy from z[i] back to z[j] */ 12226: if( c==cEnd ){ 12227: cEnd = 0; 12228: }else if( c=='"' || c=='\'' || c=='`' ){ 12229: cEnd = c; 12230: }else if( c=='[' ){ 12231: cEnd = ']'; 12232: }else if( c=='-' && z[i+1]=='-' ){ 12233: cEnd = '\n'; 12234: }else if( c=='(' ){ 12235: nParen++; 12236: }else if( c==')' ){ 12237: nParen--; 12238: if( nLine>0 && nParen==0 && j>0 ){ 12239: printSchemaLineN(p->out, z, j, "\n"); 12240: j = 0; 12241: } 12242: } 12243: z[j++] = c; 12244: if( nParen==1 && cEnd==0 12245: && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1))) 12246: ){ 12247: if( c=='\n' ) j--; 12248: printSchemaLineN(p->out, z, j, "\n "); 12249: j = 0; 12250: nLine++; 12251: while( IsSpace(z[i+1]) ){ i++; } 12252: } 12253: } 12254: z[j] = 0; 12255: } 12256: printSchemaLine(p->out, z, ";\n"); 12257: sqlite3_free(z); 12258: break; 12259: } 12260: case MODE_List: { 12261: if( p->cnt++==0 && p->showHeader ){ 12262: for(i=0; i<nArg; i++){ 12263: utf8_printf(p->out,"%s%s",azCol[i], 12264: i==nArg-1 ? p->rowSeparator : p->colSeparator); 12265: } 12266: } 12267: if( azArg==0 ) break; 12268: for(i=0; i<nArg; i++){ 12269: char *z = azArg[i]; 12270: if( z==0 ) z = p->nullValue; 12271: utf8_printf(p->out, "%s", z); 12272: if( i<nArg-1 ){ 12273: utf8_printf(p->out, "%s", p->colSeparator); 12274: }else{ 12275: utf8_printf(p->out, "%s", p->rowSeparator); 12276: } 12277: } 12278: break; 12279: } 12280: case MODE_Html: { 12281: if( p->cnt++==0 && p->showHeader ){ 12282: raw_printf(p->out,"<TR>"); 12283: for(i=0; i<nArg; i++){ 12284: raw_printf(p->out,"<TH>"); 12285: output_html_string(p->out, azCol[i]); 12286: raw_printf(p->out,"</TH>\n"); 12287: } 12288: raw_printf(p->out,"</TR>\n"); 12289: } 12290: if( azArg==0 ) break; 12291: raw_printf(p->out,"<TR>"); 12292: for(i=0; i<nArg; i++){ 12293: raw_printf(p->out,"<TD>"); 12294: output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 12295: raw_printf(p->out,"</TD>\n"); 12296: } 12297: raw_printf(p->out,"</TR>\n"); 12298: break; 12299: } 12300: case MODE_Tcl: { 12301: if( p->cnt++==0 && p->showHeader ){ 12302: for(i=0; i<nArg; i++){ 12303: output_c_string(p->out,azCol[i] ? azCol[i] : ""); 12304: if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 12305: } 12306: utf8_printf(p->out, "%s", p->rowSeparator); 12307: } 12308: if( azArg==0 ) break; 12309: for(i=0; i<nArg; i++){ 12310: output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue); 12311: if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator); 12312: } 12313: utf8_printf(p->out, "%s", p->rowSeparator); 12314: break; 12315: } 12316: case MODE_Csv: { 12317: setBinaryMode(p->out, 1); 12318: if( p->cnt++==0 && p->showHeader ){ 12319: for(i=0; i<nArg; i++){ 12320: output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1); 12321: } 12322: utf8_printf(p->out, "%s", p->rowSeparator); 12323: } 12324: if( nArg>0 ){ 12325: for(i=0; i<nArg; i++){ 12326: output_csv(p, azArg[i], i<nArg-1); 12327: } 12328: utf8_printf(p->out, "%s", p->rowSeparator); 12329: } 12330: setTextMode(p->out, 1); 12331: break; 12332: } 12333: case MODE_Insert: { 12334: if( azArg==0 ) break; 12335: utf8_printf(p->out,"INSERT INTO %s",p->zDestTable); 12336: if( p->showHeader ){ 12337: raw_printf(p->out,"("); 12338: for(i=0; i<nArg; i++){ 12339: if( i>0 ) raw_printf(p->out, ","); 12340: if( quoteChar(azCol[i]) ){ 12341: char *z = sqlite3_mprintf("\"%w\"", azCol[i]); 12342: utf8_printf(p->out, "%s", z); 12343: sqlite3_free(z); 12344: }else{ 12345: raw_printf(p->out, "%s", azCol[i]); 12346: } 12347: } 12348: raw_printf(p->out,")"); 12349: } 12350: p->cnt++; 12351: for(i=0; i<nArg; i++){ 12352: raw_printf(p->out, i>0 ? "," : " VALUES("); 12353: if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 12354: utf8_printf(p->out,"NULL"); 12355: }else if( aiType && aiType[i]==SQLITE_TEXT ){ 12356: if( ShellHasFlag(p, SHFLG_Newlines) ){ 12357: output_quoted_string(p->out, azArg[i]); 12358: }else{ 12359: output_quoted_escaped_string(p->out, azArg[i]); 12360: } 12361: }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 12362: utf8_printf(p->out,"%s", azArg[i]); 12363: }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 12364: char z[50]; 12365: double r = sqlite3_column_double(p->pStmt, i); 12366: sqlite3_uint64 ur; 12367: memcpy(&ur,&r,sizeof(r)); 12368: if( ur==0x7ff0000000000000LL ){ 12369: raw_printf(p->out, "1e999"); 12370: }else if( ur==0xfff0000000000000LL ){ 12371: raw_printf(p->out, "-1e999"); 12372: }else{ 12373: sqlite3_snprintf(50,z,"%!.20g", r); 12374: raw_printf(p->out, "%s", z); 12375: } 12376: }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 12377: const void *pBlob = sqlite3_column_blob(p->pStmt, i); 12378: int nBlob = sqlite3_column_bytes(p->pStmt, i); 12379: output_hex_blob(p->out, pBlob, nBlob); 12380: }else if( isNumber(azArg[i], 0) ){ 12381: utf8_printf(p->out,"%s", azArg[i]); 12382: }else if( ShellHasFlag(p, SHFLG_Newlines) ){ 12383: output_quoted_string(p->out, azArg[i]); 12384: }else{ 12385: output_quoted_escaped_string(p->out, azArg[i]); 12386: } 12387: } 12388: raw_printf(p->out,");\n"); 12389: break; 12390: } 12391: case MODE_Json: { 12392: if( azArg==0 ) break; 12393: if( p->cnt==0 ){ 12394: fputs("[{", p->out); 12395: }else{ 12396: fputs(",\n{", p->out); 12397: } 12398: p->cnt++; 12399: for(i=0; i<nArg; i++){ 12400: output_json_string(p->out, azCol[i], -1); 12401: putc(':', p->out); 12402: if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 12403: fputs("null",p->out); 12404: }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 12405: char z[50]; 12406: double r = sqlite3_column_double(p->pStmt, i); 12407: sqlite3_uint64 ur; 12408: memcpy(&ur,&r,sizeof(r)); 12409: if( ur==0x7ff0000000000000LL ){ 12410: raw_printf(p->out, "1e999"); 12411: }else if( ur==0xfff0000000000000LL ){ 12412: raw_printf(p->out, "-1e999"); 12413: }else{ 12414: sqlite3_snprintf(50,z,"%!.20g", r); 12415: raw_printf(p->out, "%s", z); 12416: } 12417: }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 12418: const void *pBlob = sqlite3_column_blob(p->pStmt, i); 12419: int nBlob = sqlite3_column_bytes(p->pStmt, i); 12420: output_json_string(p->out, pBlob, nBlob); 12421: }else if( aiType && aiType[i]==SQLITE_TEXT ){ 12422: output_json_string(p->out, azArg[i], -1); 12423: }else{ 12424: utf8_printf(p->out,"%s", azArg[i]); 12425: } 12426: if( i<nArg-1 ){ 12427: putc(',', p->out); 12428: } 12429: } 12430: putc('}', p->out); 12431: break; 12432: } 12433: case MODE_Quote: { 12434: if( azArg==0 ) break; 12435: if( p->cnt==0 && p->showHeader ){ 12436: for(i=0; i<nArg; i++){ 12437: if( i>0 ) fputs(p->colSeparator, p->out); 12438: output_quoted_string(p->out, azCol[i]); 12439: } 12440: fputs(p->rowSeparator, p->out); 12441: } 12442: p->cnt++; 12443: for(i=0; i<nArg; i++){ 12444: if( i>0 ) fputs(p->colSeparator, p->out); 12445: if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ 12446: utf8_printf(p->out,"NULL"); 12447: }else if( aiType && aiType[i]==SQLITE_TEXT ){ 12448: output_quoted_string(p->out, azArg[i]); 12449: }else if( aiType && aiType[i]==SQLITE_INTEGER ){ 12450: utf8_printf(p->out,"%s", azArg[i]); 12451: }else if( aiType && aiType[i]==SQLITE_FLOAT ){ 12452: char z[50]; 12453: double r = sqlite3_column_double(p->pStmt, i); 12454: sqlite3_snprintf(50,z,"%!.20g", r); 12455: raw_printf(p->out, "%s", z); 12456: }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ 12457: const void *pBlob = sqlite3_column_blob(p->pStmt, i); 12458: int nBlob = sqlite3_column_bytes(p->pStmt, i); 12459: output_hex_blob(p->out, pBlob, nBlob); 12460: }else if( isNumber(azArg[i], 0) ){ 12461: utf8_printf(p->out,"%s", azArg[i]); 12462: }else{ 12463: output_quoted_string(p->out, azArg[i]); 12464: } 12465: } 12466: fputs(p->rowSeparator, p->out); 12467: break; 12468: } 12469: case MODE_Ascii: { 12470: if( p->cnt++==0 && p->showHeader ){ 12471: for(i=0; i<nArg; i++){ 12472: if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 12473: utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : ""); 12474: } 12475: utf8_printf(p->out, "%s", p->rowSeparator); 12476: } 12477: if( azArg==0 ) break; 12478: for(i=0; i<nArg; i++){ 12479: if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator); 12480: utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue); 12481: } 12482: utf8_printf(p->out, "%s", p->rowSeparator); 12483: break; 12484: } 12485: case MODE_EQP: { 12486: eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]); 12487: break; 12488: } 12489: } 12490: return 0; 12491: } 12492: 12493: /* 12494: ** This is the callback routine that the SQLite library 12495: ** invokes for each row of a query result. 12496: */ 12497: static int callback(void *pArg, int nArg, char **azArg, char **azCol){ 12498: /* since we don't have type info, call the shell_callback with a NULL value */ 12499: return shell_callback(pArg, nArg, azArg, azCol, NULL); 12500: } 12501: 12502: /* 12503: ** This is the callback routine from sqlite3_exec() that appends all 12504: ** output onto the end of a ShellText object. 12505: */ 12506: static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){ 12507: ShellText *p = (ShellText*)pArg; 12508: int i; 12509: UNUSED_PARAMETER(az); 12510: if( azArg==0 ) return 0; 12511: if( p->n ) appendText(p, "|", 0); 12512: for(i=0; i<nArg; i++){ 12513: if( i ) appendText(p, ",", 0); 12514: if( azArg[i] ) appendText(p, azArg[i], 0); 12515: } 12516: return 0; 12517: } 12518: 12519: /* 12520: ** Generate an appropriate SELFTEST table in the main database. 12521: */ 12522: static void createSelftestTable(ShellState *p){ 12523: char *zErrMsg = 0; 12524: sqlite3_exec(p->db, 12525: "SAVEPOINT selftest_init;\n" 12526: "CREATE TABLE IF NOT EXISTS selftest(\n" 12527: " tno INTEGER PRIMARY KEY,\n" /* Test number */ 12528: " op TEXT,\n" /* Operator: memo run */ 12529: " cmd TEXT,\n" /* Command text */ 12530: " ans TEXT\n" /* Desired answer */ 12531: ");" 12532: "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n" 12533: "INSERT INTO [_shell$self](rowid,op,cmd)\n" 12534: " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n" 12535: " 'memo','Tests generated by --init');\n" 12536: "INSERT INTO [_shell$self]\n" 12537: " SELECT 'run',\n" 12538: " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql " 12539: "FROM sqlite_schema ORDER BY 2'',224))',\n" 12540: " hex(sha3_query('SELECT type,name,tbl_name,sql " 12541: "FROM sqlite_schema ORDER BY 2',224));\n" 12542: "INSERT INTO [_shell$self]\n" 12543: " SELECT 'run'," 12544: " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||" 12545: " printf('%w',name) || '\" NOT INDEXED'',224))',\n" 12546: " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n" 12547: " FROM (\n" 12548: " SELECT name FROM sqlite_schema\n" 12549: " WHERE type='table'\n" 12550: " AND name<>'selftest'\n" 12551: " AND coalesce(rootpage,0)>0\n" 12552: " )\n" 12553: " ORDER BY name;\n" 12554: "INSERT INTO [_shell$self]\n" 12555: " VALUES('run','PRAGMA integrity_check','ok');\n" 12556: "INSERT INTO selftest(tno,op,cmd,ans)" 12557: " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n" 12558: "DROP TABLE [_shell$self];" 12559: ,0,0,&zErrMsg); 12560: if( zErrMsg ){ 12561: utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg); 12562: sqlite3_free(zErrMsg); 12563: } 12564: sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0); 12565: } 12566: 12567: 12568: /* 12569: ** Set the destination table field of the ShellState structure to 12570: ** the name of the table given. Escape any quote characters in the 12571: ** table name. 12572: */ 12573: static void set_table_name(ShellState *p, const char *zName){ 12574: int i, n; 12575: char cQuote; 12576: char *z; 12577: 12578: if( p->zDestTable ){ 12579: free(p->zDestTable); 12580: p->zDestTable = 0; 12581: } 12582: if( zName==0 ) return; 12583: cQuote = quoteChar(zName); 12584: n = strlen30(zName); 12585: if( cQuote ) n += n+2; 12586: z = p->zDestTable = malloc( n+1 ); 12587: if( z==0 ) shell_out_of_memory(); 12588: n = 0; 12589: if( cQuote ) z[n++] = cQuote; 12590: for(i=0; zName[i]; i++){ 12591: z[n++] = zName[i]; 12592: if( zName[i]==cQuote ) z[n++] = cQuote; 12593: } 12594: if( cQuote ) z[n++] = cQuote; 12595: z[n] = 0; 12596: } 12597: 12598: 12599: /* 12600: ** Execute a query statement that will generate SQL output. Print 12601: ** the result columns, comma-separated, on a line and then add a 12602: ** semicolon terminator to the end of that line. 12603: ** 12604: ** If the number of columns is 1 and that column contains text "--" 12605: ** then write the semicolon on a separate line. That way, if a 12606: ** "--" comment occurs at the end of the statement, the comment 12607: ** won't consume the semicolon terminator. 12608: */ 12609: static int run_table_dump_query( 12610: ShellState *p, /* Query context */ 12611: const char *zSelect /* SELECT statement to extract content */ 12612: ){ 12613: sqlite3_stmt *pSelect; 12614: int rc; 12615: int nResult; 12616: int i; 12617: const char *z; 12618: rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0); 12619: if( rc!=SQLITE_OK || !pSelect ){ 12620: utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 12621: sqlite3_errmsg(p->db)); 12622: if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 12623: return rc; 12624: } 12625: rc = sqlite3_step(pSelect); 12626: nResult = sqlite3_column_count(pSelect); 12627: while( rc==SQLITE_ROW ){ 12628: z = (const char*)sqlite3_column_text(pSelect, 0); 12629: utf8_printf(p->out, "%s", z); 12630: for(i=1; i<nResult; i++){ 12631: utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i)); 12632: } 12633: if( z==0 ) z = ""; 12634: while( z[0] && (z[0]!='-' || z[1]!='-') ) z++; 12635: if( z[0] ){ 12636: raw_printf(p->out, "\n;\n"); 12637: }else{ 12638: raw_printf(p->out, ";\n"); 12639: } 12640: rc = sqlite3_step(pSelect); 12641: } 12642: rc = sqlite3_finalize(pSelect); 12643: if( rc!=SQLITE_OK ){ 12644: utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, 12645: sqlite3_errmsg(p->db)); 12646: if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; 12647: } 12648: return rc; 12649: } 12650: 12651: /* 12652: ** Allocate space and save off current error string. 12653: */ 12654: static char *save_err_msg( 12655: sqlite3 *db /* Database to query */ 12656: ){ 12657: int nErrMsg = 1+strlen30(sqlite3_errmsg(db)); 12658: char *zErrMsg = sqlite3_malloc64(nErrMsg); 12659: if( zErrMsg ){ 12660: memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg); 12661: } 12662: return zErrMsg; 12663: } 12664: 12665: #ifdef __linux__ 12666: /* 12667: ** Attempt to display I/O stats on Linux using /proc/PID/io 12668: */ 12669: static void displayLinuxIoStats(FILE *out){ 12670: FILE *in; 12671: char z[200]; 12672: sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid()); 12673: in = fopen(z, "rb"); 12674: if( in==0 ) return; 12675: while( fgets(z, sizeof(z), in)!=0 ){ 12676: static const struct { 12677: const char *zPattern; 12678: const char *zDesc; 12679: } aTrans[] = { 12680: { "rchar: ", "Bytes received by read():" }, 12681: { "wchar: ", "Bytes sent to write():" }, 12682: { "syscr: ", "Read() system calls:" }, 12683: { "syscw: ", "Write() system calls:" }, 12684: { "read_bytes: ", "Bytes read from storage:" }, 12685: { "write_bytes: ", "Bytes written to storage:" }, 12686: { "cancelled_write_bytes: ", "Cancelled write bytes:" }, 12687: }; 12688: int i; 12689: for(i=0; i<ArraySize(aTrans); i++){ 12690: int n = strlen30(aTrans[i].zPattern); 12691: if( strncmp(aTrans[i].zPattern, z, n)==0 ){ 12692: utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]); 12693: break; 12694: } 12695: } 12696: } 12697: fclose(in); 12698: } 12699: #endif 12700: 12701: /* 12702: ** Display a single line of status using 64-bit values. 12703: */ 12704: static void displayStatLine( 12705: ShellState *p, /* The shell context */ 12706: char *zLabel, /* Label for this one line */ 12707: char *zFormat, /* Format for the result */ 12708: int iStatusCtrl, /* Which status to display */ 12709: int bReset /* True to reset the stats */ 12710: ){ 12711: sqlite3_int64 iCur = -1; 12712: sqlite3_int64 iHiwtr = -1; 12713: int i, nPercent; 12714: char zLine[200]; 12715: sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset); 12716: for(i=0, nPercent=0; zFormat[i]; i++){ 12717: if( zFormat[i]=='%' ) nPercent++; 12718: } 12719: if( nPercent>1 ){ 12720: sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr); 12721: }else{ 12722: sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr); 12723: } 12724: raw_printf(p->out, "%-36s %s\n", zLabel, zLine); 12725: } 12726: 12727: /* 12728: ** Display memory stats. 12729: */ 12730: static int display_stats( 12731: sqlite3 *db, /* Database to query */ 12732: ShellState *pArg, /* Pointer to ShellState */ 12733: int bReset /* True to reset the stats */ 12734: ){ 12735: int iCur; 12736: int iHiwtr; 12737: FILE *out; 12738: if( pArg==0 || pArg->out==0 ) return 0; 12739: out = pArg->out; 12740: 1.6 ! misho 12741: if( pArg->pStmt && pArg->statsOn==2 ){ 1.5 misho 12742: int nCol, i, x; 12743: sqlite3_stmt *pStmt = pArg->pStmt; 12744: char z[100]; 12745: nCol = sqlite3_column_count(pStmt); 12746: raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol); 12747: for(i=0; i<nCol; i++){ 12748: sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x); 12749: utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i)); 12750: #ifndef SQLITE_OMIT_DECLTYPE 12751: sqlite3_snprintf(30, z+x, "declared type:"); 12752: utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i)); 12753: #endif 12754: #ifdef SQLITE_ENABLE_COLUMN_METADATA 12755: sqlite3_snprintf(30, z+x, "database name:"); 12756: utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i)); 12757: sqlite3_snprintf(30, z+x, "table name:"); 12758: utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i)); 12759: sqlite3_snprintf(30, z+x, "origin name:"); 12760: utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i)); 12761: #endif 12762: } 12763: } 12764: 1.6 ! misho 12765: if( pArg->statsOn==3 ){ ! 12766: if( pArg->pStmt ){ ! 12767: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset); ! 12768: raw_printf(pArg->out, "VM-steps: %d\n", iCur); ! 12769: } ! 12770: return 0; ! 12771: } ! 12772: 1.5 misho 12773: displayStatLine(pArg, "Memory Used:", 12774: "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset); 12775: displayStatLine(pArg, "Number of Outstanding Allocations:", 12776: "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset); 12777: if( pArg->shellFlgs & SHFLG_Pagecache ){ 12778: displayStatLine(pArg, "Number of Pcache Pages Used:", 12779: "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset); 12780: } 12781: displayStatLine(pArg, "Number of Pcache Overflow Bytes:", 12782: "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset); 12783: displayStatLine(pArg, "Largest Allocation:", 12784: "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset); 12785: displayStatLine(pArg, "Largest Pcache Allocation:", 12786: "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset); 12787: #ifdef YYTRACKMAXSTACKDEPTH 12788: displayStatLine(pArg, "Deepest Parser Stack:", 12789: "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset); 12790: #endif 12791: 12792: if( db ){ 12793: if( pArg->shellFlgs & SHFLG_Lookaside ){ 12794: iHiwtr = iCur = -1; 12795: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, 12796: &iCur, &iHiwtr, bReset); 12797: raw_printf(pArg->out, 12798: "Lookaside Slots Used: %d (max %d)\n", 12799: iCur, iHiwtr); 12800: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, 12801: &iCur, &iHiwtr, bReset); 12802: raw_printf(pArg->out, "Successful lookaside attempts: %d\n", 12803: iHiwtr); 12804: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, 12805: &iCur, &iHiwtr, bReset); 12806: raw_printf(pArg->out, "Lookaside failures due to size: %d\n", 12807: iHiwtr); 12808: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, 12809: &iCur, &iHiwtr, bReset); 12810: raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n", 12811: iHiwtr); 12812: } 12813: iHiwtr = iCur = -1; 12814: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset); 12815: raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n", 12816: iCur); 12817: iHiwtr = iCur = -1; 12818: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1); 12819: raw_printf(pArg->out, "Page cache hits: %d\n", iCur); 12820: iHiwtr = iCur = -1; 12821: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1); 12822: raw_printf(pArg->out, "Page cache misses: %d\n", iCur); 12823: iHiwtr = iCur = -1; 12824: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1); 12825: raw_printf(pArg->out, "Page cache writes: %d\n", iCur); 12826: iHiwtr = iCur = -1; 12827: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1); 12828: raw_printf(pArg->out, "Page cache spills: %d\n", iCur); 12829: iHiwtr = iCur = -1; 12830: sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset); 12831: raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n", 12832: iCur); 12833: iHiwtr = iCur = -1; 12834: sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset); 12835: raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n", 12836: iCur); 12837: } 12838: 12839: if( pArg->pStmt ){ 12840: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, 12841: bReset); 12842: raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur); 12843: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset); 12844: raw_printf(pArg->out, "Sort Operations: %d\n", iCur); 12845: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset); 12846: raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur); 12847: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset); 12848: raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur); 12849: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset); 12850: raw_printf(pArg->out, "Reprepare operations: %d\n", iCur); 12851: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset); 12852: raw_printf(pArg->out, "Number of times run: %d\n", iCur); 12853: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset); 12854: raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur); 12855: } 12856: 12857: #ifdef __linux__ 12858: displayLinuxIoStats(pArg->out); 12859: #endif 12860: 12861: /* Do not remove this machine readable comment: extra-stats-output-here */ 12862: 12863: return 0; 12864: } 12865: 12866: /* 12867: ** Display scan stats. 12868: */ 12869: static void display_scanstats( 12870: sqlite3 *db, /* Database to query */ 12871: ShellState *pArg /* Pointer to ShellState */ 12872: ){ 12873: #ifndef SQLITE_ENABLE_STMT_SCANSTATUS 12874: UNUSED_PARAMETER(db); 12875: UNUSED_PARAMETER(pArg); 12876: #else 12877: int i, k, n, mx; 12878: raw_printf(pArg->out, "-------- scanstats --------\n"); 12879: mx = 0; 12880: for(k=0; k<=mx; k++){ 12881: double rEstLoop = 1.0; 12882: for(i=n=0; 1; i++){ 12883: sqlite3_stmt *p = pArg->pStmt; 12884: sqlite3_int64 nLoop, nVisit; 12885: double rEst; 12886: int iSid; 12887: const char *zExplain; 12888: if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){ 12889: break; 12890: } 12891: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid); 12892: if( iSid>mx ) mx = iSid; 12893: if( iSid!=k ) continue; 12894: if( n==0 ){ 12895: rEstLoop = (double)nLoop; 12896: if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k); 12897: } 12898: n++; 12899: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit); 12900: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst); 12901: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain); 12902: utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain); 12903: rEstLoop *= rEst; 12904: raw_printf(pArg->out, 12905: " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n", 12906: nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst 12907: ); 12908: } 12909: } 12910: raw_printf(pArg->out, "---------------------------\n"); 12911: #endif 12912: } 12913: 12914: /* 12915: ** Parameter azArray points to a zero-terminated array of strings. zStr 12916: ** points to a single nul-terminated string. Return non-zero if zStr 12917: ** is equal, according to strcmp(), to any of the strings in the array. 12918: ** Otherwise, return zero. 12919: */ 12920: static int str_in_array(const char *zStr, const char **azArray){ 12921: int i; 12922: for(i=0; azArray[i]; i++){ 12923: if( 0==strcmp(zStr, azArray[i]) ) return 1; 12924: } 12925: return 0; 12926: } 12927: 12928: /* 12929: ** If compiled statement pSql appears to be an EXPLAIN statement, allocate 12930: ** and populate the ShellState.aiIndent[] array with the number of 12931: ** spaces each opcode should be indented before it is output. 12932: ** 12933: ** The indenting rules are: 12934: ** 12935: ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent 12936: ** all opcodes that occur between the p2 jump destination and the opcode 12937: ** itself by 2 spaces. 12938: ** 12939: ** * For each "Goto", if the jump destination is earlier in the program 12940: ** and ends on one of: 12941: ** Yield SeekGt SeekLt RowSetRead Rewind 12942: ** or if the P1 parameter is one instead of zero, 12943: ** then indent all opcodes between the earlier instruction 12944: ** and "Goto" by 2 spaces. 12945: */ 12946: static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){ 12947: const char *zSql; /* The text of the SQL statement */ 12948: const char *z; /* Used to check if this is an EXPLAIN */ 12949: int *abYield = 0; /* True if op is an OP_Yield */ 12950: int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */ 12951: int iOp; /* Index of operation in p->aiIndent[] */ 12952: 12953: const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 }; 12954: const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead", 12955: "Rewind", 0 }; 12956: const char *azGoto[] = { "Goto", 0 }; 12957: 12958: /* Try to figure out if this is really an EXPLAIN statement. If this 12959: ** cannot be verified, return early. */ 12960: if( sqlite3_column_count(pSql)!=8 ){ 12961: p->cMode = p->mode; 12962: return; 12963: } 12964: zSql = sqlite3_sql(pSql); 12965: if( zSql==0 ) return; 12966: for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++); 12967: if( sqlite3_strnicmp(z, "explain", 7) ){ 12968: p->cMode = p->mode; 12969: return; 12970: } 12971: 12972: for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){ 12973: int i; 12974: int iAddr = sqlite3_column_int(pSql, 0); 12975: const char *zOp = (const char*)sqlite3_column_text(pSql, 1); 12976: 12977: /* Set p2 to the P2 field of the current opcode. Then, assuming that 12978: ** p2 is an instruction address, set variable p2op to the index of that 12979: ** instruction in the aiIndent[] array. p2 and p2op may be different if 12980: ** the current instruction is part of a sub-program generated by an 12981: ** SQL trigger or foreign key. */ 12982: int p2 = sqlite3_column_int(pSql, 3); 12983: int p2op = (p2 + (iOp-iAddr)); 12984: 12985: /* Grow the p->aiIndent array as required */ 12986: if( iOp>=nAlloc ){ 12987: if( iOp==0 ){ 12988: /* Do further verfication that this is explain output. Abort if 12989: ** it is not */ 12990: static const char *explainCols[] = { 12991: "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" }; 12992: int jj; 12993: for(jj=0; jj<ArraySize(explainCols); jj++){ 12994: if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){ 12995: p->cMode = p->mode; 12996: sqlite3_reset(pSql); 12997: return; 12998: } 12999: } 13000: } 13001: nAlloc += 100; 13002: p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int)); 13003: if( p->aiIndent==0 ) shell_out_of_memory(); 13004: abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int)); 13005: if( abYield==0 ) shell_out_of_memory(); 13006: } 13007: abYield[iOp] = str_in_array(zOp, azYield); 13008: p->aiIndent[iOp] = 0; 13009: p->nIndent = iOp+1; 13010: 13011: if( str_in_array(zOp, azNext) ){ 13012: for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 13013: } 13014: if( str_in_array(zOp, azGoto) && p2op<p->nIndent 13015: && (abYield[p2op] || sqlite3_column_int(pSql, 2)) 13016: ){ 13017: for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2; 13018: } 13019: } 13020: 13021: p->iIndent = 0; 13022: sqlite3_free(abYield); 13023: sqlite3_reset(pSql); 13024: } 13025: 13026: /* 13027: ** Free the array allocated by explain_data_prepare(). 13028: */ 13029: static void explain_data_delete(ShellState *p){ 13030: sqlite3_free(p->aiIndent); 13031: p->aiIndent = 0; 13032: p->nIndent = 0; 13033: p->iIndent = 0; 13034: } 13035: 13036: /* 13037: ** Disable and restore .wheretrace and .selecttrace settings. 13038: */ 1.6 ! misho 13039: static unsigned int savedSelectTrace; ! 13040: static unsigned int savedWhereTrace; 1.5 misho 13041: static void disable_debug_trace_modes(void){ 1.6 ! misho 13042: unsigned int zero = 0; ! 13043: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 0, &savedSelectTrace); ! 13044: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &zero); ! 13045: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 2, &savedWhereTrace); ! 13046: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &zero); 1.5 misho 13047: } 13048: static void restore_debug_trace_modes(void){ 1.6 ! misho 13049: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &savedSelectTrace); ! 13050: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &savedWhereTrace); 1.5 misho 13051: } 13052: 13053: /* Create the TEMP table used to store parameter bindings */ 13054: static void bind_table_init(ShellState *p){ 13055: int wrSchema = 0; 13056: int defensiveMode = 0; 13057: sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, -1, &defensiveMode); 13058: sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 0, 0); 13059: sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema); 13060: sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0); 13061: sqlite3_exec(p->db, 13062: "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n" 13063: " key TEXT PRIMARY KEY,\n" 13064: " value ANY\n" 13065: ") WITHOUT ROWID;", 13066: 0, 0, 0); 13067: sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0); 13068: sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, defensiveMode, 0); 13069: } 13070: 13071: /* 13072: ** Bind parameters on a prepared statement. 13073: ** 13074: ** Parameter bindings are taken from a TEMP table of the form: 13075: ** 13076: ** CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value) 13077: ** WITHOUT ROWID; 13078: ** 13079: ** No bindings occur if this table does not exist. The name of the table 13080: ** begins with "sqlite_" so that it will not collide with ordinary application 13081: ** tables. The table must be in the TEMP schema. 13082: */ 13083: static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){ 13084: int nVar; 13085: int i; 13086: int rc; 13087: sqlite3_stmt *pQ = 0; 13088: 13089: nVar = sqlite3_bind_parameter_count(pStmt); 13090: if( nVar==0 ) return; /* Nothing to do */ 13091: if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters", 13092: "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){ 13093: return; /* Parameter table does not exist */ 13094: } 13095: rc = sqlite3_prepare_v2(pArg->db, 13096: "SELECT value FROM temp.sqlite_parameters" 13097: " WHERE key=?1", -1, &pQ, 0); 13098: if( rc || pQ==0 ) return; 13099: for(i=1; i<=nVar; i++){ 13100: char zNum[30]; 13101: const char *zVar = sqlite3_bind_parameter_name(pStmt, i); 13102: if( zVar==0 ){ 13103: sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i); 13104: zVar = zNum; 13105: } 13106: sqlite3_bind_text(pQ, 1, zVar, -1, SQLITE_STATIC); 13107: if( sqlite3_step(pQ)==SQLITE_ROW ){ 13108: sqlite3_bind_value(pStmt, i, sqlite3_column_value(pQ, 0)); 13109: }else{ 13110: sqlite3_bind_null(pStmt, i); 13111: } 13112: sqlite3_reset(pQ); 13113: } 13114: sqlite3_finalize(pQ); 13115: } 13116: 13117: /* 13118: ** UTF8 box-drawing characters. Imagine box lines like this: 13119: ** 13120: ** 1 13121: ** | 13122: ** 4 --+-- 2 13123: ** | 13124: ** 3 13125: ** 13126: ** Each box characters has between 2 and 4 of the lines leading from 13127: ** the center. The characters are here identified by the numbers of 13128: ** their corresponding lines. 13129: */ 13130: #define BOX_24 "\342\224\200" /* U+2500 --- */ 13131: #define BOX_13 "\342\224\202" /* U+2502 | */ 13132: #define BOX_23 "\342\224\214" /* U+250c ,- */ 13133: #define BOX_34 "\342\224\220" /* U+2510 -, */ 13134: #define BOX_12 "\342\224\224" /* U+2514 '- */ 13135: #define BOX_14 "\342\224\230" /* U+2518 -' */ 13136: #define BOX_123 "\342\224\234" /* U+251c |- */ 13137: #define BOX_134 "\342\224\244" /* U+2524 -| */ 13138: #define BOX_234 "\342\224\254" /* U+252c -,- */ 13139: #define BOX_124 "\342\224\264" /* U+2534 -'- */ 13140: #define BOX_1234 "\342\224\274" /* U+253c -|- */ 13141: 13142: /* Draw horizontal line N characters long using unicode box 13143: ** characters 13144: */ 13145: static void print_box_line(FILE *out, int N){ 13146: const char zDash[] = 13147: BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 13148: BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24; 13149: const int nDash = sizeof(zDash) - 1; 13150: N *= 3; 13151: while( N>nDash ){ 13152: utf8_printf(out, zDash); 13153: N -= nDash; 13154: } 13155: utf8_printf(out, "%.*s", N, zDash); 13156: } 13157: 13158: /* 13159: ** Draw a horizontal separator for a MODE_Box table. 13160: */ 13161: static void print_box_row_separator( 13162: ShellState *p, 13163: int nArg, 13164: const char *zSep1, 13165: const char *zSep2, 13166: const char *zSep3 13167: ){ 13168: int i; 13169: if( nArg>0 ){ 13170: utf8_printf(p->out, "%s", zSep1); 13171: print_box_line(p->out, p->actualWidth[0]+2); 13172: for(i=1; i<nArg; i++){ 13173: utf8_printf(p->out, "%s", zSep2); 13174: print_box_line(p->out, p->actualWidth[i]+2); 13175: } 13176: utf8_printf(p->out, "%s", zSep3); 13177: } 13178: fputs("\n", p->out); 13179: } 13180: 13181: 13182: 13183: /* 13184: ** Run a prepared statement and output the result in one of the 13185: ** table-oriented formats: MODE_Column, MODE_Markdown, MODE_Table, 13186: ** or MODE_Box. 13187: ** 13188: ** This is different from ordinary exec_prepared_stmt() in that 13189: ** it has to run the entire query and gather the results into memory 13190: ** first, in order to determine column widths, before providing 13191: ** any output. 13192: */ 13193: static void exec_prepared_stmt_columnar( 13194: ShellState *p, /* Pointer to ShellState */ 13195: sqlite3_stmt *pStmt /* Statment to run */ 13196: ){ 13197: sqlite3_int64 nRow = 0; 13198: int nColumn = 0; 13199: char **azData = 0; 13200: sqlite3_int64 nAlloc = 0; 13201: const char *z; 13202: int rc; 13203: sqlite3_int64 i, nData; 13204: int j, nTotal, w, n; 13205: const char *colSep = 0; 13206: const char *rowSep = 0; 13207: 13208: rc = sqlite3_step(pStmt); 13209: if( rc!=SQLITE_ROW ) return; 13210: nColumn = sqlite3_column_count(pStmt); 13211: nAlloc = nColumn*4; 13212: azData = sqlite3_malloc64( nAlloc*sizeof(char*) ); 13213: if( azData==0 ) shell_out_of_memory(); 13214: for(i=0; i<nColumn; i++){ 13215: azData[i] = strdup(sqlite3_column_name(pStmt,i)); 13216: } 13217: do{ 13218: if( (nRow+2)*nColumn >= nAlloc ){ 13219: nAlloc *= 2; 13220: azData = sqlite3_realloc64(azData, nAlloc*sizeof(char*)); 13221: if( azData==0 ) shell_out_of_memory(); 13222: } 13223: nRow++; 13224: for(i=0; i<nColumn; i++){ 13225: z = (const char*)sqlite3_column_text(pStmt,i); 13226: azData[nRow*nColumn + i] = z ? strdup(z) : 0; 13227: } 13228: }while( (rc = sqlite3_step(pStmt))==SQLITE_ROW ); 13229: if( nColumn>p->nWidth ){ 13230: p->colWidth = realloc(p->colWidth, nColumn*2*sizeof(int)); 13231: if( p->colWidth==0 ) shell_out_of_memory(); 13232: for(i=p->nWidth; i<nColumn; i++) p->colWidth[i] = 0; 13233: p->nWidth = nColumn; 13234: p->actualWidth = &p->colWidth[nColumn]; 13235: } 13236: memset(p->actualWidth, 0, nColumn*sizeof(int)); 13237: for(i=0; i<nColumn; i++){ 13238: w = p->colWidth[i]; 13239: if( w<0 ) w = -w; 13240: p->actualWidth[i] = w; 13241: } 13242: nTotal = nColumn*(nRow+1); 13243: for(i=0; i<nTotal; i++){ 13244: z = azData[i]; 13245: if( z==0 ) z = p->nullValue; 13246: n = strlenChar(z); 13247: j = i%nColumn; 13248: if( n>p->actualWidth[j] ) p->actualWidth[j] = n; 13249: } 13250: if( seenInterrupt ) goto columnar_end; 13251: switch( p->cMode ){ 13252: case MODE_Column: { 13253: colSep = " "; 13254: rowSep = "\n"; 13255: if( p->showHeader ){ 13256: for(i=0; i<nColumn; i++){ 13257: w = p->actualWidth[i]; 13258: if( p->colWidth[i]<0 ) w = -w; 13259: utf8_width_print(p->out, w, azData[i]); 13260: fputs(i==nColumn-1?"\n":" ", p->out); 13261: } 13262: for(i=0; i<nColumn; i++){ 13263: print_dashes(p->out, p->actualWidth[i]); 13264: fputs(i==nColumn-1?"\n":" ", p->out); 13265: } 13266: } 13267: break; 13268: } 13269: case MODE_Table: { 13270: colSep = " | "; 13271: rowSep = " |\n"; 13272: print_row_separator(p, nColumn, "+"); 13273: fputs("| ", p->out); 13274: for(i=0; i<nColumn; i++){ 13275: w = p->actualWidth[i]; 13276: n = strlenChar(azData[i]); 13277: utf8_printf(p->out, "%*s%s%*s", (w-n)/2, "", azData[i], (w-n+1)/2, ""); 13278: fputs(i==nColumn-1?" |\n":" | ", p->out); 13279: } 13280: print_row_separator(p, nColumn, "+"); 13281: break; 13282: } 13283: case MODE_Markdown: { 13284: colSep = " | "; 13285: rowSep = " |\n"; 13286: fputs("| ", p->out); 13287: for(i=0; i<nColumn; i++){ 13288: w = p->actualWidth[i]; 13289: n = strlenChar(azData[i]); 13290: utf8_printf(p->out, "%*s%s%*s", (w-n)/2, "", azData[i], (w-n+1)/2, ""); 13291: fputs(i==nColumn-1?" |\n":" | ", p->out); 13292: } 13293: print_row_separator(p, nColumn, "|"); 13294: break; 13295: } 13296: case MODE_Box: { 13297: colSep = " " BOX_13 " "; 13298: rowSep = " " BOX_13 "\n"; 13299: print_box_row_separator(p, nColumn, BOX_23, BOX_234, BOX_34); 13300: utf8_printf(p->out, BOX_13 " "); 13301: for(i=0; i<nColumn; i++){ 13302: w = p->actualWidth[i]; 13303: n = strlenChar(azData[i]); 13304: utf8_printf(p->out, "%*s%s%*s%s", 13305: (w-n)/2, "", azData[i], (w-n+1)/2, "", 13306: i==nColumn-1?" "BOX_13"\n":" "BOX_13" "); 13307: } 13308: print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134); 13309: break; 13310: } 13311: } 13312: for(i=nColumn, j=0; i<nTotal; i++, j++){ 13313: if( j==0 && p->cMode!=MODE_Column ){ 13314: utf8_printf(p->out, "%s", p->cMode==MODE_Box?BOX_13" ":"| "); 13315: } 13316: z = azData[i]; 13317: if( z==0 ) z = p->nullValue; 13318: w = p->actualWidth[j]; 13319: if( p->colWidth[j]<0 ) w = -w; 13320: utf8_width_print(p->out, w, z); 13321: if( j==nColumn-1 ){ 13322: utf8_printf(p->out, "%s", rowSep); 13323: j = -1; 13324: if( seenInterrupt ) goto columnar_end; 13325: }else{ 13326: utf8_printf(p->out, "%s", colSep); 13327: } 13328: } 13329: if( p->cMode==MODE_Table ){ 13330: print_row_separator(p, nColumn, "+"); 13331: }else if( p->cMode==MODE_Box ){ 13332: print_box_row_separator(p, nColumn, BOX_12, BOX_124, BOX_14); 13333: } 13334: columnar_end: 13335: if( seenInterrupt ){ 13336: utf8_printf(p->out, "Interrupt\n"); 13337: } 13338: nData = (nRow+1)*nColumn; 13339: for(i=0; i<nData; i++) free(azData[i]); 13340: sqlite3_free(azData); 13341: } 13342: 13343: /* 13344: ** Run a prepared statement 13345: */ 13346: static void exec_prepared_stmt( 13347: ShellState *pArg, /* Pointer to ShellState */ 13348: sqlite3_stmt *pStmt /* Statment to run */ 13349: ){ 13350: int rc; 13351: 13352: if( pArg->cMode==MODE_Column 13353: || pArg->cMode==MODE_Table 13354: || pArg->cMode==MODE_Box 13355: || pArg->cMode==MODE_Markdown 13356: ){ 13357: exec_prepared_stmt_columnar(pArg, pStmt); 13358: return; 13359: } 13360: 13361: /* perform the first step. this will tell us if we 13362: ** have a result set or not and how wide it is. 13363: */ 13364: rc = sqlite3_step(pStmt); 13365: /* if we have a result set... */ 13366: if( SQLITE_ROW == rc ){ 13367: /* allocate space for col name ptr, value ptr, and type */ 13368: int nCol = sqlite3_column_count(pStmt); 13369: void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1); 13370: if( !pData ){ 13371: rc = SQLITE_NOMEM; 13372: }else{ 13373: char **azCols = (char **)pData; /* Names of result columns */ 13374: char **azVals = &azCols[nCol]; /* Results */ 13375: int *aiTypes = (int *)&azVals[nCol]; /* Result types */ 13376: int i, x; 13377: assert(sizeof(int) <= sizeof(char *)); 13378: /* save off ptrs to column names */ 13379: for(i=0; i<nCol; i++){ 13380: azCols[i] = (char *)sqlite3_column_name(pStmt, i); 13381: } 13382: do{ 13383: /* extract the data and data types */ 13384: for(i=0; i<nCol; i++){ 13385: aiTypes[i] = x = sqlite3_column_type(pStmt, i); 13386: if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){ 13387: azVals[i] = ""; 13388: }else{ 13389: azVals[i] = (char*)sqlite3_column_text(pStmt, i); 13390: } 13391: if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){ 13392: rc = SQLITE_NOMEM; 13393: break; /* from for */ 13394: } 13395: } /* end for */ 13396: 13397: /* if data and types extracted successfully... */ 13398: if( SQLITE_ROW == rc ){ 13399: /* call the supplied callback with the result row data */ 13400: if( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){ 13401: rc = SQLITE_ABORT; 13402: }else{ 13403: rc = sqlite3_step(pStmt); 13404: } 13405: } 13406: } while( SQLITE_ROW == rc ); 13407: sqlite3_free(pData); 13408: if( pArg->cMode==MODE_Json ){ 13409: fputs("]\n", pArg->out); 13410: } 13411: } 13412: } 13413: } 13414: 13415: #ifndef SQLITE_OMIT_VIRTUALTABLE 13416: /* 13417: ** This function is called to process SQL if the previous shell command 13418: ** was ".expert". It passes the SQL in the second argument directly to 13419: ** the sqlite3expert object. 13420: ** 13421: ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 13422: ** code. In this case, (*pzErr) may be set to point to a buffer containing 13423: ** an English language error message. It is the responsibility of the 13424: ** caller to eventually free this buffer using sqlite3_free(). 13425: */ 13426: static int expertHandleSQL( 13427: ShellState *pState, 13428: const char *zSql, 13429: char **pzErr 13430: ){ 13431: assert( pState->expert.pExpert ); 13432: assert( pzErr==0 || *pzErr==0 ); 13433: return sqlite3_expert_sql(pState->expert.pExpert, zSql, pzErr); 13434: } 13435: 13436: /* 13437: ** This function is called either to silently clean up the object 13438: ** created by the ".expert" command (if bCancel==1), or to generate a 13439: ** report from it and then clean it up (if bCancel==0). 13440: ** 13441: ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error 13442: ** code. In this case, (*pzErr) may be set to point to a buffer containing 13443: ** an English language error message. It is the responsibility of the 13444: ** caller to eventually free this buffer using sqlite3_free(). 13445: */ 13446: static int expertFinish( 13447: ShellState *pState, 13448: int bCancel, 13449: char **pzErr 13450: ){ 13451: int rc = SQLITE_OK; 13452: sqlite3expert *p = pState->expert.pExpert; 13453: assert( p ); 13454: assert( bCancel || pzErr==0 || *pzErr==0 ); 13455: if( bCancel==0 ){ 13456: FILE *out = pState->out; 13457: int bVerbose = pState->expert.bVerbose; 13458: 13459: rc = sqlite3_expert_analyze(p, pzErr); 13460: if( rc==SQLITE_OK ){ 13461: int nQuery = sqlite3_expert_count(p); 13462: int i; 13463: 13464: if( bVerbose ){ 13465: const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES); 13466: raw_printf(out, "-- Candidates -----------------------------\n"); 13467: raw_printf(out, "%s\n", zCand); 13468: } 13469: for(i=0; i<nQuery; i++){ 13470: const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL); 13471: const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES); 13472: const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN); 13473: if( zIdx==0 ) zIdx = "(no new indexes)\n"; 13474: if( bVerbose ){ 13475: raw_printf(out, "-- Query %d --------------------------------\n",i+1); 13476: raw_printf(out, "%s\n\n", zSql); 13477: } 13478: raw_printf(out, "%s\n", zIdx); 13479: raw_printf(out, "%s\n", zEQP); 13480: } 13481: } 13482: } 13483: sqlite3_expert_destroy(p); 13484: pState->expert.pExpert = 0; 13485: return rc; 13486: } 13487: 13488: /* 13489: ** Implementation of ".expert" dot command. 13490: */ 13491: static int expertDotCommand( 13492: ShellState *pState, /* Current shell tool state */ 13493: char **azArg, /* Array of arguments passed to dot command */ 13494: int nArg /* Number of entries in azArg[] */ 13495: ){ 13496: int rc = SQLITE_OK; 13497: char *zErr = 0; 13498: int i; 13499: int iSample = 0; 13500: 13501: assert( pState->expert.pExpert==0 ); 13502: memset(&pState->expert, 0, sizeof(ExpertInfo)); 13503: 13504: for(i=1; rc==SQLITE_OK && i<nArg; i++){ 13505: char *z = azArg[i]; 13506: int n; 13507: if( z[0]=='-' && z[1]=='-' ) z++; 13508: n = strlen30(z); 13509: if( n>=2 && 0==strncmp(z, "-verbose", n) ){ 13510: pState->expert.bVerbose = 1; 13511: } 13512: else if( n>=2 && 0==strncmp(z, "-sample", n) ){ 13513: if( i==(nArg-1) ){ 13514: raw_printf(stderr, "option requires an argument: %s\n", z); 13515: rc = SQLITE_ERROR; 13516: }else{ 13517: iSample = (int)integerValue(azArg[++i]); 13518: if( iSample<0 || iSample>100 ){ 13519: raw_printf(stderr, "value out of range: %s\n", azArg[i]); 13520: rc = SQLITE_ERROR; 13521: } 13522: } 13523: } 13524: else{ 13525: raw_printf(stderr, "unknown option: %s\n", z); 13526: rc = SQLITE_ERROR; 13527: } 13528: } 13529: 13530: if( rc==SQLITE_OK ){ 13531: pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr); 13532: if( pState->expert.pExpert==0 ){ 13533: raw_printf(stderr, "sqlite3_expert_new: %s\n", zErr); 13534: rc = SQLITE_ERROR; 13535: }else{ 13536: sqlite3_expert_config( 13537: pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample 13538: ); 13539: } 13540: } 13541: 13542: return rc; 13543: } 13544: #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ 13545: 13546: /* 13547: ** Execute a statement or set of statements. Print 13548: ** any result rows/columns depending on the current mode 13549: ** set via the supplied callback. 13550: ** 13551: ** This is very similar to SQLite's built-in sqlite3_exec() 13552: ** function except it takes a slightly different callback 13553: ** and callback data argument. 13554: */ 13555: static int shell_exec( 13556: ShellState *pArg, /* Pointer to ShellState */ 13557: const char *zSql, /* SQL to be evaluated */ 13558: char **pzErrMsg /* Error msg written here */ 13559: ){ 13560: sqlite3_stmt *pStmt = NULL; /* Statement to execute. */ 13561: int rc = SQLITE_OK; /* Return Code */ 13562: int rc2; 13563: const char *zLeftover; /* Tail of unprocessed SQL */ 13564: sqlite3 *db = pArg->db; 13565: 13566: if( pzErrMsg ){ 13567: *pzErrMsg = NULL; 13568: } 13569: 13570: #ifndef SQLITE_OMIT_VIRTUALTABLE 13571: if( pArg->expert.pExpert ){ 13572: rc = expertHandleSQL(pArg, zSql, pzErrMsg); 13573: return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg); 13574: } 13575: #endif 13576: 13577: while( zSql[0] && (SQLITE_OK == rc) ){ 13578: static const char *zStmtSql; 13579: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); 13580: if( SQLITE_OK != rc ){ 13581: if( pzErrMsg ){ 13582: *pzErrMsg = save_err_msg(db); 13583: } 13584: }else{ 13585: if( !pStmt ){ 13586: /* this happens for a comment or white-space */ 13587: zSql = zLeftover; 13588: while( IsSpace(zSql[0]) ) zSql++; 13589: continue; 13590: } 13591: zStmtSql = sqlite3_sql(pStmt); 13592: if( zStmtSql==0 ) zStmtSql = ""; 13593: while( IsSpace(zStmtSql[0]) ) zStmtSql++; 13594: 13595: /* save off the prepared statment handle and reset row count */ 13596: if( pArg ){ 13597: pArg->pStmt = pStmt; 13598: pArg->cnt = 0; 13599: } 13600: 13601: /* echo the sql statement if echo on */ 13602: if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){ 13603: utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql); 13604: } 13605: 13606: /* Show the EXPLAIN QUERY PLAN if .eqp is on */ 13607: if( pArg && pArg->autoEQP && sqlite3_stmt_isexplain(pStmt)==0 ){ 13608: sqlite3_stmt *pExplain; 13609: char *zEQP; 13610: int triggerEQP = 0; 13611: disable_debug_trace_modes(); 13612: sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP); 13613: if( pArg->autoEQP>=AUTOEQP_trigger ){ 13614: sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0); 13615: } 13616: zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql); 13617: rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 13618: if( rc==SQLITE_OK ){ 13619: while( sqlite3_step(pExplain)==SQLITE_ROW ){ 13620: const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3); 13621: int iEqpId = sqlite3_column_int(pExplain, 0); 13622: int iParentId = sqlite3_column_int(pExplain, 1); 13623: if( zEQPLine==0 ) zEQPLine = ""; 13624: if( zEQPLine[0]=='-' ) eqp_render(pArg); 13625: eqp_append(pArg, iEqpId, iParentId, zEQPLine); 13626: } 13627: eqp_render(pArg); 13628: } 13629: sqlite3_finalize(pExplain); 13630: sqlite3_free(zEQP); 13631: if( pArg->autoEQP>=AUTOEQP_full ){ 13632: /* Also do an EXPLAIN for ".eqp full" mode */ 13633: zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql); 13634: rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 13635: if( rc==SQLITE_OK ){ 13636: pArg->cMode = MODE_Explain; 13637: explain_data_prepare(pArg, pExplain); 13638: exec_prepared_stmt(pArg, pExplain); 13639: explain_data_delete(pArg); 13640: } 13641: sqlite3_finalize(pExplain); 13642: sqlite3_free(zEQP); 13643: } 13644: if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){ 13645: sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0); 13646: /* Reprepare pStmt before reactiving trace modes */ 13647: sqlite3_finalize(pStmt); 13648: sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 13649: if( pArg ) pArg->pStmt = pStmt; 13650: } 13651: restore_debug_trace_modes(); 13652: } 13653: 13654: if( pArg ){ 13655: pArg->cMode = pArg->mode; 13656: if( pArg->autoExplain ){ 13657: if( sqlite3_stmt_isexplain(pStmt)==1 ){ 13658: pArg->cMode = MODE_Explain; 13659: } 13660: if( sqlite3_stmt_isexplain(pStmt)==2 ){ 13661: pArg->cMode = MODE_EQP; 13662: } 13663: } 13664: 13665: /* If the shell is currently in ".explain" mode, gather the extra 13666: ** data required to add indents to the output.*/ 13667: if( pArg->cMode==MODE_Explain ){ 13668: explain_data_prepare(pArg, pStmt); 13669: } 13670: } 13671: 13672: bind_prepared_stmt(pArg, pStmt); 13673: exec_prepared_stmt(pArg, pStmt); 13674: explain_data_delete(pArg); 13675: eqp_render(pArg); 13676: 13677: /* print usage stats if stats on */ 13678: if( pArg && pArg->statsOn ){ 13679: display_stats(db, pArg, 0); 13680: } 13681: 13682: /* print loop-counters if required */ 13683: if( pArg && pArg->scanstatsOn ){ 13684: display_scanstats(db, pArg); 13685: } 13686: 13687: /* Finalize the statement just executed. If this fails, save a 13688: ** copy of the error message. Otherwise, set zSql to point to the 13689: ** next statement to execute. */ 13690: rc2 = sqlite3_finalize(pStmt); 13691: if( rc!=SQLITE_NOMEM ) rc = rc2; 13692: if( rc==SQLITE_OK ){ 13693: zSql = zLeftover; 13694: while( IsSpace(zSql[0]) ) zSql++; 13695: }else if( pzErrMsg ){ 13696: *pzErrMsg = save_err_msg(db); 13697: } 13698: 13699: /* clear saved stmt handle */ 13700: if( pArg ){ 13701: pArg->pStmt = NULL; 13702: } 13703: } 13704: } /* end while */ 13705: 13706: return rc; 13707: } 13708: 13709: /* 13710: ** Release memory previously allocated by tableColumnList(). 13711: */ 13712: static void freeColumnList(char **azCol){ 13713: int i; 13714: for(i=1; azCol[i]; i++){ 13715: sqlite3_free(azCol[i]); 13716: } 13717: /* azCol[0] is a static string */ 13718: sqlite3_free(azCol); 13719: } 13720: 13721: /* 13722: ** Return a list of pointers to strings which are the names of all 13723: ** columns in table zTab. The memory to hold the names is dynamically 13724: ** allocated and must be released by the caller using a subsequent call 13725: ** to freeColumnList(). 13726: ** 13727: ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid 13728: ** value that needs to be preserved, then azCol[0] is filled in with the 13729: ** name of the rowid column. 13730: ** 13731: ** The first regular column in the table is azCol[1]. The list is terminated 13732: ** by an entry with azCol[i]==0. 13733: */ 13734: static char **tableColumnList(ShellState *p, const char *zTab){ 13735: char **azCol = 0; 13736: sqlite3_stmt *pStmt; 13737: char *zSql; 13738: int nCol = 0; 13739: int nAlloc = 0; 13740: int nPK = 0; /* Number of PRIMARY KEY columns seen */ 13741: int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */ 13742: int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid); 13743: int rc; 13744: 13745: zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab); 13746: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 13747: sqlite3_free(zSql); 13748: if( rc ) return 0; 13749: while( sqlite3_step(pStmt)==SQLITE_ROW ){ 13750: if( nCol>=nAlloc-2 ){ 13751: nAlloc = nAlloc*2 + nCol + 10; 13752: azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0])); 13753: if( azCol==0 ) shell_out_of_memory(); 13754: } 13755: azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1)); 13756: if( sqlite3_column_int(pStmt, 5) ){ 13757: nPK++; 13758: if( nPK==1 13759: && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2), 13760: "INTEGER")==0 13761: ){ 13762: isIPK = 1; 13763: }else{ 13764: isIPK = 0; 13765: } 13766: } 13767: } 13768: sqlite3_finalize(pStmt); 13769: if( azCol==0 ) return 0; 13770: azCol[0] = 0; 13771: azCol[nCol+1] = 0; 13772: 13773: /* The decision of whether or not a rowid really needs to be preserved 13774: ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table 13775: ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve 13776: ** rowids on tables where the rowid is inaccessible because there are other 13777: ** columns in the table named "rowid", "_rowid_", and "oid". 13778: */ 13779: if( preserveRowid && isIPK ){ 13780: /* If a single PRIMARY KEY column with type INTEGER was seen, then it 13781: ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID 13782: ** table or a INTEGER PRIMARY KEY DESC column, neither of which are 13783: ** ROWID aliases. To distinguish these cases, check to see if 13784: ** there is a "pk" entry in "PRAGMA index_list". There will be 13785: ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID. 13786: */ 13787: zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)" 13788: " WHERE origin='pk'", zTab); 13789: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 13790: sqlite3_free(zSql); 13791: if( rc ){ 13792: freeColumnList(azCol); 13793: return 0; 13794: } 13795: rc = sqlite3_step(pStmt); 13796: sqlite3_finalize(pStmt); 13797: preserveRowid = rc==SQLITE_ROW; 13798: } 13799: if( preserveRowid ){ 13800: /* Only preserve the rowid if we can find a name to use for the 13801: ** rowid */ 13802: static char *azRowid[] = { "rowid", "_rowid_", "oid" }; 13803: int i, j; 13804: for(j=0; j<3; j++){ 13805: for(i=1; i<=nCol; i++){ 13806: if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break; 13807: } 13808: if( i>nCol ){ 13809: /* At this point, we know that azRowid[j] is not the name of any 13810: ** ordinary column in the table. Verify that azRowid[j] is a valid 13811: ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID 13812: ** tables will fail this last check */ 13813: rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0); 13814: if( rc==SQLITE_OK ) azCol[0] = azRowid[j]; 13815: break; 13816: } 13817: } 13818: } 13819: return azCol; 13820: } 13821: 13822: /* 13823: ** Toggle the reverse_unordered_selects setting. 13824: */ 13825: static void toggleSelectOrder(sqlite3 *db){ 13826: sqlite3_stmt *pStmt = 0; 13827: int iSetting = 0; 13828: char zStmt[100]; 13829: sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0); 13830: if( sqlite3_step(pStmt)==SQLITE_ROW ){ 13831: iSetting = sqlite3_column_int(pStmt, 0); 13832: } 13833: sqlite3_finalize(pStmt); 13834: sqlite3_snprintf(sizeof(zStmt), zStmt, 13835: "PRAGMA reverse_unordered_selects(%d)", !iSetting); 13836: sqlite3_exec(db, zStmt, 0, 0, 0); 13837: } 13838: 13839: /* 13840: ** This is a different callback routine used for dumping the database. 13841: ** Each row received by this callback consists of a table name, 13842: ** the table type ("index" or "table") and SQL to create the table. 13843: ** This routine should print text sufficient to recreate the table. 13844: */ 13845: static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){ 13846: int rc; 13847: const char *zTable; 13848: const char *zType; 13849: const char *zSql; 13850: ShellState *p = (ShellState *)pArg; 1.6 ! misho 13851: int dataOnly; ! 13852: int noSys; 1.5 misho 13853: 13854: UNUSED_PARAMETER(azNotUsed); 13855: if( nArg!=3 || azArg==0 ) return 0; 13856: zTable = azArg[0]; 13857: zType = azArg[1]; 13858: zSql = azArg[2]; 1.6 ! misho 13859: dataOnly = (p->shellFlgs & SHFLG_DumpDataOnly)!=0; ! 13860: noSys = (p->shellFlgs & SHFLG_DumpNoSys)!=0; 1.5 misho 13861: 1.6 ! misho 13862: if( strcmp(zTable, "sqlite_sequence")==0 && !noSys ){ ! 13863: if( !dataOnly ) raw_printf(p->out, "DELETE FROM sqlite_sequence;\n"); ! 13864: }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 && !noSys ){ ! 13865: if( !dataOnly ) raw_printf(p->out, "ANALYZE sqlite_schema;\n"); 1.5 misho 13866: }else if( strncmp(zTable, "sqlite_", 7)==0 ){ 13867: return 0; 1.6 ! misho 13868: }else if( dataOnly ){ ! 13869: /* no-op */ 1.5 misho 13870: }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ 13871: char *zIns; 13872: if( !p->writableSchema ){ 13873: raw_printf(p->out, "PRAGMA writable_schema=ON;\n"); 13874: p->writableSchema = 1; 13875: } 13876: zIns = sqlite3_mprintf( 13877: "INSERT INTO sqlite_schema(type,name,tbl_name,rootpage,sql)" 13878: "VALUES('table','%q','%q',0,'%q');", 13879: zTable, zTable, zSql); 13880: utf8_printf(p->out, "%s\n", zIns); 13881: sqlite3_free(zIns); 13882: return 0; 13883: }else{ 13884: printSchemaLine(p->out, zSql, ";\n"); 13885: } 13886: 13887: if( strcmp(zType, "table")==0 ){ 13888: ShellText sSelect; 13889: ShellText sTable; 13890: char **azCol; 13891: int i; 13892: char *savedDestTable; 13893: int savedMode; 13894: 13895: azCol = tableColumnList(p, zTable); 13896: if( azCol==0 ){ 13897: p->nErr++; 13898: return 0; 13899: } 13900: 13901: /* Always quote the table name, even if it appears to be pure ascii, 13902: ** in case it is a keyword. Ex: INSERT INTO "table" ... */ 13903: initText(&sTable); 13904: appendText(&sTable, zTable, quoteChar(zTable)); 13905: /* If preserving the rowid, add a column list after the table name. 13906: ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)" 13907: ** instead of the usual "INSERT INTO tab VALUES(...)". 13908: */ 13909: if( azCol[0] ){ 13910: appendText(&sTable, "(", 0); 13911: appendText(&sTable, azCol[0], 0); 13912: for(i=1; azCol[i]; i++){ 13913: appendText(&sTable, ",", 0); 13914: appendText(&sTable, azCol[i], quoteChar(azCol[i])); 13915: } 13916: appendText(&sTable, ")", 0); 13917: } 13918: 13919: /* Build an appropriate SELECT statement */ 13920: initText(&sSelect); 13921: appendText(&sSelect, "SELECT ", 0); 13922: if( azCol[0] ){ 13923: appendText(&sSelect, azCol[0], 0); 13924: appendText(&sSelect, ",", 0); 13925: } 13926: for(i=1; azCol[i]; i++){ 13927: appendText(&sSelect, azCol[i], quoteChar(azCol[i])); 13928: if( azCol[i+1] ){ 13929: appendText(&sSelect, ",", 0); 13930: } 13931: } 13932: freeColumnList(azCol); 13933: appendText(&sSelect, " FROM ", 0); 13934: appendText(&sSelect, zTable, quoteChar(zTable)); 13935: 13936: savedDestTable = p->zDestTable; 13937: savedMode = p->mode; 13938: p->zDestTable = sTable.z; 13939: p->mode = p->cMode = MODE_Insert; 13940: rc = shell_exec(p, sSelect.z, 0); 13941: if( (rc&0xff)==SQLITE_CORRUPT ){ 13942: raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 13943: toggleSelectOrder(p->db); 13944: shell_exec(p, sSelect.z, 0); 13945: toggleSelectOrder(p->db); 13946: } 13947: p->zDestTable = savedDestTable; 13948: p->mode = savedMode; 13949: freeText(&sTable); 13950: freeText(&sSelect); 13951: if( rc ) p->nErr++; 13952: } 13953: return 0; 13954: } 13955: 13956: /* 13957: ** Run zQuery. Use dump_callback() as the callback routine so that 13958: ** the contents of the query are output as SQL statements. 13959: ** 13960: ** If we get a SQLITE_CORRUPT error, rerun the query after appending 13961: ** "ORDER BY rowid DESC" to the end. 13962: */ 13963: static int run_schema_dump_query( 13964: ShellState *p, 13965: const char *zQuery 13966: ){ 13967: int rc; 13968: char *zErr = 0; 13969: rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr); 13970: if( rc==SQLITE_CORRUPT ){ 13971: char *zQ2; 13972: int len = strlen30(zQuery); 13973: raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n"); 13974: if( zErr ){ 13975: utf8_printf(p->out, "/****** %s ******/\n", zErr); 13976: sqlite3_free(zErr); 13977: zErr = 0; 13978: } 13979: zQ2 = malloc( len+100 ); 13980: if( zQ2==0 ) return rc; 13981: sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery); 13982: rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr); 13983: if( rc ){ 13984: utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr); 13985: }else{ 13986: rc = SQLITE_CORRUPT; 13987: } 13988: sqlite3_free(zErr); 13989: free(zQ2); 13990: } 13991: return rc; 13992: } 13993: 13994: /* 13995: ** Text of help messages. 13996: ** 13997: ** The help text for each individual command begins with a line that starts 13998: ** with ".". Subsequent lines are supplimental information. 13999: ** 14000: ** There must be two or more spaces between the end of the command and the 14001: ** start of the description of what that command does. 14002: */ 14003: static const char *(azHelp[]) = { 14004: #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 14005: ".archive ... Manage SQL archives", 14006: " Each command must have exactly one of the following options:", 14007: " -c, --create Create a new archive", 14008: " -u, --update Add or update files with changed mtime", 14009: " -i, --insert Like -u but always add even if unchanged", 14010: " -t, --list List contents of archive", 14011: " -x, --extract Extract files from archive", 14012: " Optional arguments:", 14013: " -v, --verbose Print each filename as it is processed", 14014: " -f FILE, --file FILE Use archive FILE (default is current db)", 14015: " -a FILE, --append FILE Open FILE using the apndvfs VFS", 14016: " -C DIR, --directory DIR Read/extract files from directory DIR", 14017: " -n, --dryrun Show the SQL that would have occurred", 14018: " Examples:", 14019: " .ar -cf ARCHIVE foo bar # Create ARCHIVE from files foo and bar", 14020: " .ar -tf ARCHIVE # List members of ARCHIVE", 14021: " .ar -xvf ARCHIVE # Verbosely extract files from ARCHIVE", 14022: " See also:", 14023: " http://sqlite.org/cli.html#sqlar_archive_support", 14024: #endif 14025: #ifndef SQLITE_OMIT_AUTHORIZATION 14026: ".auth ON|OFF Show authorizer callbacks", 14027: #endif 14028: ".backup ?DB? FILE Backup DB (default \"main\") to FILE", 14029: " --append Use the appendvfs", 14030: " --async Write to FILE without journal and fsync()", 14031: ".bail on|off Stop after hitting an error. Default OFF", 14032: ".binary on|off Turn binary output on or off. Default OFF", 14033: ".cd DIRECTORY Change the working directory to DIRECTORY", 14034: ".changes on|off Show number of rows changed by SQL", 14035: ".check GLOB Fail if output since .testcase does not match", 14036: ".clone NEWDB Clone data into NEWDB from the existing database", 14037: ".databases List names and files of attached databases", 14038: ".dbconfig ?op? ?val? List or change sqlite3_db_config() options", 14039: ".dbinfo ?DB? Show status information about the database", 1.6 ! misho 14040: ".dump ?OBJECTS? Render database content as SQL", 1.5 misho 14041: " Options:", 1.6 ! misho 14042: " --data-only Output only INSERT statements", ! 14043: " --newlines Allow unescaped newline characters in output", ! 14044: " --nosys Omit system tables (ex: \"sqlite_stat1\")", 1.5 misho 14045: " --preserve-rowids Include ROWID values in the output", 1.6 ! misho 14046: " OBJECTS is a LIKE pattern for tables, indexes, triggers or views to dump", 1.5 misho 14047: " Additional LIKE patterns can be given in subsequent arguments", 14048: ".echo on|off Turn command echo on or off", 14049: ".eqp on|off|full|... Enable or disable automatic EXPLAIN QUERY PLAN", 14050: " Other Modes:", 14051: #ifdef SQLITE_DEBUG 14052: " test Show raw EXPLAIN QUERY PLAN output", 14053: " trace Like \"full\" but enable \"PRAGMA vdbe_trace\"", 14054: #endif 14055: " trigger Like \"full\" but also show trigger bytecode", 14056: ".excel Display the output of next command in spreadsheet", 14057: " --bom Put a UTF8 byte-order mark on intermediate file", 14058: ".exit ?CODE? Exit this program with return-code CODE", 14059: ".expert EXPERIMENTAL. Suggest indexes for queries", 14060: ".explain ?on|off|auto? Change the EXPLAIN formatting mode. Default: auto", 14061: ".filectrl CMD ... Run various sqlite3_file_control() operations", 14062: " --schema SCHEMA Use SCHEMA instead of \"main\"", 14063: " --help Show CMD details", 14064: ".fullschema ?--indent? Show schema and the content of sqlite_stat tables", 14065: ".headers on|off Turn display of headers on or off", 14066: ".help ?-all? ?PATTERN? Show help text for PATTERN", 14067: ".import FILE TABLE Import data from FILE into TABLE", 14068: " Options:", 14069: " --ascii Use \\037 and \\036 as column and row separators", 14070: " --csv Use , and \\n as column and row separators", 14071: " --skip N Skip the first N rows of input", 14072: " -v \"Verbose\" - increase auxiliary output", 14073: " Notes:", 14074: " * If TABLE does not exist, it is created. The first row of input", 14075: " determines the column names.", 14076: " * If neither --csv or --ascii are used, the input mode is derived", 14077: " from the \".mode\" output mode", 14078: " * If FILE begins with \"|\" then it is a command that generates the", 14079: " input text.", 14080: #ifndef SQLITE_OMIT_TEST_CONTROL 14081: ".imposter INDEX TABLE Create imposter table TABLE on index INDEX", 14082: #endif 14083: ".indexes ?TABLE? Show names of indexes", 14084: " If TABLE is specified, only show indexes for", 14085: " tables matching TABLE using the LIKE operator.", 14086: #ifdef SQLITE_ENABLE_IOTRACE 14087: ".iotrace FILE Enable I/O diagnostic logging to FILE", 14088: #endif 14089: ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT", 14090: ".lint OPTIONS Report potential schema issues.", 14091: " Options:", 14092: " fkey-indexes Find missing foreign key indexes", 14093: #ifndef SQLITE_OMIT_LOAD_EXTENSION 14094: ".load FILE ?ENTRY? Load an extension library", 14095: #endif 14096: ".log FILE|off Turn logging on or off. FILE can be stderr/stdout", 14097: ".mode MODE ?TABLE? Set output mode", 14098: " MODE is one of:", 14099: " ascii Columns/rows delimited by 0x1F and 0x1E", 14100: " box Tables using unicode box-drawing characters", 14101: " csv Comma-separated values", 14102: " column Output in columns. (See .width)", 14103: " html HTML <table> code", 14104: " insert SQL insert statements for TABLE", 14105: " json Results in a JSON array", 14106: " line One value per line", 14107: " list Values delimited by \"|\"", 14108: " markdown Markdown table format", 14109: " quote Escape answers as for SQL", 14110: " table ASCII-art table", 14111: " tabs Tab-separated values", 14112: " tcl TCL list elements", 14113: ".nullvalue STRING Use STRING in place of NULL values", 14114: ".once ?OPTIONS? ?FILE? Output for the next SQL command only to FILE", 14115: " If FILE begins with '|' then open as a pipe", 14116: " --bom Put a UTF8 byte-order mark at the beginning", 14117: " -e Send output to the system text editor", 14118: " -x Send output as CSV to a spreadsheet (same as \".excel\")", 14119: #ifdef SQLITE_DEBUG 14120: ".oom ?--repeat M? ?N? Simulate an OOM error on the N-th allocation", 14121: #endif 14122: ".open ?OPTIONS? ?FILE? Close existing database and reopen FILE", 14123: " Options:", 14124: " --append Use appendvfs to append database to the end of FILE", 14125: #ifdef SQLITE_ENABLE_DESERIALIZE 14126: " --deserialize Load into memory useing sqlite3_deserialize()", 14127: " --hexdb Load the output of \"dbtotxt\" as an in-memory db", 14128: " --maxsize N Maximum size for --hexdb or --deserialized database", 14129: #endif 14130: " --new Initialize FILE to an empty database", 14131: " --nofollow Do not follow symbolic links", 14132: " --readonly Open FILE readonly", 14133: " --zip FILE is a ZIP archive", 14134: ".output ?FILE? Send output to FILE or stdout if FILE is omitted", 14135: " If FILE begins with '|' then open it as a pipe.", 14136: " Options:", 14137: " --bom Prefix output with a UTF8 byte-order mark", 14138: " -e Send output to the system text editor", 14139: " -x Send output as CSV to a spreadsheet", 14140: ".parameter CMD ... Manage SQL parameter bindings", 14141: " clear Erase all bindings", 14142: " init Initialize the TEMP table that holds bindings", 14143: " list List the current parameter bindings", 14144: " set PARAMETER VALUE Given SQL parameter PARAMETER a value of VALUE", 14145: " PARAMETER should start with one of: $ : @ ?", 14146: " unset PARAMETER Remove PARAMETER from the binding table", 14147: ".print STRING... Print literal STRING", 14148: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 14149: ".progress N Invoke progress handler after every N opcodes", 14150: " --limit N Interrupt after N progress callbacks", 14151: " --once Do no more than one progress interrupt", 14152: " --quiet|-q No output except at interrupts", 14153: " --reset Reset the count for each input and interrupt", 14154: #endif 14155: ".prompt MAIN CONTINUE Replace the standard prompts", 14156: ".quit Exit this program", 14157: ".read FILE Read input from FILE", 14158: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 14159: ".recover Recover as much data as possible from corrupt db.", 14160: " --freelist-corrupt Assume the freelist is corrupt", 14161: " --recovery-db NAME Store recovery metadata in database file NAME", 14162: " --lost-and-found TABLE Alternative name for the lost-and-found table", 14163: " --no-rowids Do not attempt to recover rowid values", 14164: " that are not also INTEGER PRIMARY KEYs", 14165: #endif 14166: ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE", 14167: ".save FILE Write in-memory database into FILE", 14168: ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off", 14169: ".schema ?PATTERN? Show the CREATE statements matching PATTERN", 1.6 ! misho 14170: " Options:", ! 14171: " --indent Try to pretty-print the schema", ! 14172: " --nosys Omit objects whose names start with \"sqlite_\"", 1.5 misho 14173: ".selftest ?OPTIONS? Run tests defined in the SELFTEST table", 14174: " Options:", 14175: " --init Create a new SELFTEST table", 14176: " -v Verbose output", 14177: ".separator COL ?ROW? Change the column and row separators", 14178: #if defined(SQLITE_ENABLE_SESSION) 14179: ".session ?NAME? CMD ... Create or control sessions", 14180: " Subcommands:", 14181: " attach TABLE Attach TABLE", 14182: " changeset FILE Write a changeset into FILE", 14183: " close Close one session", 14184: " enable ?BOOLEAN? Set or query the enable bit", 14185: " filter GLOB... Reject tables matching GLOBs", 14186: " indirect ?BOOLEAN? Mark or query the indirect status", 14187: " isempty Query whether the session is empty", 14188: " list List currently open session names", 14189: " open DB NAME Open a new session on DB", 14190: " patchset FILE Write a patchset into FILE", 14191: " If ?NAME? is omitted, the first defined session is used.", 14192: #endif 14193: ".sha3sum ... Compute a SHA3 hash of database content", 14194: " Options:", 14195: " --schema Also hash the sqlite_schema table", 14196: " --sha3-224 Use the sha3-224 algorithm", 14197: " --sha3-256 Use the sha3-256 algorithm (default)", 14198: " --sha3-384 Use the sha3-384 algorithm", 14199: " --sha3-512 Use the sha3-512 algorithm", 14200: " Any other argument is a LIKE pattern for tables to hash", 14201: #ifndef SQLITE_NOHAVE_SYSTEM 14202: ".shell CMD ARGS... Run CMD ARGS... in a system shell", 14203: #endif 14204: ".show Show the current values for various settings", 1.6 ! misho 14205: ".stats ?ARG? Show stats or turn stats on or off", ! 14206: " off Turn off automatic stat display", ! 14207: " on Turn on automatic stat display", ! 14208: " stmt Show statement stats", ! 14209: " vmstep Show the virtual machine step count only", 1.5 misho 14210: #ifndef SQLITE_NOHAVE_SYSTEM 14211: ".system CMD ARGS... Run CMD ARGS... in a system shell", 14212: #endif 14213: ".tables ?TABLE? List names of tables matching LIKE pattern TABLE", 14214: ".testcase NAME Begin redirecting output to 'testcase-out.txt'", 14215: ".testctrl CMD ... Run various sqlite3_test_control() operations", 14216: " Run \".testctrl\" with no arguments for details", 14217: ".timeout MS Try opening locked tables for MS milliseconds", 14218: ".timer on|off Turn SQL timer on or off", 14219: #ifndef SQLITE_OMIT_TRACE 14220: ".trace ?OPTIONS? Output each SQL statement as it is run", 14221: " FILE Send output to FILE", 14222: " stdout Send output to stdout", 14223: " stderr Send output to stderr", 14224: " off Disable tracing", 14225: " --expanded Expand query parameters", 14226: #ifdef SQLITE_ENABLE_NORMALIZE 14227: " --normalized Normal the SQL statements", 14228: #endif 14229: " --plain Show SQL as it is input", 14230: " --stmt Trace statement execution (SQLITE_TRACE_STMT)", 14231: " --profile Profile statements (SQLITE_TRACE_PROFILE)", 14232: " --row Trace each row (SQLITE_TRACE_ROW)", 14233: " --close Trace connection close (SQLITE_TRACE_CLOSE)", 14234: #endif /* SQLITE_OMIT_TRACE */ 14235: #ifdef SQLITE_DEBUG 14236: ".unmodule NAME ... Unregister virtual table modules", 14237: " --allexcept Unregister everything except those named", 14238: #endif 14239: ".vfsinfo ?AUX? Information about the top-level VFS", 14240: ".vfslist List all available VFSes", 14241: ".vfsname ?AUX? Print the name of the VFS stack", 14242: ".width NUM1 NUM2 ... Set minimum column widths for columnar output", 14243: " Negative values right-justify", 14244: }; 14245: 14246: /* 14247: ** Output help text. 14248: ** 14249: ** zPattern describes the set of commands for which help text is provided. 14250: ** If zPattern is NULL, then show all commands, but only give a one-line 14251: ** description of each. 14252: ** 14253: ** Return the number of matches. 14254: */ 14255: static int showHelp(FILE *out, const char *zPattern){ 14256: int i = 0; 14257: int j = 0; 14258: int n = 0; 14259: char *zPat; 14260: if( zPattern==0 14261: || zPattern[0]=='0' 14262: || strcmp(zPattern,"-a")==0 14263: || strcmp(zPattern,"-all")==0 14264: || strcmp(zPattern,"--all")==0 14265: ){ 14266: /* Show all commands, but only one line per command */ 14267: if( zPattern==0 ) zPattern = ""; 14268: for(i=0; i<ArraySize(azHelp); i++){ 14269: if( azHelp[i][0]=='.' || zPattern[0] ){ 14270: utf8_printf(out, "%s\n", azHelp[i]); 14271: n++; 14272: } 14273: } 14274: }else{ 14275: /* Look for commands that for which zPattern is an exact prefix */ 14276: zPat = sqlite3_mprintf(".%s*", zPattern); 14277: for(i=0; i<ArraySize(azHelp); i++){ 14278: if( sqlite3_strglob(zPat, azHelp[i])==0 ){ 14279: utf8_printf(out, "%s\n", azHelp[i]); 14280: j = i+1; 14281: n++; 14282: } 14283: } 14284: sqlite3_free(zPat); 14285: if( n ){ 14286: if( n==1 ){ 14287: /* when zPattern is a prefix of exactly one command, then include the 14288: ** details of that command, which should begin at offset j */ 14289: while( j<ArraySize(azHelp)-1 && azHelp[j][0]!='.' ){ 14290: utf8_printf(out, "%s\n", azHelp[j]); 14291: j++; 14292: } 14293: } 14294: return n; 14295: } 14296: /* Look for commands that contain zPattern anywhere. Show the complete 14297: ** text of all commands that match. */ 14298: zPat = sqlite3_mprintf("%%%s%%", zPattern); 14299: for(i=0; i<ArraySize(azHelp); i++){ 14300: if( azHelp[i][0]=='.' ) j = i; 14301: if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){ 14302: utf8_printf(out, "%s\n", azHelp[j]); 14303: while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]!='.' ){ 14304: j++; 14305: utf8_printf(out, "%s\n", azHelp[j]); 14306: } 14307: i = j; 14308: n++; 14309: } 14310: } 14311: sqlite3_free(zPat); 14312: } 14313: return n; 14314: } 14315: 14316: /* Forward reference */ 14317: static int process_input(ShellState *p); 14318: 14319: /* 14320: ** Read the content of file zName into memory obtained from sqlite3_malloc64() 14321: ** and return a pointer to the buffer. The caller is responsible for freeing 14322: ** the memory. 14323: ** 14324: ** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes 14325: ** read. 14326: ** 14327: ** For convenience, a nul-terminator byte is always appended to the data read 14328: ** from the file before the buffer is returned. This byte is not included in 14329: ** the final value of (*pnByte), if applicable. 14330: ** 14331: ** NULL is returned if any error is encountered. The final value of *pnByte 14332: ** is undefined in this case. 14333: */ 14334: static char *readFile(const char *zName, int *pnByte){ 14335: FILE *in = fopen(zName, "rb"); 14336: long nIn; 14337: size_t nRead; 14338: char *pBuf; 14339: if( in==0 ) return 0; 14340: fseek(in, 0, SEEK_END); 14341: nIn = ftell(in); 14342: rewind(in); 14343: pBuf = sqlite3_malloc64( nIn+1 ); 14344: if( pBuf==0 ){ fclose(in); return 0; } 14345: nRead = fread(pBuf, nIn, 1, in); 14346: fclose(in); 14347: if( nRead!=1 ){ 14348: sqlite3_free(pBuf); 14349: return 0; 14350: } 14351: pBuf[nIn] = 0; 14352: if( pnByte ) *pnByte = nIn; 14353: return pBuf; 14354: } 14355: 14356: #if defined(SQLITE_ENABLE_SESSION) 14357: /* 14358: ** Close a single OpenSession object and release all of its associated 14359: ** resources. 14360: */ 14361: static void session_close(OpenSession *pSession){ 14362: int i; 14363: sqlite3session_delete(pSession->p); 14364: sqlite3_free(pSession->zName); 14365: for(i=0; i<pSession->nFilter; i++){ 14366: sqlite3_free(pSession->azFilter[i]); 14367: } 14368: sqlite3_free(pSession->azFilter); 14369: memset(pSession, 0, sizeof(OpenSession)); 14370: } 14371: #endif 14372: 14373: /* 14374: ** Close all OpenSession objects and release all associated resources. 14375: */ 14376: #if defined(SQLITE_ENABLE_SESSION) 14377: static void session_close_all(ShellState *p){ 14378: int i; 14379: for(i=0; i<p->nSession; i++){ 14380: session_close(&p->aSession[i]); 14381: } 14382: p->nSession = 0; 14383: } 14384: #else 14385: # define session_close_all(X) 14386: #endif 14387: 14388: /* 14389: ** Implementation of the xFilter function for an open session. Omit 14390: ** any tables named by ".session filter" but let all other table through. 14391: */ 14392: #if defined(SQLITE_ENABLE_SESSION) 14393: static int session_filter(void *pCtx, const char *zTab){ 14394: OpenSession *pSession = (OpenSession*)pCtx; 14395: int i; 14396: for(i=0; i<pSession->nFilter; i++){ 14397: if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0; 14398: } 14399: return 1; 14400: } 14401: #endif 14402: 14403: /* 14404: ** Try to deduce the type of file for zName based on its content. Return 14405: ** one of the SHELL_OPEN_* constants. 14406: ** 14407: ** If the file does not exist or is empty but its name looks like a ZIP 14408: ** archive and the dfltZip flag is true, then assume it is a ZIP archive. 14409: ** Otherwise, assume an ordinary database regardless of the filename if 14410: ** the type cannot be determined from content. 14411: */ 14412: int deduceDatabaseType(const char *zName, int dfltZip){ 14413: FILE *f = fopen(zName, "rb"); 14414: size_t n; 14415: int rc = SHELL_OPEN_UNSPEC; 14416: char zBuf[100]; 14417: if( f==0 ){ 14418: if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 14419: return SHELL_OPEN_ZIPFILE; 14420: }else{ 14421: return SHELL_OPEN_NORMAL; 14422: } 14423: } 14424: n = fread(zBuf, 16, 1, f); 14425: if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){ 14426: fclose(f); 14427: return SHELL_OPEN_NORMAL; 14428: } 14429: fseek(f, -25, SEEK_END); 14430: n = fread(zBuf, 25, 1, f); 14431: if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){ 14432: rc = SHELL_OPEN_APPENDVFS; 14433: }else{ 14434: fseek(f, -22, SEEK_END); 14435: n = fread(zBuf, 22, 1, f); 14436: if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05 14437: && zBuf[3]==0x06 ){ 14438: rc = SHELL_OPEN_ZIPFILE; 14439: }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){ 14440: rc = SHELL_OPEN_ZIPFILE; 14441: } 14442: } 14443: fclose(f); 14444: return rc; 14445: } 14446: 14447: #ifdef SQLITE_ENABLE_DESERIALIZE 14448: /* 14449: ** Reconstruct an in-memory database using the output from the "dbtotxt" 14450: ** program. Read content from the file in p->zDbFilename. If p->zDbFilename 14451: ** is 0, then read from standard input. 14452: */ 14453: static unsigned char *readHexDb(ShellState *p, int *pnData){ 14454: unsigned char *a = 0; 14455: int nLine; 14456: int n = 0; 14457: int pgsz = 0; 14458: int iOffset = 0; 14459: int j, k; 14460: int rc; 14461: FILE *in; 14462: unsigned int x[16]; 14463: char zLine[1000]; 14464: if( p->zDbFilename ){ 14465: in = fopen(p->zDbFilename, "r"); 14466: if( in==0 ){ 14467: utf8_printf(stderr, "cannot open \"%s\" for reading\n", p->zDbFilename); 14468: return 0; 14469: } 14470: nLine = 0; 14471: }else{ 14472: in = p->in; 14473: nLine = p->lineno; 14474: if( in==0 ) in = stdin; 14475: } 14476: *pnData = 0; 14477: nLine++; 14478: if( fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error; 14479: rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz); 14480: if( rc!=2 ) goto readHexDb_error; 14481: if( n<0 ) goto readHexDb_error; 14482: if( pgsz<512 || pgsz>65536 || (pgsz&(pgsz-1))!=0 ) goto readHexDb_error; 14483: n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */ 14484: a = sqlite3_malloc( n ? n : 1 ); 14485: if( a==0 ){ 14486: utf8_printf(stderr, "Out of memory!\n"); 14487: goto readHexDb_error; 14488: } 14489: memset(a, 0, n); 14490: if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){ 14491: utf8_printf(stderr, "invalid pagesize\n"); 14492: goto readHexDb_error; 14493: } 14494: for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){ 14495: rc = sscanf(zLine, "| page %d offset %d", &j, &k); 14496: if( rc==2 ){ 14497: iOffset = k; 14498: continue; 14499: } 14500: if( strncmp(zLine, "| end ", 6)==0 ){ 14501: break; 14502: } 14503: rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", 14504: &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7], 14505: &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]); 14506: if( rc==17 ){ 14507: k = iOffset+j; 14508: if( k+16<=n ){ 14509: int ii; 14510: for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff; 14511: } 14512: } 14513: } 14514: *pnData = n; 14515: if( in!=p->in ){ 14516: fclose(in); 14517: }else{ 14518: p->lineno = nLine; 14519: } 14520: return a; 14521: 14522: readHexDb_error: 14523: if( in!=p->in ){ 14524: fclose(in); 14525: }else{ 14526: while( fgets(zLine, sizeof(zLine), p->in)!=0 ){ 14527: nLine++; 14528: if(strncmp(zLine, "| end ", 6)==0 ) break; 14529: } 14530: p->lineno = nLine; 14531: } 14532: sqlite3_free(a); 14533: utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine); 14534: return 0; 14535: } 14536: #endif /* SQLITE_ENABLE_DESERIALIZE */ 14537: 14538: /* 14539: ** Scalar function "shell_int32". The first argument to this function 14540: ** must be a blob. The second a non-negative integer. This function 14541: ** reads and returns a 32-bit big-endian integer from byte 14542: ** offset (4*<arg2>) of the blob. 14543: */ 14544: static void shellInt32( 14545: sqlite3_context *context, 14546: int argc, 14547: sqlite3_value **argv 14548: ){ 14549: const unsigned char *pBlob; 14550: int nBlob; 14551: int iInt; 14552: 14553: UNUSED_PARAMETER(argc); 14554: nBlob = sqlite3_value_bytes(argv[0]); 14555: pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]); 14556: iInt = sqlite3_value_int(argv[1]); 14557: 14558: if( iInt>=0 && (iInt+1)*4<=nBlob ){ 14559: const unsigned char *a = &pBlob[iInt*4]; 14560: sqlite3_int64 iVal = ((sqlite3_int64)a[0]<<24) 14561: + ((sqlite3_int64)a[1]<<16) 14562: + ((sqlite3_int64)a[2]<< 8) 14563: + ((sqlite3_int64)a[3]<< 0); 14564: sqlite3_result_int64(context, iVal); 14565: } 14566: } 14567: 14568: /* 14569: ** Scalar function "shell_idquote(X)" returns string X quoted as an identifier, 14570: ** using "..." with internal double-quote characters doubled. 14571: */ 14572: static void shellIdQuote( 14573: sqlite3_context *context, 14574: int argc, 14575: sqlite3_value **argv 14576: ){ 14577: const char *zName = (const char*)sqlite3_value_text(argv[0]); 14578: UNUSED_PARAMETER(argc); 14579: if( zName ){ 14580: char *z = sqlite3_mprintf("\"%w\"", zName); 14581: sqlite3_result_text(context, z, -1, sqlite3_free); 14582: } 14583: } 14584: 14585: /* 1.6 ! misho 14586: ** Scalar function "usleep(X)" invokes sqlite3_sleep(X) and returns X. ! 14587: */ ! 14588: static void shellUSleepFunc( ! 14589: sqlite3_context *context, ! 14590: int argcUnused, ! 14591: sqlite3_value **argv ! 14592: ){ ! 14593: int sleep = sqlite3_value_int(argv[0]); ! 14594: (void)argcUnused; ! 14595: sqlite3_sleep(sleep/1000); ! 14596: sqlite3_result_int(context, sleep); ! 14597: } ! 14598: ! 14599: /* 1.5 misho 14600: ** Scalar function "shell_escape_crnl" used by the .recover command. 14601: ** The argument passed to this function is the output of built-in 14602: ** function quote(). If the first character of the input is "'", 14603: ** indicating that the value passed to quote() was a text value, 14604: ** then this function searches the input for "\n" and "\r" characters 14605: ** and adds a wrapper similar to the following: 14606: ** 14607: ** replace(replace(<input>, '\n', char(10), '\r', char(13)); 14608: ** 14609: ** Or, if the first character of the input is not "'", then a copy 14610: ** of the input is returned. 14611: */ 14612: static void shellEscapeCrnl( 14613: sqlite3_context *context, 14614: int argc, 14615: sqlite3_value **argv 14616: ){ 14617: const char *zText = (const char*)sqlite3_value_text(argv[0]); 14618: UNUSED_PARAMETER(argc); 14619: if( zText[0]=='\'' ){ 14620: int nText = sqlite3_value_bytes(argv[0]); 14621: int i; 14622: char zBuf1[20]; 14623: char zBuf2[20]; 14624: const char *zNL = 0; 14625: const char *zCR = 0; 14626: int nCR = 0; 14627: int nNL = 0; 14628: 14629: for(i=0; zText[i]; i++){ 14630: if( zNL==0 && zText[i]=='\n' ){ 14631: zNL = unused_string(zText, "\\n", "\\012", zBuf1); 14632: nNL = (int)strlen(zNL); 14633: } 14634: if( zCR==0 && zText[i]=='\r' ){ 14635: zCR = unused_string(zText, "\\r", "\\015", zBuf2); 14636: nCR = (int)strlen(zCR); 14637: } 14638: } 14639: 14640: if( zNL || zCR ){ 14641: int iOut = 0; 14642: i64 nMax = (nNL > nCR) ? nNL : nCR; 14643: i64 nAlloc = nMax * nText + (nMax+64)*2; 14644: char *zOut = (char*)sqlite3_malloc64(nAlloc); 14645: if( zOut==0 ){ 14646: sqlite3_result_error_nomem(context); 14647: return; 14648: } 14649: 14650: if( zNL && zCR ){ 14651: memcpy(&zOut[iOut], "replace(replace(", 16); 14652: iOut += 16; 14653: }else{ 14654: memcpy(&zOut[iOut], "replace(", 8); 14655: iOut += 8; 14656: } 14657: for(i=0; zText[i]; i++){ 14658: if( zText[i]=='\n' ){ 14659: memcpy(&zOut[iOut], zNL, nNL); 14660: iOut += nNL; 14661: }else if( zText[i]=='\r' ){ 14662: memcpy(&zOut[iOut], zCR, nCR); 14663: iOut += nCR; 1.3 misho 14664: }else{ 1.5 misho 14665: zOut[iOut] = zText[i]; 14666: iOut++; 1.4 misho 14667: } 14668: } 1.5 misho 14669: 14670: if( zNL ){ 14671: memcpy(&zOut[iOut], ",'", 2); iOut += 2; 14672: memcpy(&zOut[iOut], zNL, nNL); iOut += nNL; 14673: memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12; 14674: } 14675: if( zCR ){ 14676: memcpy(&zOut[iOut], ",'", 2); iOut += 2; 14677: memcpy(&zOut[iOut], zCR, nCR); iOut += nCR; 14678: memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12; 14679: } 14680: 14681: sqlite3_result_text(context, zOut, iOut, SQLITE_TRANSIENT); 14682: sqlite3_free(zOut); 14683: return; 1.4 misho 14684: } 1.5 misho 14685: } 14686: 14687: sqlite3_result_value(context, argv[0]); 14688: } 14689: 14690: /* Flags for open_db(). 14691: ** 14692: ** The default behavior of open_db() is to exit(1) if the database fails to 14693: ** open. The OPEN_DB_KEEPALIVE flag changes that so that it prints an error 14694: ** but still returns without calling exit. 14695: ** 14696: ** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a 14697: ** ZIP archive if the file does not exist or is empty and its name matches 14698: ** the *.zip pattern. 14699: */ 14700: #define OPEN_DB_KEEPALIVE 0x001 /* Return after error if true */ 14701: #define OPEN_DB_ZIPFILE 0x002 /* Open as ZIP if name matches *.zip */ 14702: 14703: /* 14704: ** Make sure the database is open. If it is not, then open it. If 14705: ** the database fails to open, print an error message and exit. 14706: */ 14707: static void open_db(ShellState *p, int openFlags){ 14708: if( p->db==0 ){ 14709: if( p->openMode==SHELL_OPEN_UNSPEC ){ 14710: if( p->zDbFilename==0 || p->zDbFilename[0]==0 ){ 14711: p->openMode = SHELL_OPEN_NORMAL; 14712: }else{ 14713: p->openMode = (u8)deduceDatabaseType(p->zDbFilename, 14714: (openFlags & OPEN_DB_ZIPFILE)!=0); 14715: } 1.4 misho 14716: } 1.5 misho 14717: switch( p->openMode ){ 14718: case SHELL_OPEN_APPENDVFS: { 14719: sqlite3_open_v2(p->zDbFilename, &p->db, 14720: SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, "apndvfs"); 14721: break; 14722: } 14723: case SHELL_OPEN_HEXDB: 14724: case SHELL_OPEN_DESERIALIZE: { 14725: sqlite3_open(0, &p->db); 14726: break; 14727: } 14728: case SHELL_OPEN_ZIPFILE: { 14729: sqlite3_open(":memory:", &p->db); 14730: break; 14731: } 14732: case SHELL_OPEN_READONLY: { 14733: sqlite3_open_v2(p->zDbFilename, &p->db, 14734: SQLITE_OPEN_READONLY|p->openFlags, 0); 1.4 misho 14735: break; 14736: } 1.5 misho 14737: case SHELL_OPEN_UNSPEC: 14738: case SHELL_OPEN_NORMAL: { 14739: sqlite3_open_v2(p->zDbFilename, &p->db, 14740: SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, 0); 14741: break; 1.4 misho 14742: } 1.5 misho 14743: } 14744: globalDb = p->db; 14745: if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){ 14746: utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n", 14747: p->zDbFilename, sqlite3_errmsg(p->db)); 14748: if( openFlags & OPEN_DB_KEEPALIVE ){ 14749: sqlite3_open(":memory:", &p->db); 14750: return; 1.2 misho 14751: } 1.5 misho 14752: exit(1); 1.2 misho 14753: } 1.5 misho 14754: #ifndef SQLITE_OMIT_LOAD_EXTENSION 14755: sqlite3_enable_load_extension(p->db, 1); 14756: #endif 14757: sqlite3_fileio_init(p->db, 0, 0); 14758: sqlite3_shathree_init(p->db, 0, 0); 14759: sqlite3_completion_init(p->db, 0, 0); 14760: sqlite3_uint_init(p->db, 0, 0); 14761: sqlite3_decimal_init(p->db, 0, 0); 14762: sqlite3_ieee_init(p->db, 0, 0); 1.6 ! misho 14763: sqlite3_series_init(p->db, 0, 0); 1.5 misho 14764: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 14765: sqlite3_dbdata_init(p->db, 0, 0); 14766: #endif 14767: #ifdef SQLITE_HAVE_ZLIB 14768: sqlite3_zipfile_init(p->db, 0, 0); 14769: sqlite3_sqlar_init(p->db, 0, 0); 14770: #endif 14771: sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0, 14772: shellAddSchemaName, 0, 0); 14773: sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, 0, 14774: shellModuleSchema, 0, 0); 14775: sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p, 14776: shellPutsFunc, 0, 0); 14777: sqlite3_create_function(p->db, "shell_escape_crnl", 1, SQLITE_UTF8, 0, 14778: shellEscapeCrnl, 0, 0); 14779: sqlite3_create_function(p->db, "shell_int32", 2, SQLITE_UTF8, 0, 14780: shellInt32, 0, 0); 14781: sqlite3_create_function(p->db, "shell_idquote", 1, SQLITE_UTF8, 0, 14782: shellIdQuote, 0, 0); 1.6 ! misho 14783: sqlite3_create_function(p->db, "usleep",1,SQLITE_UTF8,0, ! 14784: shellUSleepFunc, 0, 0); 1.5 misho 14785: #ifndef SQLITE_NOHAVE_SYSTEM 14786: sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0, 14787: editFunc, 0, 0); 14788: sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0, 14789: editFunc, 0, 0); 14790: #endif 14791: if( p->openMode==SHELL_OPEN_ZIPFILE ){ 14792: char *zSql = sqlite3_mprintf( 14793: "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", p->zDbFilename); 14794: sqlite3_exec(p->db, zSql, 0, 0, 0); 14795: sqlite3_free(zSql); 14796: } 14797: #ifdef SQLITE_ENABLE_DESERIALIZE 14798: else 14799: if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){ 14800: int rc; 14801: int nData = 0; 14802: unsigned char *aData; 14803: if( p->openMode==SHELL_OPEN_DESERIALIZE ){ 14804: aData = (unsigned char*)readFile(p->zDbFilename, &nData); 14805: }else{ 14806: aData = readHexDb(p, &nData); 14807: if( aData==0 ){ 14808: return; 1.2 misho 14809: } 14810: } 1.5 misho 14811: rc = sqlite3_deserialize(p->db, "main", aData, nData, nData, 14812: SQLITE_DESERIALIZE_RESIZEABLE | 14813: SQLITE_DESERIALIZE_FREEONCLOSE); 14814: if( rc ){ 14815: utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc); 14816: } 14817: if( p->szMax>0 ){ 14818: sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax); 14819: } 14820: } 14821: #endif 14822: } 14823: } 14824: 14825: /* 14826: ** Attempt to close the databaes connection. Report errors. 14827: */ 14828: void close_db(sqlite3 *db){ 14829: int rc = sqlite3_close(db); 14830: if( rc ){ 14831: utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n", 14832: rc, sqlite3_errmsg(db)); 14833: } 14834: } 14835: 14836: #if HAVE_READLINE || HAVE_EDITLINE 14837: /* 14838: ** Readline completion callbacks 14839: */ 14840: static char *readline_completion_generator(const char *text, int state){ 14841: static sqlite3_stmt *pStmt = 0; 14842: char *zRet; 14843: if( state==0 ){ 14844: char *zSql; 14845: sqlite3_finalize(pStmt); 14846: zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 14847: " FROM completion(%Q) ORDER BY 1", text); 14848: sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 14849: sqlite3_free(zSql); 14850: } 14851: if( sqlite3_step(pStmt)==SQLITE_ROW ){ 14852: zRet = strdup((const char*)sqlite3_column_text(pStmt, 0)); 14853: }else{ 14854: sqlite3_finalize(pStmt); 14855: pStmt = 0; 14856: zRet = 0; 14857: } 14858: return zRet; 14859: } 14860: static char **readline_completion(const char *zText, int iStart, int iEnd){ 14861: rl_attempted_completion_over = 1; 14862: return rl_completion_matches(zText, readline_completion_generator); 14863: } 14864: 14865: #elif HAVE_LINENOISE 14866: /* 14867: ** Linenoise completion callback 14868: */ 14869: static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){ 14870: int nLine = strlen30(zLine); 14871: int i, iStart; 14872: sqlite3_stmt *pStmt = 0; 14873: char *zSql; 14874: char zBuf[1000]; 14875: 14876: if( nLine>sizeof(zBuf)-30 ) return; 14877: if( zLine[0]=='.' || zLine[0]=='#') return; 14878: for(i=nLine-1; i>=0 && (isalnum(zLine[i]) || zLine[i]=='_'); i--){} 14879: if( i==nLine-1 ) return; 14880: iStart = i+1; 14881: memcpy(zBuf, zLine, iStart); 14882: zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase" 14883: " FROM completion(%Q,%Q) ORDER BY 1", 14884: &zLine[iStart], zLine); 14885: sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0); 14886: sqlite3_free(zSql); 14887: sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */ 14888: while( sqlite3_step(pStmt)==SQLITE_ROW ){ 14889: const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0); 14890: int nCompletion = sqlite3_column_bytes(pStmt, 0); 14891: if( iStart+nCompletion < sizeof(zBuf)-1 ){ 14892: memcpy(zBuf+iStart, zCompletion, nCompletion+1); 14893: linenoiseAddCompletion(lc, zBuf); 14894: } 14895: } 14896: sqlite3_finalize(pStmt); 14897: } 14898: #endif 14899: 14900: /* 14901: ** Do C-language style dequoting. 14902: ** 14903: ** \a -> alarm 14904: ** \b -> backspace 14905: ** \t -> tab 14906: ** \n -> newline 14907: ** \v -> vertical tab 14908: ** \f -> form feed 14909: ** \r -> carriage return 14910: ** \s -> space 14911: ** \" -> " 14912: ** \' -> ' 14913: ** \\ -> backslash 14914: ** \NNN -> ascii character NNN in octal 14915: */ 14916: static void resolve_backslashes(char *z){ 14917: int i, j; 14918: char c; 14919: while( *z && *z!='\\' ) z++; 14920: for(i=j=0; (c = z[i])!=0; i++, j++){ 14921: if( c=='\\' && z[i+1]!=0 ){ 14922: c = z[++i]; 14923: if( c=='a' ){ 14924: c = '\a'; 14925: }else if( c=='b' ){ 14926: c = '\b'; 14927: }else if( c=='t' ){ 14928: c = '\t'; 14929: }else if( c=='n' ){ 14930: c = '\n'; 14931: }else if( c=='v' ){ 14932: c = '\v'; 14933: }else if( c=='f' ){ 14934: c = '\f'; 14935: }else if( c=='r' ){ 14936: c = '\r'; 14937: }else if( c=='"' ){ 14938: c = '"'; 14939: }else if( c=='\'' ){ 14940: c = '\''; 14941: }else if( c=='\\' ){ 14942: c = '\\'; 14943: }else if( c>='0' && c<='7' ){ 14944: c -= '0'; 14945: if( z[i+1]>='0' && z[i+1]<='7' ){ 14946: i++; 14947: c = (c<<3) + z[i] - '0'; 14948: if( z[i+1]>='0' && z[i+1]<='7' ){ 14949: i++; 14950: c = (c<<3) + z[i] - '0'; 14951: } 1.2 misho 14952: } 14953: } 14954: } 1.5 misho 14955: z[j] = c; 14956: } 14957: if( j<i ) z[j] = 0; 14958: } 14959: 14960: /* 14961: ** Interpret zArg as either an integer or a boolean value. Return 1 or 0 14962: ** for TRUE and FALSE. Return the integer value if appropriate. 14963: */ 14964: static int booleanValue(const char *zArg){ 14965: int i; 14966: if( zArg[0]=='0' && zArg[1]=='x' ){ 14967: for(i=2; hexDigitValue(zArg[i])>=0; i++){} 14968: }else{ 14969: for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){} 14970: } 14971: if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff); 14972: if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){ 14973: return 1; 14974: } 14975: if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){ 14976: return 0; 14977: } 14978: utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", 14979: zArg); 14980: return 0; 14981: } 14982: 14983: /* 14984: ** Set or clear a shell flag according to a boolean value. 14985: */ 14986: static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){ 14987: if( booleanValue(zArg) ){ 14988: ShellSetFlag(p, mFlag); 14989: }else{ 14990: ShellClearFlag(p, mFlag); 14991: } 14992: } 14993: 14994: /* 14995: ** Close an output file, assuming it is not stderr or stdout 14996: */ 14997: static void output_file_close(FILE *f){ 14998: if( f && f!=stdout && f!=stderr ) fclose(f); 14999: } 15000: 15001: /* 15002: ** Try to open an output file. The names "stdout" and "stderr" are 15003: ** recognized and do the right thing. NULL is returned if the output 15004: ** filename is "off". 15005: */ 15006: static FILE *output_file_open(const char *zFile, int bTextMode){ 15007: FILE *f; 15008: if( strcmp(zFile,"stdout")==0 ){ 15009: f = stdout; 15010: }else if( strcmp(zFile, "stderr")==0 ){ 15011: f = stderr; 15012: }else if( strcmp(zFile, "off")==0 ){ 15013: f = 0; 15014: }else{ 15015: f = fopen(zFile, bTextMode ? "w" : "wb"); 15016: if( f==0 ){ 15017: utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 1.2 misho 15018: } 1.5 misho 15019: } 15020: return f; 15021: } 15022: 15023: #ifndef SQLITE_OMIT_TRACE 15024: /* 15025: ** A routine for handling output from sqlite3_trace(). 15026: */ 15027: static int sql_trace_callback( 15028: unsigned mType, /* The trace type */ 15029: void *pArg, /* The ShellState pointer */ 15030: void *pP, /* Usually a pointer to sqlite_stmt */ 15031: void *pX /* Auxiliary output */ 15032: ){ 15033: ShellState *p = (ShellState*)pArg; 15034: sqlite3_stmt *pStmt; 15035: const char *zSql; 15036: int nSql; 15037: if( p->traceOut==0 ) return 0; 15038: if( mType==SQLITE_TRACE_CLOSE ){ 15039: utf8_printf(p->traceOut, "-- closing database connection\n"); 15040: return 0; 15041: } 15042: if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){ 15043: zSql = (const char*)pX; 15044: }else{ 15045: pStmt = (sqlite3_stmt*)pP; 15046: switch( p->eTraceType ){ 15047: case SHELL_TRACE_EXPANDED: { 15048: zSql = sqlite3_expanded_sql(pStmt); 15049: break; 1.2 misho 15050: } 1.5 misho 15051: #ifdef SQLITE_ENABLE_NORMALIZE 15052: case SHELL_TRACE_NORMALIZED: { 15053: zSql = sqlite3_normalized_sql(pStmt); 15054: break; 1.2 misho 15055: } 1.5 misho 15056: #endif 15057: default: { 15058: zSql = sqlite3_sql(pStmt); 15059: break; 1.2 misho 15060: } 15061: } 1.5 misho 15062: } 15063: if( zSql==0 ) return 0; 15064: nSql = strlen30(zSql); 15065: while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; } 15066: switch( mType ){ 15067: case SQLITE_TRACE_ROW: 15068: case SQLITE_TRACE_STMT: { 15069: utf8_printf(p->traceOut, "%.*s;\n", nSql, zSql); 1.4 misho 15070: break; 15071: } 1.5 misho 15072: case SQLITE_TRACE_PROFILE: { 15073: sqlite3_int64 nNanosec = *(sqlite3_int64*)pX; 15074: utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", nSql, zSql, nNanosec); 1.2 misho 15075: break; 15076: } 15077: } 15078: return 0; 15079: } 1.5 misho 15080: #endif 1.2 misho 15081: 15082: /* 1.5 misho 15083: ** A no-op routine that runs with the ".breakpoint" doc-command. This is 15084: ** a useful spot to set a debugger breakpoint. 1.2 misho 15085: */ 1.5 misho 15086: static void test_breakpoint(void){ 15087: static int nCall = 0; 15088: nCall++; 1.2 misho 15089: } 15090: 15091: /* 1.5 misho 15092: ** An object used to read a CSV and other files for import. 1.2 misho 15093: */ 1.5 misho 15094: typedef struct ImportCtx ImportCtx; 15095: struct ImportCtx { 15096: const char *zFile; /* Name of the input file */ 15097: FILE *in; /* Read the CSV text from this input stream */ 15098: int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close in */ 15099: char *z; /* Accumulated text for a field */ 15100: int n; /* Number of bytes in z */ 15101: int nAlloc; /* Space allocated for z[] */ 15102: int nLine; /* Current line number */ 15103: int nRow; /* Number of rows imported */ 15104: int nErr; /* Number of errors encountered */ 15105: int bNotFirst; /* True if one or more bytes already read */ 15106: int cTerm; /* Character that terminated the most recent field */ 15107: int cColSep; /* The column separator character. (Usually ",") */ 15108: int cRowSep; /* The row separator character. (Usually "\n") */ 15109: }; 1.2 misho 15110: 1.5 misho 15111: /* Clean up resourced used by an ImportCtx */ 15112: static void import_cleanup(ImportCtx *p){ 15113: if( p->in!=0 && p->xCloser!=0 ){ 15114: p->xCloser(p->in); 15115: p->in = 0; 1.2 misho 15116: } 1.5 misho 15117: sqlite3_free(p->z); 15118: p->z = 0; 15119: } 15120: 15121: /* Append a single byte to z[] */ 15122: static void import_append_char(ImportCtx *p, int c){ 15123: if( p->n+1>=p->nAlloc ){ 15124: p->nAlloc += p->nAlloc + 100; 15125: p->z = sqlite3_realloc64(p->z, p->nAlloc); 15126: if( p->z==0 ) shell_out_of_memory(); 1.2 misho 15127: } 1.5 misho 15128: p->z[p->n++] = (char)c; 1.2 misho 15129: } 15130: 1.5 misho 15131: /* Read a single field of CSV text. Compatible with rfc4180 and extended 15132: ** with the option of having a separator other than ",". 1.2 misho 15133: ** 1.5 misho 15134: ** + Input comes from p->in. 15135: ** + Store results in p->z of length p->n. Space to hold p->z comes 15136: ** from sqlite3_malloc64(). 15137: ** + Use p->cSep as the column separator. The default is ",". 15138: ** + Use p->rSep as the row separator. The default is "\n". 15139: ** + Keep track of the line number in p->nLine. 15140: ** + Store the character that terminates the field in p->cTerm. Store 15141: ** EOF on end-of-file. 15142: ** + Report syntax errors on stderr 1.2 misho 15143: */ 1.5 misho 15144: static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){ 15145: int c; 15146: int cSep = p->cColSep; 15147: int rSep = p->cRowSep; 15148: p->n = 0; 15149: c = fgetc(p->in); 15150: if( c==EOF || seenInterrupt ){ 15151: p->cTerm = EOF; 1.2 misho 15152: return 0; 15153: } 1.5 misho 15154: if( c=='"' ){ 15155: int pc, ppc; 15156: int startLine = p->nLine; 15157: int cQuote = c; 15158: pc = ppc = 0; 15159: while( 1 ){ 15160: c = fgetc(p->in); 15161: if( c==rSep ) p->nLine++; 15162: if( c==cQuote ){ 15163: if( pc==cQuote ){ 15164: pc = 0; 15165: continue; 15166: } 15167: } 15168: if( (c==cSep && pc==cQuote) 15169: || (c==rSep && pc==cQuote) 15170: || (c==rSep && pc=='\r' && ppc==cQuote) 15171: || (c==EOF && pc==cQuote) 15172: ){ 15173: do{ p->n--; }while( p->z[p->n]!=cQuote ); 15174: p->cTerm = c; 15175: break; 15176: } 15177: if( pc==cQuote && c!='\r' ){ 15178: utf8_printf(stderr, "%s:%d: unescaped %c character\n", 15179: p->zFile, p->nLine, cQuote); 15180: } 15181: if( c==EOF ){ 15182: utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n", 15183: p->zFile, startLine, cQuote); 15184: p->cTerm = c; 15185: break; 15186: } 15187: import_append_char(p, c); 15188: ppc = pc; 15189: pc = c; 1.2 misho 15190: } 15191: }else{ 1.5 misho 15192: /* If this is the first field being parsed and it begins with the 15193: ** UTF-8 BOM (0xEF BB BF) then skip the BOM */ 15194: if( (c&0xff)==0xef && p->bNotFirst==0 ){ 15195: import_append_char(p, c); 15196: c = fgetc(p->in); 15197: if( (c&0xff)==0xbb ){ 15198: import_append_char(p, c); 15199: c = fgetc(p->in); 15200: if( (c&0xff)==0xbf ){ 15201: p->bNotFirst = 1; 15202: p->n = 0; 15203: return csv_read_one_field(p); 15204: } 15205: } 1.2 misho 15206: } 1.5 misho 15207: while( c!=EOF && c!=cSep && c!=rSep ){ 15208: import_append_char(p, c); 15209: c = fgetc(p->in); 1.3 misho 15210: } 1.5 misho 15211: if( c==rSep ){ 15212: p->nLine++; 15213: if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--; 1.4 misho 15214: } 1.5 misho 15215: p->cTerm = c; 1.2 misho 15216: } 1.5 misho 15217: if( p->z ) p->z[p->n] = 0; 15218: p->bNotFirst = 1; 15219: return p->z; 1.2 misho 15220: } 15221: 1.5 misho 15222: /* Read a single field of ASCII delimited text. 15223: ** 15224: ** + Input comes from p->in. 15225: ** + Store results in p->z of length p->n. Space to hold p->z comes 15226: ** from sqlite3_malloc64(). 15227: ** + Use p->cSep as the column separator. The default is "\x1F". 15228: ** + Use p->rSep as the row separator. The default is "\x1E". 15229: ** + Keep track of the row number in p->nLine. 15230: ** + Store the character that terminates the field in p->cTerm. Store 15231: ** EOF on end-of-file. 15232: ** + Report syntax errors on stderr 1.2 misho 15233: */ 1.5 misho 15234: static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){ 15235: int c; 15236: int cSep = p->cColSep; 15237: int rSep = p->cRowSep; 15238: p->n = 0; 15239: c = fgetc(p->in); 15240: if( c==EOF || seenInterrupt ){ 15241: p->cTerm = EOF; 15242: return 0; 15243: } 15244: while( c!=EOF && c!=cSep && c!=rSep ){ 15245: import_append_char(p, c); 15246: c = fgetc(p->in); 1.2 misho 15247: } 1.5 misho 15248: if( c==rSep ){ 15249: p->nLine++; 1.4 misho 15250: } 1.5 misho 15251: p->cTerm = c; 15252: if( p->z ) p->z[p->n] = 0; 15253: return p->z; 1.4 misho 15254: } 15255: 1.2 misho 15256: /* 1.5 misho 15257: ** Try to transfer data for table zTable. If an error is seen while 15258: ** moving forward, try to go backwards. The backwards movement won't 15259: ** work for WITHOUT ROWID tables. 1.2 misho 15260: */ 1.5 misho 15261: static void tryToCloneData( 15262: ShellState *p, 15263: sqlite3 *newDb, 15264: const char *zTable 1.2 misho 15265: ){ 1.5 misho 15266: sqlite3_stmt *pQuery = 0; 15267: sqlite3_stmt *pInsert = 0; 15268: char *zQuery = 0; 15269: char *zInsert = 0; 15270: int rc; 15271: int i, j, n; 15272: int nTable = strlen30(zTable); 15273: int k = 0; 15274: int cnt = 0; 15275: const int spinRate = 10000; 1.2 misho 15276: 1.5 misho 15277: zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); 15278: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 15279: if( rc ){ 15280: utf8_printf(stderr, "Error %d: %s on [%s]\n", 15281: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 15282: zQuery); 15283: goto end_data_xfer; 15284: } 15285: n = sqlite3_column_count(pQuery); 15286: zInsert = sqlite3_malloc64(200 + nTable + n*3); 15287: if( zInsert==0 ) shell_out_of_memory(); 15288: sqlite3_snprintf(200+nTable,zInsert, 15289: "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable); 15290: i = strlen30(zInsert); 15291: for(j=1; j<n; j++){ 15292: memcpy(zInsert+i, ",?", 2); 15293: i += 2; 15294: } 15295: memcpy(zInsert+i, ");", 3); 15296: rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0); 15297: if( rc ){ 15298: utf8_printf(stderr, "Error %d: %s on [%s]\n", 15299: sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), 15300: zQuery); 15301: goto end_data_xfer; 1.2 misho 15302: } 1.5 misho 15303: for(k=0; k<2; k++){ 15304: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 15305: for(i=0; i<n; i++){ 15306: switch( sqlite3_column_type(pQuery, i) ){ 15307: case SQLITE_NULL: { 15308: sqlite3_bind_null(pInsert, i+1); 15309: break; 15310: } 15311: case SQLITE_INTEGER: { 15312: sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i)); 15313: break; 15314: } 15315: case SQLITE_FLOAT: { 15316: sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i)); 15317: break; 15318: } 15319: case SQLITE_TEXT: { 15320: sqlite3_bind_text(pInsert, i+1, 15321: (const char*)sqlite3_column_text(pQuery,i), 15322: -1, SQLITE_STATIC); 15323: break; 15324: } 15325: case SQLITE_BLOB: { 15326: sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i), 15327: sqlite3_column_bytes(pQuery,i), 15328: SQLITE_STATIC); 15329: break; 15330: } 15331: } 15332: } /* End for */ 15333: rc = sqlite3_step(pInsert); 15334: if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){ 15335: utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb), 15336: sqlite3_errmsg(newDb)); 15337: } 15338: sqlite3_reset(pInsert); 15339: cnt++; 15340: if( (cnt%spinRate)==0 ){ 15341: printf("%c\b", "|/-\\"[(cnt/spinRate)%4]); 15342: fflush(stdout); 15343: } 15344: } /* End while */ 15345: if( rc==SQLITE_DONE ) break; 15346: sqlite3_finalize(pQuery); 15347: sqlite3_free(zQuery); 15348: zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;", 15349: zTable); 15350: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 15351: if( rc ){ 15352: utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable); 15353: break; 1.4 misho 15354: } 1.5 misho 15355: } /* End for(k=0...) */ 1.2 misho 15356: 1.5 misho 15357: end_data_xfer: 15358: sqlite3_finalize(pQuery); 15359: sqlite3_finalize(pInsert); 15360: sqlite3_free(zQuery); 15361: sqlite3_free(zInsert); 15362: } 1.4 misho 15363: 1.2 misho 15364: 15365: /* 1.5 misho 15366: ** Try to transfer all rows of the schema that match zWhere. For 15367: ** each row, invoke xForEach() on the object defined by that row. 15368: ** If an error is encountered while moving forward through the 15369: ** sqlite_schema table, try again moving backwards. 1.2 misho 15370: */ 1.5 misho 15371: static void tryToCloneSchema( 15372: ShellState *p, 15373: sqlite3 *newDb, 15374: const char *zWhere, 15375: void (*xForEach)(ShellState*,sqlite3*,const char*) 1.2 misho 15376: ){ 1.5 misho 15377: sqlite3_stmt *pQuery = 0; 15378: char *zQuery = 0; 15379: int rc; 15380: const unsigned char *zName; 15381: const unsigned char *zSql; 15382: char *zErrMsg = 0; 15383: 15384: zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema" 15385: " WHERE %s", zWhere); 15386: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 15387: if( rc ){ 15388: utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 15389: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 15390: zQuery); 15391: goto end_schema_xfer; 15392: } 15393: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 15394: zName = sqlite3_column_text(pQuery, 0); 15395: zSql = sqlite3_column_text(pQuery, 1); 15396: printf("%s... ", zName); fflush(stdout); 15397: sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 15398: if( zErrMsg ){ 15399: utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 15400: sqlite3_free(zErrMsg); 15401: zErrMsg = 0; 15402: } 15403: if( xForEach ){ 15404: xForEach(p, newDb, (const char*)zName); 15405: } 15406: printf("done\n"); 15407: } 15408: if( rc!=SQLITE_DONE ){ 15409: sqlite3_finalize(pQuery); 15410: sqlite3_free(zQuery); 15411: zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema" 15412: " WHERE %s ORDER BY rowid DESC", zWhere); 15413: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); 15414: if( rc ){ 15415: utf8_printf(stderr, "Error: (%d) %s on [%s]\n", 15416: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), 15417: zQuery); 15418: goto end_schema_xfer; 15419: } 15420: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ 15421: zName = sqlite3_column_text(pQuery, 0); 15422: zSql = sqlite3_column_text(pQuery, 1); 15423: printf("%s... ", zName); fflush(stdout); 15424: sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); 15425: if( zErrMsg ){ 15426: utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); 15427: sqlite3_free(zErrMsg); 15428: zErrMsg = 0; 1.2 misho 15429: } 1.5 misho 15430: if( xForEach ){ 15431: xForEach(p, newDb, (const char*)zName); 1.2 misho 15432: } 1.5 misho 15433: printf("done\n"); 1.4 misho 15434: } 15435: } 1.5 misho 15436: end_schema_xfer: 15437: sqlite3_finalize(pQuery); 15438: sqlite3_free(zQuery); 1.4 misho 15439: } 1.2 misho 15440: 1.4 misho 15441: /* 1.5 misho 15442: ** Open a new database file named "zNewDb". Try to recover as much information 15443: ** as possible out of the main database (which might be corrupt) and write it 15444: ** into zNewDb. 1.4 misho 15445: */ 1.5 misho 15446: static void tryToClone(ShellState *p, const char *zNewDb){ 15447: int rc; 15448: sqlite3 *newDb = 0; 15449: if( access(zNewDb,0)==0 ){ 15450: utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb); 1.4 misho 15451: return; 15452: } 1.5 misho 15453: rc = sqlite3_open(zNewDb, &newDb); 15454: if( rc ){ 15455: utf8_printf(stderr, "Cannot create output database: %s\n", 15456: sqlite3_errmsg(newDb)); 15457: }else{ 15458: sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0); 15459: sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0); 15460: tryToCloneSchema(p, newDb, "type='table'", tryToCloneData); 15461: tryToCloneSchema(p, newDb, "type!='table'", 0); 15462: sqlite3_exec(newDb, "COMMIT;", 0, 0, 0); 15463: sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 1.4 misho 15464: } 1.5 misho 15465: close_db(newDb); 1.4 misho 15466: } 15467: 15468: /* 1.5 misho 15469: ** Change the output file back to stdout. 15470: ** 15471: ** If the p->doXdgOpen flag is set, that means the output was being 15472: ** redirected to a temporary file named by p->zTempFile. In that case, 15473: ** launch start/open/xdg-open on that temporary file. 1.4 misho 15474: */ 1.5 misho 15475: static void output_reset(ShellState *p){ 15476: if( p->outfile[0]=='|' ){ 15477: #ifndef SQLITE_OMIT_POPEN 15478: pclose(p->out); 15479: #endif 15480: }else{ 15481: output_file_close(p->out); 15482: #ifndef SQLITE_NOHAVE_SYSTEM 15483: if( p->doXdgOpen ){ 15484: const char *zXdgOpenCmd = 15485: #if defined(_WIN32) 15486: "start"; 15487: #elif defined(__APPLE__) 15488: "open"; 15489: #else 15490: "xdg-open"; 15491: #endif 15492: char *zCmd; 15493: zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile); 15494: if( system(zCmd) ){ 15495: utf8_printf(stderr, "Failed: [%s]\n", zCmd); 15496: }else{ 15497: /* Give the start/open/xdg-open command some time to get 15498: ** going before we continue, and potential delete the 15499: ** p->zTempFile data file out from under it */ 15500: sqlite3_sleep(2000); 15501: } 15502: sqlite3_free(zCmd); 15503: outputModePop(p); 15504: p->doXdgOpen = 0; 15505: } 15506: #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 15507: } 15508: p->outfile[0] = 0; 15509: p->out = stdout; 1.4 misho 15510: } 15511: 15512: /* 1.5 misho 15513: ** Run an SQL command and return the single integer result. 1.4 misho 15514: */ 1.5 misho 15515: static int db_int(ShellState *p, const char *zSql){ 15516: sqlite3_stmt *pStmt; 15517: int res = 0; 15518: sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 15519: if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ 15520: res = sqlite3_column_int(pStmt,0); 15521: } 15522: sqlite3_finalize(pStmt); 15523: return res; 1.4 misho 15524: } 15525: 15526: /* 1.5 misho 15527: ** Convert a 2-byte or 4-byte big-endian integer into a native integer 1.4 misho 15528: */ 1.5 misho 15529: static unsigned int get2byteInt(unsigned char *a){ 15530: return (a[0]<<8) + a[1]; 15531: } 15532: static unsigned int get4byteInt(unsigned char *a){ 15533: return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3]; 1.4 misho 15534: } 15535: 15536: /* 1.5 misho 15537: ** Implementation of the ".dbinfo" command. 1.4 misho 15538: ** 1.5 misho 15539: ** Return 1 on error, 2 to exit, and 0 otherwise. 1.4 misho 15540: */ 1.5 misho 15541: static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){ 15542: static const struct { const char *zName; int ofst; } aField[] = { 15543: { "file change counter:", 24 }, 15544: { "database page count:", 28 }, 15545: { "freelist page count:", 36 }, 15546: { "schema cookie:", 40 }, 15547: { "schema format:", 44 }, 15548: { "default cache size:", 48 }, 15549: { "autovacuum top root:", 52 }, 15550: { "incremental vacuum:", 64 }, 15551: { "text encoding:", 56 }, 15552: { "user version:", 60 }, 15553: { "application id:", 68 }, 15554: { "software version:", 96 }, 15555: }; 15556: static const struct { const char *zName; const char *zSql; } aQuery[] = { 15557: { "number of tables:", 15558: "SELECT count(*) FROM %s WHERE type='table'" }, 15559: { "number of indexes:", 15560: "SELECT count(*) FROM %s WHERE type='index'" }, 15561: { "number of triggers:", 15562: "SELECT count(*) FROM %s WHERE type='trigger'" }, 15563: { "number of views:", 15564: "SELECT count(*) FROM %s WHERE type='view'" }, 15565: { "schema size:", 15566: "SELECT total(length(sql)) FROM %s" }, 15567: }; 15568: int i, rc; 15569: unsigned iDataVersion; 15570: char *zSchemaTab; 15571: char *zDb = nArg>=2 ? azArg[1] : "main"; 15572: sqlite3_stmt *pStmt = 0; 15573: unsigned char aHdr[100]; 15574: open_db(p, 0); 15575: if( p->db==0 ) return 1; 15576: rc = sqlite3_prepare_v2(p->db, 15577: "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1", 15578: -1, &pStmt, 0); 15579: if( rc ){ 15580: utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db)); 15581: sqlite3_finalize(pStmt); 15582: return 1; 15583: } 15584: sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC); 15585: if( sqlite3_step(pStmt)==SQLITE_ROW 15586: && sqlite3_column_bytes(pStmt,0)>100 15587: ){ 15588: memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100); 15589: sqlite3_finalize(pStmt); 15590: }else{ 15591: raw_printf(stderr, "unable to read database header\n"); 15592: sqlite3_finalize(pStmt); 15593: return 1; 1.4 misho 15594: } 1.5 misho 15595: i = get2byteInt(aHdr+16); 15596: if( i==1 ) i = 65536; 15597: utf8_printf(p->out, "%-20s %d\n", "database page size:", i); 15598: utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]); 15599: utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]); 15600: utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]); 15601: for(i=0; i<ArraySize(aField); i++){ 15602: int ofst = aField[i].ofst; 15603: unsigned int val = get4byteInt(aHdr + ofst); 15604: utf8_printf(p->out, "%-20s %u", aField[i].zName, val); 15605: switch( ofst ){ 15606: case 56: { 15607: if( val==1 ) raw_printf(p->out, " (utf8)"); 15608: if( val==2 ) raw_printf(p->out, " (utf16le)"); 15609: if( val==3 ) raw_printf(p->out, " (utf16be)"); 1.2 misho 15610: } 15611: } 1.5 misho 15612: raw_printf(p->out, "\n"); 15613: } 15614: if( zDb==0 ){ 15615: zSchemaTab = sqlite3_mprintf("main.sqlite_schema"); 15616: }else if( strcmp(zDb,"temp")==0 ){ 15617: zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_schema"); 15618: }else{ 15619: zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_schema", zDb); 15620: } 15621: for(i=0; i<ArraySize(aQuery); i++){ 15622: char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab); 15623: int val = db_int(p, zSql); 15624: sqlite3_free(zSql); 15625: utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val); 15626: } 15627: sqlite3_free(zSchemaTab); 15628: sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion); 15629: utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion); 15630: return 0; 1.2 misho 15631: } 15632: 15633: /* 1.5 misho 15634: ** Print the current sqlite3_errmsg() value to stderr and return 1. 1.2 misho 15635: */ 1.5 misho 15636: static int shellDatabaseError(sqlite3 *db){ 15637: const char *zErr = sqlite3_errmsg(db); 15638: utf8_printf(stderr, "Error: %s\n", zErr); 15639: return 1; 1.2 misho 15640: } 15641: 15642: /* 1.5 misho 15643: ** Compare the pattern in zGlob[] against the text in z[]. Return TRUE 15644: ** if they match and FALSE (0) if they do not match. 15645: ** 15646: ** Globbing rules: 15647: ** 15648: ** '*' Matches any sequence of zero or more characters. 15649: ** 15650: ** '?' Matches exactly one character. 15651: ** 15652: ** [...] Matches one character from the enclosed list of 15653: ** characters. 15654: ** 15655: ** [^...] Matches one character not in the enclosed list. 15656: ** 15657: ** '#' Matches any sequence of one or more digits with an 15658: ** optional + or - sign in front 15659: ** 15660: ** ' ' Any span of whitespace matches any other span of 15661: ** whitespace. 1.2 misho 15662: ** 1.5 misho 15663: ** Extra whitespace at the end of z[] is ignored. 1.2 misho 15664: */ 1.5 misho 15665: static int testcase_glob(const char *zGlob, const char *z){ 15666: int c, c2; 15667: int invert; 15668: int seen; 15669: 15670: while( (c = (*(zGlob++)))!=0 ){ 15671: if( IsSpace(c) ){ 15672: if( !IsSpace(*z) ) return 0; 15673: while( IsSpace(*zGlob) ) zGlob++; 15674: while( IsSpace(*z) ) z++; 15675: }else if( c=='*' ){ 15676: while( (c=(*(zGlob++))) == '*' || c=='?' ){ 15677: if( c=='?' && (*(z++))==0 ) return 0; 15678: } 15679: if( c==0 ){ 15680: return 1; 15681: }else if( c=='[' ){ 15682: while( *z && testcase_glob(zGlob-1,z)==0 ){ 15683: z++; 15684: } 15685: return (*z)!=0; 15686: } 15687: while( (c2 = (*(z++)))!=0 ){ 15688: while( c2!=c ){ 15689: c2 = *(z++); 15690: if( c2==0 ) return 0; 15691: } 15692: if( testcase_glob(zGlob,z) ) return 1; 15693: } 15694: return 0; 15695: }else if( c=='?' ){ 15696: if( (*(z++))==0 ) return 0; 15697: }else if( c=='[' ){ 15698: int prior_c = 0; 15699: seen = 0; 15700: invert = 0; 15701: c = *(z++); 15702: if( c==0 ) return 0; 15703: c2 = *(zGlob++); 15704: if( c2=='^' ){ 15705: invert = 1; 15706: c2 = *(zGlob++); 15707: } 15708: if( c2==']' ){ 15709: if( c==']' ) seen = 1; 15710: c2 = *(zGlob++); 15711: } 15712: while( c2 && c2!=']' ){ 15713: if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){ 15714: c2 = *(zGlob++); 15715: if( c>=prior_c && c<=c2 ) seen = 1; 15716: prior_c = 0; 15717: }else{ 15718: if( c==c2 ){ 15719: seen = 1; 15720: } 15721: prior_c = c2; 15722: } 15723: c2 = *(zGlob++); 15724: } 15725: if( c2==0 || (seen ^ invert)==0 ) return 0; 15726: }else if( c=='#' ){ 15727: if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++; 15728: if( !IsDigit(z[0]) ) return 0; 15729: z++; 15730: while( IsDigit(z[0]) ){ z++; } 1.2 misho 15731: }else{ 1.5 misho 15732: if( c!=(*(z++)) ) return 0; 1.2 misho 15733: } 15734: } 1.5 misho 15735: while( IsSpace(*z) ){ z++; } 15736: return *z==0; 1.2 misho 15737: } 15738: 1.5 misho 15739: 1.2 misho 15740: /* 1.5 misho 15741: ** Compare the string as a command-line option with either one or two 15742: ** initial "-" characters. 1.2 misho 15743: */ 1.5 misho 15744: static int optionMatch(const char *zStr, const char *zOpt){ 15745: if( zStr[0]!='-' ) return 0; 15746: zStr++; 15747: if( zStr[0]=='-' ) zStr++; 15748: return strcmp(zStr, zOpt)==0; 15749: } 1.2 misho 15750: 1.4 misho 15751: /* 1.5 misho 15752: ** Delete a file. 1.4 misho 15753: */ 1.5 misho 15754: int shellDeleteFile(const char *zFilename){ 15755: int rc; 15756: #ifdef _WIN32 15757: wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename); 15758: rc = _wunlink(z); 15759: sqlite3_free(z); 15760: #else 15761: rc = unlink(zFilename); 15762: #endif 15763: return rc; 1.4 misho 15764: } 15765: 15766: /* 1.5 misho 15767: ** Try to delete the temporary file (if there is one) and free the 15768: ** memory used to hold the name of the temp file. 1.4 misho 15769: */ 1.5 misho 15770: static void clearTempFile(ShellState *p){ 15771: if( p->zTempFile==0 ) return; 15772: if( p->doXdgOpen ) return; 15773: if( shellDeleteFile(p->zTempFile) ) return; 15774: sqlite3_free(p->zTempFile); 15775: p->zTempFile = 0; 15776: } 1.4 misho 15777: 1.5 misho 15778: /* 15779: ** Create a new temp file name with the given suffix. 15780: */ 15781: static void newTempFile(ShellState *p, const char *zSuffix){ 15782: clearTempFile(p); 15783: sqlite3_free(p->zTempFile); 15784: p->zTempFile = 0; 15785: if( p->db ){ 15786: sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile); 15787: } 15788: if( p->zTempFile==0 ){ 15789: /* If p->db is an in-memory database then the TEMPFILENAME file-control 15790: ** will not work and we will need to fallback to guessing */ 15791: char *zTemp; 15792: sqlite3_uint64 r; 15793: sqlite3_randomness(sizeof(r), &r); 15794: zTemp = getenv("TEMP"); 15795: if( zTemp==0 ) zTemp = getenv("TMP"); 15796: if( zTemp==0 ){ 15797: #ifdef _WIN32 15798: zTemp = "\\tmp"; 15799: #else 15800: zTemp = "/tmp"; 15801: #endif 15802: } 15803: p->zTempFile = sqlite3_mprintf("%s/temp%llx.%s", zTemp, r, zSuffix); 1.4 misho 15804: }else{ 1.5 misho 15805: p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix); 15806: } 15807: if( p->zTempFile==0 ){ 15808: raw_printf(stderr, "out of memory\n"); 15809: exit(1); 1.4 misho 15810: } 15811: } 15812: 1.5 misho 15813: 1.4 misho 15814: /* 1.5 misho 15815: ** The implementation of SQL scalar function fkey_collate_clause(), used 15816: ** by the ".lint fkey-indexes" command. This scalar function is always 15817: ** called with four arguments - the parent table name, the parent column name, 15818: ** the child table name and the child column name. 15819: ** 15820: ** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col') 15821: ** 15822: ** If either of the named tables or columns do not exist, this function 15823: ** returns an empty string. An empty string is also returned if both tables 15824: ** and columns exist but have the same default collation sequence. Or, 15825: ** if both exist but the default collation sequences are different, this 15826: ** function returns the string " COLLATE <parent-collation>", where 15827: ** <parent-collation> is the default collation sequence of the parent column. 15828: */ 15829: static void shellFkeyCollateClause( 15830: sqlite3_context *pCtx, 15831: int nVal, 15832: sqlite3_value **apVal 1.4 misho 15833: ){ 1.5 misho 15834: sqlite3 *db = sqlite3_context_db_handle(pCtx); 15835: const char *zParent; 15836: const char *zParentCol; 15837: const char *zParentSeq; 15838: const char *zChild; 15839: const char *zChildCol; 15840: const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */ 15841: int rc; 15842: 15843: assert( nVal==4 ); 15844: zParent = (const char*)sqlite3_value_text(apVal[0]); 15845: zParentCol = (const char*)sqlite3_value_text(apVal[1]); 15846: zChild = (const char*)sqlite3_value_text(apVal[2]); 15847: zChildCol = (const char*)sqlite3_value_text(apVal[3]); 15848: 15849: sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC); 15850: rc = sqlite3_table_column_metadata( 15851: db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0 15852: ); 15853: if( rc==SQLITE_OK ){ 15854: rc = sqlite3_table_column_metadata( 15855: db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0 15856: ); 15857: } 1.4 misho 15858: 1.5 misho 15859: if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){ 15860: char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq); 15861: sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT); 15862: sqlite3_free(z); 1.4 misho 15863: } 15864: } 15865: 1.5 misho 15866: 1.4 misho 15867: /* 1.5 misho 15868: ** The implementation of dot-command ".lint fkey-indexes". 1.4 misho 15869: */ 1.5 misho 15870: static int lintFkeyIndexes( 15871: ShellState *pState, /* Current shell tool state */ 15872: char **azArg, /* Array of arguments passed to dot command */ 15873: int nArg /* Number of entries in azArg[] */ 15874: ){ 15875: sqlite3 *db = pState->db; /* Database handle to query "main" db of */ 15876: FILE *out = pState->out; /* Stream to write non-error output to */ 15877: int bVerbose = 0; /* If -verbose is present */ 15878: int bGroupByParent = 0; /* If -groupbyparent is present */ 15879: int i; /* To iterate through azArg[] */ 15880: const char *zIndent = ""; /* How much to indent CREATE INDEX by */ 15881: int rc; /* Return code */ 15882: sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */ 15883: 15884: /* 15885: ** This SELECT statement returns one row for each foreign key constraint 15886: ** in the schema of the main database. The column values are: 15887: ** 15888: ** 0. The text of an SQL statement similar to: 15889: ** 15890: ** "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?" 15891: ** 15892: ** This SELECT is similar to the one that the foreign keys implementation 15893: ** needs to run internally on child tables. If there is an index that can 15894: ** be used to optimize this query, then it can also be used by the FK 15895: ** implementation to optimize DELETE or UPDATE statements on the parent 15896: ** table. 15897: ** 15898: ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by 15899: ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema 15900: ** contains an index that can be used to optimize the query. 15901: ** 15902: ** 2. Human readable text that describes the child table and columns. e.g. 15903: ** 15904: ** "child_table(child_key1, child_key2)" 15905: ** 15906: ** 3. Human readable text that describes the parent table and columns. e.g. 15907: ** 15908: ** "parent_table(parent_key1, parent_key2)" 15909: ** 15910: ** 4. A full CREATE INDEX statement for an index that could be used to 15911: ** optimize DELETE or UPDATE statements on the parent table. e.g. 15912: ** 15913: ** "CREATE INDEX child_table_child_key ON child_table(child_key)" 15914: ** 15915: ** 5. The name of the parent table. 15916: ** 15917: ** These six values are used by the C logic below to generate the report. 15918: */ 15919: const char *zSql = 15920: "SELECT " 15921: " 'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '" 15922: " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' " 15923: " || fkey_collate_clause(" 15924: " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')" 15925: ", " 15926: " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('" 15927: " || group_concat('*=?', ' AND ') || ')'" 15928: ", " 15929: " s.name || '(' || group_concat(f.[from], ', ') || ')'" 15930: ", " 15931: " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'" 15932: ", " 15933: " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))" 15934: " || ' ON ' || quote(s.name) || '('" 15935: " || group_concat(quote(f.[from]) ||" 15936: " fkey_collate_clause(" 15937: " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')" 15938: " || ');'" 15939: ", " 15940: " f.[table] " 15941: "FROM sqlite_schema AS s, pragma_foreign_key_list(s.name) AS f " 15942: "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) " 15943: "GROUP BY s.name, f.id " 15944: "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)" 15945: ; 15946: const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)"; 15947: 15948: for(i=2; i<nArg; i++){ 15949: int n = strlen30(azArg[i]); 15950: if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){ 15951: bVerbose = 1; 15952: } 15953: else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){ 15954: bGroupByParent = 1; 15955: zIndent = " "; 15956: } 15957: else{ 15958: raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n", 15959: azArg[0], azArg[1] 15960: ); 15961: return SQLITE_ERROR; 15962: } 15963: } 15964: 15965: /* Register the fkey_collate_clause() SQL function */ 15966: rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8, 15967: 0, shellFkeyCollateClause, 0, 0 15968: ); 15969: 15970: 15971: if( rc==SQLITE_OK ){ 15972: rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0); 15973: } 15974: if( rc==SQLITE_OK ){ 15975: sqlite3_bind_int(pSql, 1, bGroupByParent); 1.4 misho 15976: } 15977: 1.5 misho 15978: if( rc==SQLITE_OK ){ 15979: int rc2; 15980: char *zPrev = 0; 15981: while( SQLITE_ROW==sqlite3_step(pSql) ){ 15982: int res = -1; 15983: sqlite3_stmt *pExplain = 0; 15984: const char *zEQP = (const char*)sqlite3_column_text(pSql, 0); 15985: const char *zGlob = (const char*)sqlite3_column_text(pSql, 1); 15986: const char *zFrom = (const char*)sqlite3_column_text(pSql, 2); 15987: const char *zTarget = (const char*)sqlite3_column_text(pSql, 3); 15988: const char *zCI = (const char*)sqlite3_column_text(pSql, 4); 15989: const char *zParent = (const char*)sqlite3_column_text(pSql, 5); 15990: 15991: rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); 15992: if( rc!=SQLITE_OK ) break; 15993: if( SQLITE_ROW==sqlite3_step(pExplain) ){ 15994: const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3); 15995: res = ( 15996: 0==sqlite3_strglob(zGlob, zPlan) 15997: || 0==sqlite3_strglob(zGlobIPK, zPlan) 15998: ); 15999: } 16000: rc = sqlite3_finalize(pExplain); 16001: if( rc!=SQLITE_OK ) break; 16002: 16003: if( res<0 ){ 16004: raw_printf(stderr, "Error: internal error"); 16005: break; 16006: }else{ 16007: if( bGroupByParent 16008: && (bVerbose || res==0) 16009: && (zPrev==0 || sqlite3_stricmp(zParent, zPrev)) 16010: ){ 16011: raw_printf(out, "-- Parent table %s\n", zParent); 16012: sqlite3_free(zPrev); 16013: zPrev = sqlite3_mprintf("%s", zParent); 16014: } 16015: 16016: if( res==0 ){ 16017: raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget); 16018: }else if( bVerbose ){ 16019: raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n", 16020: zIndent, zFrom, zTarget 16021: ); 16022: } 16023: } 16024: } 16025: sqlite3_free(zPrev); 16026: 16027: if( rc!=SQLITE_OK ){ 16028: raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 16029: } 16030: 16031: rc2 = sqlite3_finalize(pSql); 16032: if( rc==SQLITE_OK && rc2!=SQLITE_OK ){ 16033: rc = rc2; 16034: raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 16035: } 16036: }else{ 16037: raw_printf(stderr, "%s\n", sqlite3_errmsg(db)); 1.4 misho 16038: } 1.5 misho 16039: 16040: return rc; 1.4 misho 16041: } 16042: 16043: /* 1.5 misho 16044: ** Implementation of ".lint" dot command. 1.4 misho 16045: */ 1.5 misho 16046: static int lintDotCommand( 16047: ShellState *pState, /* Current shell tool state */ 16048: char **azArg, /* Array of arguments passed to dot command */ 16049: int nArg /* Number of entries in azArg[] */ 16050: ){ 16051: int n; 16052: n = (nArg>=2 ? strlen30(azArg[1]) : 0); 16053: if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage; 16054: return lintFkeyIndexes(pState, azArg, nArg); 16055: 16056: usage: 16057: raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]); 16058: raw_printf(stderr, "Where sub-commands are:\n"); 16059: raw_printf(stderr, " fkey-indexes\n"); 16060: return SQLITE_ERROR; 16061: } 16062: 16063: #if !defined SQLITE_OMIT_VIRTUALTABLE 16064: static void shellPrepare( 16065: sqlite3 *db, 16066: int *pRc, 16067: const char *zSql, 16068: sqlite3_stmt **ppStmt 16069: ){ 16070: *ppStmt = 0; 16071: if( *pRc==SQLITE_OK ){ 16072: int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); 16073: if( rc!=SQLITE_OK ){ 16074: raw_printf(stderr, "sql error: %s (%d)\n", 16075: sqlite3_errmsg(db), sqlite3_errcode(db) 16076: ); 16077: *pRc = rc; 16078: } 1.4 misho 16079: } 16080: } 1.2 misho 16081: 16082: /* 1.5 misho 16083: ** Create a prepared statement using printf-style arguments for the SQL. 16084: ** 16085: ** This routine is could be marked "static". But it is not always used, 16086: ** depending on compile-time options. By omitting the "static", we avoid 16087: ** nuisance compiler warnings about "defined but not used". 16088: */ 16089: void shellPreparePrintf( 16090: sqlite3 *db, 16091: int *pRc, 16092: sqlite3_stmt **ppStmt, 16093: const char *zFmt, 16094: ... 16095: ){ 16096: *ppStmt = 0; 16097: if( *pRc==SQLITE_OK ){ 16098: va_list ap; 16099: char *z; 16100: va_start(ap, zFmt); 16101: z = sqlite3_vmprintf(zFmt, ap); 16102: va_end(ap); 16103: if( z==0 ){ 16104: *pRc = SQLITE_NOMEM; 16105: }else{ 16106: shellPrepare(db, pRc, z, ppStmt); 16107: sqlite3_free(z); 1.2 misho 16108: } 1.5 misho 16109: } 16110: } 16111: 16112: /* Finalize the prepared statement created using shellPreparePrintf(). 16113: ** 16114: ** This routine is could be marked "static". But it is not always used, 16115: ** depending on compile-time options. By omitting the "static", we avoid 16116: ** nuisance compiler warnings about "defined but not used". 16117: */ 16118: void shellFinalize( 16119: int *pRc, 16120: sqlite3_stmt *pStmt 16121: ){ 16122: if( pStmt ){ 16123: sqlite3 *db = sqlite3_db_handle(pStmt); 16124: int rc = sqlite3_finalize(pStmt); 16125: if( *pRc==SQLITE_OK ){ 16126: if( rc!=SQLITE_OK ){ 16127: raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 16128: } 16129: *pRc = rc; 1.2 misho 16130: } 16131: } 16132: } 16133: 1.5 misho 16134: /* Reset the prepared statement created using shellPreparePrintf(). 1.2 misho 16135: ** 1.5 misho 16136: ** This routine is could be marked "static". But it is not always used, 16137: ** depending on compile-time options. By omitting the "static", we avoid 16138: ** nuisance compiler warnings about "defined but not used". 16139: */ 16140: void shellReset( 16141: int *pRc, 16142: sqlite3_stmt *pStmt 16143: ){ 16144: int rc = sqlite3_reset(pStmt); 16145: if( *pRc==SQLITE_OK ){ 16146: if( rc!=SQLITE_OK ){ 16147: sqlite3 *db = sqlite3_db_handle(pStmt); 16148: raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db)); 1.2 misho 16149: } 1.5 misho 16150: *pRc = rc; 1.2 misho 16151: } 1.4 misho 16152: } 1.5 misho 16153: #endif /* !defined SQLITE_OMIT_VIRTUALTABLE */ 16154: 16155: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 16156: /****************************************************************************** 16157: ** The ".archive" or ".ar" command. 16158: */ 16159: /* 16160: ** Structure representing a single ".ar" command. 16161: */ 16162: typedef struct ArCommand ArCommand; 16163: struct ArCommand { 16164: u8 eCmd; /* An AR_CMD_* value */ 16165: u8 bVerbose; /* True if --verbose */ 16166: u8 bZip; /* True if the archive is a ZIP */ 16167: u8 bDryRun; /* True if --dry-run */ 16168: u8 bAppend; /* True if --append */ 16169: u8 fromCmdLine; /* Run from -A instead of .archive */ 16170: int nArg; /* Number of command arguments */ 16171: char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */ 16172: const char *zFile; /* --file argument, or NULL */ 16173: const char *zDir; /* --directory argument, or NULL */ 16174: char **azArg; /* Array of command arguments */ 16175: ShellState *p; /* Shell state */ 16176: sqlite3 *db; /* Database containing the archive */ 16177: }; 1.4 misho 16178: 16179: /* 1.5 misho 16180: ** Print a usage message for the .ar command to stderr and return SQLITE_ERROR. 1.4 misho 16181: */ 1.5 misho 16182: static int arUsage(FILE *f){ 16183: showHelp(f,"archive"); 16184: return SQLITE_ERROR; 1.4 misho 16185: } 16186: 16187: /* 1.5 misho 16188: ** Print an error message for the .ar command to stderr and return 16189: ** SQLITE_ERROR. 1.4 misho 16190: */ 1.5 misho 16191: static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){ 16192: va_list ap; 16193: char *z; 16194: va_start(ap, zFmt); 16195: z = sqlite3_vmprintf(zFmt, ap); 16196: va_end(ap); 16197: utf8_printf(stderr, "Error: %s\n", z); 16198: if( pAr->fromCmdLine ){ 16199: utf8_printf(stderr, "Use \"-A\" for more help\n"); 1.4 misho 16200: }else{ 1.5 misho 16201: utf8_printf(stderr, "Use \".archive --help\" for more help\n"); 1.4 misho 16202: } 1.5 misho 16203: sqlite3_free(z); 16204: return SQLITE_ERROR; 16205: } 16206: 16207: /* 16208: ** Values for ArCommand.eCmd. 16209: */ 16210: #define AR_CMD_CREATE 1 16211: #define AR_CMD_UPDATE 2 16212: #define AR_CMD_INSERT 3 16213: #define AR_CMD_EXTRACT 4 16214: #define AR_CMD_LIST 5 16215: #define AR_CMD_HELP 6 16216: 16217: /* 16218: ** Other (non-command) switches. 16219: */ 16220: #define AR_SWITCH_VERBOSE 7 16221: #define AR_SWITCH_FILE 8 16222: #define AR_SWITCH_DIRECTORY 9 16223: #define AR_SWITCH_APPEND 10 16224: #define AR_SWITCH_DRYRUN 11 16225: 16226: static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){ 16227: switch( eSwitch ){ 16228: case AR_CMD_CREATE: 16229: case AR_CMD_EXTRACT: 16230: case AR_CMD_LIST: 16231: case AR_CMD_UPDATE: 16232: case AR_CMD_INSERT: 16233: case AR_CMD_HELP: 16234: if( pAr->eCmd ){ 16235: return arErrorMsg(pAr, "multiple command options"); 16236: } 16237: pAr->eCmd = eSwitch; 16238: break; 16239: 16240: case AR_SWITCH_DRYRUN: 16241: pAr->bDryRun = 1; 16242: break; 16243: case AR_SWITCH_VERBOSE: 16244: pAr->bVerbose = 1; 16245: break; 16246: case AR_SWITCH_APPEND: 16247: pAr->bAppend = 1; 16248: /* Fall thru into --file */ 16249: case AR_SWITCH_FILE: 16250: pAr->zFile = zArg; 16251: break; 16252: case AR_SWITCH_DIRECTORY: 16253: pAr->zDir = zArg; 1.4 misho 16254: break; 16255: } 1.5 misho 16256: 16257: return SQLITE_OK; 1.2 misho 16258: } 16259: 16260: /* 1.5 misho 16261: ** Parse the command line for an ".ar" command. The results are written into 16262: ** structure (*pAr). SQLITE_OK is returned if the command line is parsed 16263: ** successfully, otherwise an error message is written to stderr and 16264: ** SQLITE_ERROR returned. 16265: */ 16266: static int arParseCommand( 16267: char **azArg, /* Array of arguments passed to dot command */ 16268: int nArg, /* Number of entries in azArg[] */ 16269: ArCommand *pAr /* Populate this object */ 16270: ){ 16271: struct ArSwitch { 16272: const char *zLong; 16273: char cShort; 16274: u8 eSwitch; 16275: u8 bArg; 16276: } aSwitch[] = { 16277: { "create", 'c', AR_CMD_CREATE, 0 }, 16278: { "extract", 'x', AR_CMD_EXTRACT, 0 }, 16279: { "insert", 'i', AR_CMD_INSERT, 0 }, 16280: { "list", 't', AR_CMD_LIST, 0 }, 16281: { "update", 'u', AR_CMD_UPDATE, 0 }, 16282: { "help", 'h', AR_CMD_HELP, 0 }, 16283: { "verbose", 'v', AR_SWITCH_VERBOSE, 0 }, 16284: { "file", 'f', AR_SWITCH_FILE, 1 }, 16285: { "append", 'a', AR_SWITCH_APPEND, 1 }, 16286: { "directory", 'C', AR_SWITCH_DIRECTORY, 1 }, 16287: { "dryrun", 'n', AR_SWITCH_DRYRUN, 0 }, 16288: }; 16289: int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch); 16290: struct ArSwitch *pEnd = &aSwitch[nSwitch]; 16291: 16292: if( nArg<=1 ){ 16293: utf8_printf(stderr, "Wrong number of arguments. Usage:\n"); 16294: return arUsage(stderr); 1.4 misho 16295: }else{ 1.5 misho 16296: char *z = azArg[1]; 16297: if( z[0]!='-' ){ 16298: /* Traditional style [tar] invocation */ 16299: int i; 16300: int iArg = 2; 16301: for(i=0; z[i]; i++){ 16302: const char *zArg = 0; 16303: struct ArSwitch *pOpt; 16304: for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 16305: if( z[i]==pOpt->cShort ) break; 16306: } 16307: if( pOpt==pEnd ){ 16308: return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 16309: } 16310: if( pOpt->bArg ){ 16311: if( iArg>=nArg ){ 16312: return arErrorMsg(pAr, "option requires an argument: %c",z[i]); 16313: } 16314: zArg = azArg[iArg++]; 16315: } 16316: if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 16317: } 16318: pAr->nArg = nArg-iArg; 16319: if( pAr->nArg>0 ){ 16320: pAr->azArg = &azArg[iArg]; 16321: } 16322: }else{ 16323: /* Non-traditional invocation */ 16324: int iArg; 16325: for(iArg=1; iArg<nArg; iArg++){ 16326: int n; 16327: z = azArg[iArg]; 16328: if( z[0]!='-' ){ 16329: /* All remaining command line words are command arguments. */ 16330: pAr->azArg = &azArg[iArg]; 16331: pAr->nArg = nArg-iArg; 16332: break; 16333: } 16334: n = strlen30(z); 16335: 16336: if( z[1]!='-' ){ 16337: int i; 16338: /* One or more short options */ 16339: for(i=1; i<n; i++){ 16340: const char *zArg = 0; 16341: struct ArSwitch *pOpt; 16342: for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 16343: if( z[i]==pOpt->cShort ) break; 16344: } 16345: if( pOpt==pEnd ){ 16346: return arErrorMsg(pAr, "unrecognized option: %c", z[i]); 16347: } 16348: if( pOpt->bArg ){ 16349: if( i<(n-1) ){ 16350: zArg = &z[i+1]; 16351: i = n; 16352: }else{ 16353: if( iArg>=(nArg-1) ){ 16354: return arErrorMsg(pAr, "option requires an argument: %c", 16355: z[i]); 16356: } 16357: zArg = azArg[++iArg]; 16358: } 16359: } 16360: if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR; 16361: } 16362: }else if( z[2]=='\0' ){ 16363: /* A -- option, indicating that all remaining command line words 16364: ** are command arguments. */ 16365: pAr->azArg = &azArg[iArg+1]; 16366: pAr->nArg = nArg-iArg-1; 16367: break; 16368: }else{ 16369: /* A long option */ 16370: const char *zArg = 0; /* Argument for option, if any */ 16371: struct ArSwitch *pMatch = 0; /* Matching option */ 16372: struct ArSwitch *pOpt; /* Iterator */ 16373: for(pOpt=&aSwitch[0]; pOpt<pEnd; pOpt++){ 16374: const char *zLong = pOpt->zLong; 16375: if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){ 16376: if( pMatch ){ 16377: return arErrorMsg(pAr, "ambiguous option: %s",z); 16378: }else{ 16379: pMatch = pOpt; 16380: } 16381: } 16382: } 16383: 16384: if( pMatch==0 ){ 16385: return arErrorMsg(pAr, "unrecognized option: %s", z); 16386: } 16387: if( pMatch->bArg ){ 16388: if( iArg>=(nArg-1) ){ 16389: return arErrorMsg(pAr, "option requires an argument: %s", z); 16390: } 16391: zArg = azArg[++iArg]; 16392: } 16393: if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR; 16394: } 16395: } 16396: } 1.4 misho 16397: } 1.2 misho 16398: 1.5 misho 16399: return SQLITE_OK; 1.3 misho 16400: } 16401: 16402: /* 1.5 misho 16403: ** This function assumes that all arguments within the ArCommand.azArg[] 16404: ** array refer to archive members, as for the --extract or --list commands. 16405: ** It checks that each of them are present. If any specified file is not 16406: ** present in the archive, an error is printed to stderr and an error 16407: ** code returned. Otherwise, if all specified arguments are present in 16408: ** the archive, SQLITE_OK is returned. 16409: ** 16410: ** This function strips any trailing '/' characters from each argument. 16411: ** This is consistent with the way the [tar] command seems to work on 16412: ** Linux. 16413: */ 16414: static int arCheckEntries(ArCommand *pAr){ 16415: int rc = SQLITE_OK; 16416: if( pAr->nArg ){ 16417: int i, j; 16418: sqlite3_stmt *pTest = 0; 16419: 16420: shellPreparePrintf(pAr->db, &rc, &pTest, 16421: "SELECT name FROM %s WHERE name=$name", 16422: pAr->zSrcTable 16423: ); 16424: j = sqlite3_bind_parameter_index(pTest, "$name"); 16425: for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 16426: char *z = pAr->azArg[i]; 16427: int n = strlen30(z); 16428: int bOk = 0; 16429: while( n>0 && z[n-1]=='/' ) n--; 16430: z[n] = '\0'; 16431: sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC); 16432: if( SQLITE_ROW==sqlite3_step(pTest) ){ 16433: bOk = 1; 16434: } 16435: shellReset(&rc, pTest); 16436: if( rc==SQLITE_OK && bOk==0 ){ 16437: utf8_printf(stderr, "not found in archive: %s\n", z); 16438: rc = SQLITE_ERROR; 16439: } 1.3 misho 16440: } 1.5 misho 16441: shellFinalize(&rc, pTest); 1.3 misho 16442: } 1.5 misho 16443: return rc; 1.3 misho 16444: } 16445: 16446: /* 1.5 misho 16447: ** Format a WHERE clause that can be used against the "sqlar" table to 16448: ** identify all archive members that match the command arguments held 16449: ** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning. 16450: ** The caller is responsible for eventually calling sqlite3_free() on 16451: ** any non-NULL (*pzWhere) value. 16452: */ 16453: static void arWhereClause( 16454: int *pRc, 16455: ArCommand *pAr, 16456: char **pzWhere /* OUT: New WHERE clause */ 16457: ){ 16458: char *zWhere = 0; 16459: if( *pRc==SQLITE_OK ){ 16460: if( pAr->nArg==0 ){ 16461: zWhere = sqlite3_mprintf("1"); 16462: }else{ 16463: int i; 16464: const char *zSep = ""; 16465: for(i=0; i<pAr->nArg; i++){ 16466: const char *z = pAr->azArg[i]; 16467: zWhere = sqlite3_mprintf( 16468: "%z%s name = '%q' OR substr(name,1,%d) = '%q/'", 16469: zWhere, zSep, z, strlen30(z)+1, z 16470: ); 16471: if( zWhere==0 ){ 16472: *pRc = SQLITE_NOMEM; 16473: break; 16474: } 16475: zSep = " OR "; 16476: } 16477: } 1.4 misho 16478: } 1.5 misho 16479: *pzWhere = zWhere; 1.3 misho 16480: } 16481: 16482: /* 1.5 misho 16483: ** Implementation of .ar "lisT" command. 1.3 misho 16484: */ 1.5 misho 16485: static int arListCommand(ArCommand *pAr){ 16486: const char *zSql = "SELECT %s FROM %s WHERE %s"; 16487: const char *azCols[] = { 16488: "name", 16489: "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name" 16490: }; 16491: 16492: char *zWhere = 0; 16493: sqlite3_stmt *pSql = 0; 16494: int rc; 16495: 16496: rc = arCheckEntries(pAr); 16497: arWhereClause(&rc, pAr, &zWhere); 16498: 16499: shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose], 16500: pAr->zSrcTable, zWhere); 16501: if( pAr->bDryRun ){ 16502: utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 16503: }else{ 16504: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 16505: if( pAr->bVerbose ){ 16506: utf8_printf(pAr->p->out, "%s % 10d %s %s\n", 16507: sqlite3_column_text(pSql, 0), 16508: sqlite3_column_int(pSql, 1), 16509: sqlite3_column_text(pSql, 2), 16510: sqlite3_column_text(pSql, 3) 16511: ); 16512: }else{ 16513: utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 16514: } 16515: } 16516: } 16517: shellFinalize(&rc, pSql); 16518: sqlite3_free(zWhere); 16519: return rc; 1.3 misho 16520: } 16521: 1.5 misho 16522: 1.3 misho 16523: /* 1.5 misho 16524: ** Implementation of .ar "eXtract" command. 1.4 misho 16525: */ 1.5 misho 16526: static int arExtractCommand(ArCommand *pAr){ 16527: const char *zSql1 = 16528: "SELECT " 16529: " ($dir || name)," 16530: " writefile(($dir || name), %s, mode, mtime) " 16531: "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)" 16532: " AND name NOT GLOB '*..[/\\]*'"; 16533: 16534: const char *azExtraArg[] = { 16535: "sqlar_uncompress(data, sz)", 16536: "data" 16537: }; 16538: 16539: sqlite3_stmt *pSql = 0; 16540: int rc = SQLITE_OK; 16541: char *zDir = 0; 16542: char *zWhere = 0; 16543: int i, j; 1.4 misho 16544: 1.5 misho 16545: /* If arguments are specified, check that they actually exist within 16546: ** the archive before proceeding. And formulate a WHERE clause to 16547: ** match them. */ 16548: rc = arCheckEntries(pAr); 16549: arWhereClause(&rc, pAr, &zWhere); 16550: 16551: if( rc==SQLITE_OK ){ 16552: if( pAr->zDir ){ 16553: zDir = sqlite3_mprintf("%s/", pAr->zDir); 16554: }else{ 16555: zDir = sqlite3_mprintf(""); 1.4 misho 16556: } 1.5 misho 16557: if( zDir==0 ) rc = SQLITE_NOMEM; 1.4 misho 16558: } 16559: 1.5 misho 16560: shellPreparePrintf(pAr->db, &rc, &pSql, zSql1, 16561: azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere 16562: ); 16563: 16564: if( rc==SQLITE_OK ){ 16565: j = sqlite3_bind_parameter_index(pSql, "$dir"); 16566: sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC); 16567: 16568: /* Run the SELECT statement twice. The first time, writefile() is called 16569: ** for all archive members that should be extracted. The second time, 16570: ** only for the directories. This is because the timestamps for 16571: ** extracted directories must be reset after they are populated (as 16572: ** populating them changes the timestamp). */ 16573: for(i=0; i<2; i++){ 16574: j = sqlite3_bind_parameter_index(pSql, "$dirOnly"); 16575: sqlite3_bind_int(pSql, j, i); 16576: if( pAr->bDryRun ){ 16577: utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql)); 16578: }else{ 16579: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){ 16580: if( i==0 && pAr->bVerbose ){ 16581: utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0)); 16582: } 1.4 misho 16583: } 16584: } 1.5 misho 16585: shellReset(&rc, pSql); 1.4 misho 16586: } 1.5 misho 16587: shellFinalize(&rc, pSql); 1.4 misho 16588: } 1.5 misho 16589: 16590: sqlite3_free(zDir); 16591: sqlite3_free(zWhere); 16592: return rc; 1.4 misho 16593: } 16594: 1.5 misho 16595: /* 16596: ** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out. 1.4 misho 16597: */ 1.5 misho 16598: static int arExecSql(ArCommand *pAr, const char *zSql){ 16599: int rc; 16600: if( pAr->bDryRun ){ 16601: utf8_printf(pAr->p->out, "%s\n", zSql); 16602: rc = SQLITE_OK; 16603: }else{ 16604: char *zErr = 0; 16605: rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr); 16606: if( zErr ){ 16607: utf8_printf(stdout, "ERROR: %s\n", zErr); 16608: sqlite3_free(zErr); 16609: } 1.4 misho 16610: } 1.5 misho 16611: return rc; 1.4 misho 16612: } 16613: 1.5 misho 16614: 1.4 misho 16615: /* 1.5 misho 16616: ** Implementation of .ar "create", "insert", and "update" commands. 16617: ** 16618: ** create -> Create a new SQL archive 16619: ** insert -> Insert or reinsert all files listed 16620: ** update -> Insert files that have changed or that were not 16621: ** previously in the archive 16622: ** 16623: ** Create the "sqlar" table in the database if it does not already exist. 16624: ** Then add each file in the azFile[] array to the archive. Directories 16625: ** are added recursively. If argument bVerbose is non-zero, a message is 16626: ** printed on stdout for each file archived. 16627: ** 16628: ** The create command is the same as update, except that it drops 16629: ** any existing "sqlar" table before beginning. The "insert" command 16630: ** always overwrites every file named on the command-line, where as 16631: ** "update" only overwrites if the size or mtime or mode has changed. 16632: */ 16633: static int arCreateOrUpdateCommand( 16634: ArCommand *pAr, /* Command arguments and options */ 16635: int bUpdate, /* true for a --create. */ 16636: int bOnlyIfChanged /* Only update if file has changed */ 1.4 misho 16637: ){ 1.5 misho 16638: const char *zCreate = 16639: "CREATE TABLE IF NOT EXISTS sqlar(\n" 16640: " name TEXT PRIMARY KEY, -- name of the file\n" 16641: " mode INT, -- access permissions\n" 16642: " mtime INT, -- last modification time\n" 16643: " sz INT, -- original file size\n" 16644: " data BLOB -- compressed content\n" 16645: ")"; 16646: const char *zDrop = "DROP TABLE IF EXISTS sqlar"; 16647: const char *zInsertFmt[2] = { 16648: "REPLACE INTO %s(name,mode,mtime,sz,data)\n" 16649: " SELECT\n" 16650: " %s,\n" 16651: " mode,\n" 16652: " mtime,\n" 16653: " CASE substr(lsmode(mode),1,1)\n" 16654: " WHEN '-' THEN length(data)\n" 16655: " WHEN 'd' THEN 0\n" 16656: " ELSE -1 END,\n" 16657: " sqlar_compress(data)\n" 16658: " FROM fsdir(%Q,%Q) AS disk\n" 16659: " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 16660: , 16661: "REPLACE INTO %s(name,mode,mtime,data)\n" 16662: " SELECT\n" 16663: " %s,\n" 16664: " mode,\n" 16665: " mtime,\n" 16666: " data\n" 16667: " FROM fsdir(%Q,%Q) AS disk\n" 16668: " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 16669: }; 16670: int i; /* For iterating through azFile[] */ 16671: int rc; /* Return code */ 16672: const char *zTab = 0; /* SQL table into which to insert */ 16673: char *zSql; 16674: char zTemp[50]; 16675: char *zExists = 0; 16676: 16677: arExecSql(pAr, "PRAGMA page_size=512"); 16678: rc = arExecSql(pAr, "SAVEPOINT ar;"); 16679: if( rc!=SQLITE_OK ) return rc; 16680: zTemp[0] = 0; 16681: if( pAr->bZip ){ 16682: /* Initialize the zipfile virtual table, if necessary */ 16683: if( pAr->zFile ){ 16684: sqlite3_uint64 r; 16685: sqlite3_randomness(sizeof(r),&r); 16686: sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r); 16687: zTab = zTemp; 16688: zSql = sqlite3_mprintf( 16689: "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)", 16690: zTab, pAr->zFile 16691: ); 16692: rc = arExecSql(pAr, zSql); 16693: sqlite3_free(zSql); 16694: }else{ 16695: zTab = "zip"; 16696: } 16697: }else{ 16698: /* Initialize the table for an SQLAR */ 16699: zTab = "sqlar"; 16700: if( bUpdate==0 ){ 16701: rc = arExecSql(pAr, zDrop); 16702: if( rc!=SQLITE_OK ) goto end_ar_transaction; 16703: } 16704: rc = arExecSql(pAr, zCreate); 16705: } 16706: if( bOnlyIfChanged ){ 16707: zExists = sqlite3_mprintf( 16708: " AND NOT EXISTS(" 16709: "SELECT 1 FROM %s AS mem" 16710: " WHERE mem.name=disk.name" 16711: " AND mem.mtime=disk.mtime" 16712: " AND mem.mode=disk.mode)", zTab); 16713: }else{ 16714: zExists = sqlite3_mprintf(""); 1.4 misho 16715: } 1.5 misho 16716: if( zExists==0 ) rc = SQLITE_NOMEM; 16717: for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 16718: char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab, 16719: pAr->bVerbose ? "shell_putsnl(name)" : "name", 16720: pAr->azArg[i], pAr->zDir, zExists); 16721: rc = arExecSql(pAr, zSql2); 16722: sqlite3_free(zSql2); 1.4 misho 16723: } 1.5 misho 16724: end_ar_transaction: 16725: if( rc!=SQLITE_OK ){ 16726: sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0); 16727: }else{ 16728: rc = arExecSql(pAr, "RELEASE ar;"); 16729: if( pAr->bZip && pAr->zFile ){ 16730: zSql = sqlite3_mprintf("DROP TABLE %s", zTemp); 16731: arExecSql(pAr, zSql); 16732: sqlite3_free(zSql); 1.4 misho 16733: } 1.5 misho 16734: } 16735: sqlite3_free(zExists); 16736: return rc; 1.4 misho 16737: } 16738: 16739: /* 1.5 misho 16740: ** Implementation of ".ar" dot command. 1.4 misho 16741: */ 1.5 misho 16742: static int arDotCommand( 16743: ShellState *pState, /* Current shell tool state */ 16744: int fromCmdLine, /* True if -A command-line option, not .ar cmd */ 16745: char **azArg, /* Array of arguments passed to dot command */ 16746: int nArg /* Number of entries in azArg[] */ 1.4 misho 16747: ){ 1.5 misho 16748: ArCommand cmd; 1.4 misho 16749: int rc; 1.5 misho 16750: memset(&cmd, 0, sizeof(cmd)); 16751: cmd.fromCmdLine = fromCmdLine; 16752: rc = arParseCommand(azArg, nArg, &cmd); 16753: if( rc==SQLITE_OK ){ 16754: int eDbType = SHELL_OPEN_UNSPEC; 16755: cmd.p = pState; 16756: cmd.db = pState->db; 16757: if( cmd.zFile ){ 16758: eDbType = deduceDatabaseType(cmd.zFile, 1); 16759: }else{ 16760: eDbType = pState->openMode; 16761: } 16762: if( eDbType==SHELL_OPEN_ZIPFILE ){ 16763: if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){ 16764: if( cmd.zFile==0 ){ 16765: cmd.zSrcTable = sqlite3_mprintf("zip"); 16766: }else{ 16767: cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile); 16768: } 16769: } 16770: cmd.bZip = 1; 16771: }else if( cmd.zFile ){ 16772: int flags; 16773: if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS; 16774: if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT 16775: || cmd.eCmd==AR_CMD_UPDATE ){ 16776: flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE; 16777: }else{ 16778: flags = SQLITE_OPEN_READONLY; 16779: } 16780: cmd.db = 0; 16781: if( cmd.bDryRun ){ 16782: utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile, 16783: eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : ""); 16784: } 16785: rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags, 16786: eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0); 16787: if( rc!=SQLITE_OK ){ 16788: utf8_printf(stderr, "cannot open file: %s (%s)\n", 16789: cmd.zFile, sqlite3_errmsg(cmd.db) 16790: ); 16791: goto end_ar_command; 16792: } 16793: sqlite3_fileio_init(cmd.db, 0, 0); 16794: sqlite3_sqlar_init(cmd.db, 0, 0); 16795: sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p, 16796: shellPutsFunc, 0, 0); 1.4 misho 16797: 16798: } 1.5 misho 16799: if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){ 16800: if( cmd.eCmd!=AR_CMD_CREATE 16801: && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0) 16802: ){ 16803: utf8_printf(stderr, "database does not contain an 'sqlar' table\n"); 16804: rc = SQLITE_ERROR; 16805: goto end_ar_command; 16806: } 16807: cmd.zSrcTable = sqlite3_mprintf("sqlar"); 16808: } 16809: 16810: switch( cmd.eCmd ){ 16811: case AR_CMD_CREATE: 16812: rc = arCreateOrUpdateCommand(&cmd, 0, 0); 16813: break; 16814: 16815: case AR_CMD_EXTRACT: 16816: rc = arExtractCommand(&cmd); 16817: break; 16818: 16819: case AR_CMD_LIST: 16820: rc = arListCommand(&cmd); 16821: break; 16822: 16823: case AR_CMD_HELP: 16824: arUsage(pState->out); 16825: break; 16826: 16827: case AR_CMD_INSERT: 16828: rc = arCreateOrUpdateCommand(&cmd, 1, 0); 16829: break; 16830: 16831: default: 16832: assert( cmd.eCmd==AR_CMD_UPDATE ); 16833: rc = arCreateOrUpdateCommand(&cmd, 1, 1); 16834: break; 1.4 misho 16835: } 16836: } 1.5 misho 16837: end_ar_command: 16838: if( cmd.db!=pState->db ){ 16839: close_db(cmd.db); 16840: } 16841: sqlite3_free(cmd.zSrcTable); 16842: 16843: return rc; 16844: } 16845: /* End of the ".archive" or ".ar" command logic 16846: *******************************************************************************/ 16847: #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */ 16848: 16849: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 16850: /* 16851: ** If (*pRc) is not SQLITE_OK when this function is called, it is a no-op. 16852: ** Otherwise, the SQL statement or statements in zSql are executed using 16853: ** database connection db and the error code written to *pRc before 16854: ** this function returns. 16855: */ 16856: static void shellExec(sqlite3 *db, int *pRc, const char *zSql){ 16857: int rc = *pRc; 16858: if( rc==SQLITE_OK ){ 16859: char *zErr = 0; 16860: rc = sqlite3_exec(db, zSql, 0, 0, &zErr); 16861: if( rc!=SQLITE_OK ){ 16862: raw_printf(stderr, "SQL error: %s\n", zErr); 1.4 misho 16863: } 1.5 misho 16864: *pRc = rc; 1.4 misho 16865: } 16866: } 16867: 16868: /* 1.5 misho 16869: ** Like shellExec(), except that zFmt is a printf() style format string. 1.4 misho 16870: */ 1.5 misho 16871: static void shellExecPrintf(sqlite3 *db, int *pRc, const char *zFmt, ...){ 16872: char *z = 0; 16873: if( *pRc==SQLITE_OK ){ 16874: va_list ap; 16875: va_start(ap, zFmt); 16876: z = sqlite3_vmprintf(zFmt, ap); 16877: va_end(ap); 16878: if( z==0 ){ 16879: *pRc = SQLITE_NOMEM; 16880: }else{ 16881: shellExec(db, pRc, z); 16882: } 16883: sqlite3_free(z); 1.4 misho 16884: } 16885: } 16886: 16887: /* 1.5 misho 16888: ** If *pRc is not SQLITE_OK when this function is called, it is a no-op. 16889: ** Otherwise, an attempt is made to allocate, zero and return a pointer 16890: ** to a buffer nByte bytes in size. If an OOM error occurs, *pRc is set 16891: ** to SQLITE_NOMEM and NULL returned. 1.4 misho 16892: */ 1.5 misho 16893: static void *shellMalloc(int *pRc, sqlite3_int64 nByte){ 16894: void *pRet = 0; 16895: if( *pRc==SQLITE_OK ){ 16896: pRet = sqlite3_malloc64(nByte); 16897: if( pRet==0 ){ 16898: *pRc = SQLITE_NOMEM; 16899: }else{ 16900: memset(pRet, 0, nByte); 16901: } 1.4 misho 16902: } 1.5 misho 16903: return pRet; 1.4 misho 16904: } 16905: 16906: /* 1.5 misho 16907: ** If *pRc is not SQLITE_OK when this function is called, it is a no-op. 16908: ** Otherwise, zFmt is treated as a printf() style string. The result of 16909: ** formatting it along with any trailing arguments is written into a 16910: ** buffer obtained from sqlite3_malloc(), and pointer to which is returned. 16911: ** It is the responsibility of the caller to eventually free this buffer 16912: ** using a call to sqlite3_free(). 16913: ** 16914: ** If an OOM error occurs, (*pRc) is set to SQLITE_NOMEM and a NULL 16915: ** pointer returned. 1.4 misho 16916: */ 1.5 misho 16917: static char *shellMPrintf(int *pRc, const char *zFmt, ...){ 16918: char *z = 0; 16919: if( *pRc==SQLITE_OK ){ 16920: va_list ap; 16921: va_start(ap, zFmt); 16922: z = sqlite3_vmprintf(zFmt, ap); 16923: va_end(ap); 16924: if( z==0 ){ 16925: *pRc = SQLITE_NOMEM; 16926: } 1.4 misho 16927: } 1.5 misho 16928: return z; 1.4 misho 16929: } 16930: 16931: /* 1.5 misho 16932: ** When running the ".recover" command, each output table, and the special 16933: ** orphaned row table if it is required, is represented by an instance 16934: ** of the following struct. 16935: */ 16936: typedef struct RecoverTable RecoverTable; 16937: struct RecoverTable { 16938: char *zQuoted; /* Quoted version of table name */ 16939: int nCol; /* Number of columns in table */ 16940: char **azlCol; /* Array of column lists */ 16941: int iPk; /* Index of IPK column */ 16942: }; 16943: 16944: /* 16945: ** Free a RecoverTable object allocated by recoverFindTable() or 16946: ** recoverOrphanTable(). 1.4 misho 16947: */ 1.5 misho 16948: static void recoverFreeTable(RecoverTable *pTab){ 16949: if( pTab ){ 16950: sqlite3_free(pTab->zQuoted); 16951: if( pTab->azlCol ){ 16952: int i; 16953: for(i=0; i<=pTab->nCol; i++){ 16954: sqlite3_free(pTab->azlCol[i]); 16955: } 16956: sqlite3_free(pTab->azlCol); 16957: } 16958: sqlite3_free(pTab); 16959: } 1.4 misho 16960: } 16961: 16962: /* 1.5 misho 16963: ** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. 16964: ** Otherwise, it allocates and returns a RecoverTable object based on the 16965: ** final four arguments passed to this function. It is the responsibility 16966: ** of the caller to eventually free the returned object using 16967: ** recoverFreeTable(). 1.4 misho 16968: */ 1.5 misho 16969: static RecoverTable *recoverNewTable( 16970: int *pRc, /* IN/OUT: Error code */ 16971: const char *zName, /* Name of table */ 16972: const char *zSql, /* CREATE TABLE statement */ 16973: int bIntkey, 16974: int nCol 16975: ){ 16976: sqlite3 *dbtmp = 0; /* sqlite3 handle for testing CREATE TABLE */ 16977: int rc = *pRc; 16978: RecoverTable *pTab = 0; 16979: 16980: pTab = (RecoverTable*)shellMalloc(&rc, sizeof(RecoverTable)); 16981: if( rc==SQLITE_OK ){ 16982: int nSqlCol = 0; 16983: int bSqlIntkey = 0; 16984: sqlite3_stmt *pStmt = 0; 16985: 16986: rc = sqlite3_open("", &dbtmp); 16987: if( rc==SQLITE_OK ){ 16988: sqlite3_create_function(dbtmp, "shell_idquote", 1, SQLITE_UTF8, 0, 16989: shellIdQuote, 0, 0); 16990: } 16991: if( rc==SQLITE_OK ){ 16992: rc = sqlite3_exec(dbtmp, "PRAGMA writable_schema = on", 0, 0, 0); 16993: } 16994: if( rc==SQLITE_OK ){ 16995: rc = sqlite3_exec(dbtmp, zSql, 0, 0, 0); 16996: if( rc==SQLITE_ERROR ){ 16997: rc = SQLITE_OK; 16998: goto finished; 16999: } 17000: } 17001: shellPreparePrintf(dbtmp, &rc, &pStmt, 17002: "SELECT count(*) FROM pragma_table_info(%Q)", zName 17003: ); 17004: if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 17005: nSqlCol = sqlite3_column_int(pStmt, 0); 17006: } 17007: shellFinalize(&rc, pStmt); 17008: 17009: if( rc!=SQLITE_OK || nSqlCol<nCol ){ 17010: goto finished; 17011: } 17012: 17013: shellPreparePrintf(dbtmp, &rc, &pStmt, 17014: "SELECT (" 17015: " SELECT substr(data,1,1)==X'0D' FROM sqlite_dbpage WHERE pgno=rootpage" 17016: ") FROM sqlite_schema WHERE name = %Q", zName 17017: ); 17018: if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 17019: bSqlIntkey = sqlite3_column_int(pStmt, 0); 17020: } 17021: shellFinalize(&rc, pStmt); 17022: 17023: if( bIntkey==bSqlIntkey ){ 17024: int i; 17025: const char *zPk = "_rowid_"; 17026: sqlite3_stmt *pPkFinder = 0; 17027: 17028: /* If this is an intkey table and there is an INTEGER PRIMARY KEY, 17029: ** set zPk to the name of the PK column, and pTab->iPk to the index 17030: ** of the column, where columns are 0-numbered from left to right. 17031: ** Or, if this is a WITHOUT ROWID table or if there is no IPK column, 17032: ** leave zPk as "_rowid_" and pTab->iPk at -2. */ 17033: pTab->iPk = -2; 17034: if( bIntkey ){ 17035: shellPreparePrintf(dbtmp, &rc, &pPkFinder, 17036: "SELECT cid, name FROM pragma_table_info(%Q) " 17037: " WHERE pk=1 AND type='integer' COLLATE nocase" 17038: " AND NOT EXISTS (SELECT cid FROM pragma_table_info(%Q) WHERE pk=2)" 17039: , zName, zName 17040: ); 17041: if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPkFinder) ){ 17042: pTab->iPk = sqlite3_column_int(pPkFinder, 0); 17043: zPk = (const char*)sqlite3_column_text(pPkFinder, 1); 17044: } 17045: } 17046: 17047: pTab->zQuoted = shellMPrintf(&rc, "\"%w\"", zName); 17048: pTab->azlCol = (char**)shellMalloc(&rc, sizeof(char*) * (nSqlCol+1)); 17049: pTab->nCol = nSqlCol; 17050: 17051: if( bIntkey ){ 17052: pTab->azlCol[0] = shellMPrintf(&rc, "\"%w\"", zPk); 17053: }else{ 17054: pTab->azlCol[0] = shellMPrintf(&rc, ""); 17055: } 17056: i = 1; 17057: shellPreparePrintf(dbtmp, &rc, &pStmt, 17058: "SELECT %Q || group_concat(shell_idquote(name), ', ') " 17059: " FILTER (WHERE cid!=%d) OVER (ORDER BY %s cid) " 17060: "FROM pragma_table_info(%Q)", 17061: bIntkey ? ", " : "", pTab->iPk, 17062: bIntkey ? "" : "(CASE WHEN pk=0 THEN 1000000 ELSE pk END), ", 17063: zName 17064: ); 17065: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 17066: const char *zText = (const char*)sqlite3_column_text(pStmt, 0); 17067: pTab->azlCol[i] = shellMPrintf(&rc, "%s%s", pTab->azlCol[0], zText); 17068: i++; 1.4 misho 17069: } 1.5 misho 17070: shellFinalize(&rc, pStmt); 17071: 17072: shellFinalize(&rc, pPkFinder); 1.4 misho 17073: } 17074: } 1.5 misho 17075: 17076: finished: 17077: sqlite3_close(dbtmp); 17078: *pRc = rc; 17079: if( rc!=SQLITE_OK || (pTab && pTab->zQuoted==0) ){ 17080: recoverFreeTable(pTab); 17081: pTab = 0; 1.4 misho 17082: } 1.5 misho 17083: return pTab; 1.4 misho 17084: } 17085: 17086: /* 1.5 misho 17087: ** This function is called to search the schema recovered from the 17088: ** sqlite_schema table of the (possibly) corrupt database as part 17089: ** of a ".recover" command. Specifically, for a table with root page 17090: ** iRoot and at least nCol columns. Additionally, if bIntkey is 0, the 17091: ** table must be a WITHOUT ROWID table, or if non-zero, not one of 17092: ** those. 17093: ** 17094: ** If a table is found, a (RecoverTable*) object is returned. Or, if 17095: ** no such table is found, but bIntkey is false and iRoot is the 17096: ** root page of an index in the recovered schema, then (*pbNoop) is 17097: ** set to true and NULL returned. Or, if there is no such table or 17098: ** index, NULL is returned and (*pbNoop) set to 0, indicating that 17099: ** the caller should write data to the orphans table. 17100: */ 17101: static RecoverTable *recoverFindTable( 17102: ShellState *pState, /* Shell state object */ 17103: int *pRc, /* IN/OUT: Error code */ 17104: int iRoot, /* Root page of table */ 17105: int bIntkey, /* True for an intkey table */ 17106: int nCol, /* Number of columns in table */ 17107: int *pbNoop /* OUT: True if iRoot is root of index */ 17108: ){ 17109: sqlite3_stmt *pStmt = 0; 17110: RecoverTable *pRet = 0; 17111: int bNoop = 0; 17112: const char *zSql = 0; 17113: const char *zName = 0; 17114: 17115: /* Search the recovered schema for an object with root page iRoot. */ 17116: shellPreparePrintf(pState->db, pRc, &pStmt, 17117: "SELECT type, name, sql FROM recovery.schema WHERE rootpage=%d", iRoot 17118: ); 17119: while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 17120: const char *zType = (const char*)sqlite3_column_text(pStmt, 0); 17121: if( bIntkey==0 && sqlite3_stricmp(zType, "index")==0 ){ 17122: bNoop = 1; 17123: break; 17124: } 17125: if( sqlite3_stricmp(zType, "table")==0 ){ 17126: zName = (const char*)sqlite3_column_text(pStmt, 1); 17127: zSql = (const char*)sqlite3_column_text(pStmt, 2); 17128: pRet = recoverNewTable(pRc, zName, zSql, bIntkey, nCol); 17129: break; 17130: } 17131: } 17132: 17133: shellFinalize(pRc, pStmt); 17134: *pbNoop = bNoop; 17135: return pRet; 1.4 misho 17136: } 17137: 17138: /* 1.5 misho 17139: ** Return a RecoverTable object representing the orphans table. 1.4 misho 17140: */ 1.5 misho 17141: static RecoverTable *recoverOrphanTable( 17142: ShellState *pState, /* Shell state object */ 17143: int *pRc, /* IN/OUT: Error code */ 17144: const char *zLostAndFound, /* Base name for orphans table */ 17145: int nCol /* Number of user data columns */ 17146: ){ 17147: RecoverTable *pTab = 0; 17148: if( nCol>=0 && *pRc==SQLITE_OK ){ 17149: int i; 17150: 17151: /* This block determines the name of the orphan table. The prefered 17152: ** name is zLostAndFound. But if that clashes with another name 17153: ** in the recovered schema, try zLostAndFound_0, zLostAndFound_1 17154: ** and so on until a non-clashing name is found. */ 17155: int iTab = 0; 17156: char *zTab = shellMPrintf(pRc, "%s", zLostAndFound); 17157: sqlite3_stmt *pTest = 0; 17158: shellPrepare(pState->db, pRc, 17159: "SELECT 1 FROM recovery.schema WHERE name=?", &pTest 17160: ); 17161: if( pTest ) sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT); 17162: while( *pRc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pTest) ){ 17163: shellReset(pRc, pTest); 17164: sqlite3_free(zTab); 17165: zTab = shellMPrintf(pRc, "%s_%d", zLostAndFound, iTab++); 17166: sqlite3_bind_text(pTest, 1, zTab, -1, SQLITE_TRANSIENT); 17167: } 17168: shellFinalize(pRc, pTest); 17169: 17170: pTab = (RecoverTable*)shellMalloc(pRc, sizeof(RecoverTable)); 17171: if( pTab ){ 17172: pTab->zQuoted = shellMPrintf(pRc, "\"%w\"", zTab); 17173: pTab->nCol = nCol; 17174: pTab->iPk = -2; 17175: if( nCol>0 ){ 17176: pTab->azlCol = (char**)shellMalloc(pRc, sizeof(char*) * (nCol+1)); 17177: if( pTab->azlCol ){ 17178: pTab->azlCol[nCol] = shellMPrintf(pRc, ""); 17179: for(i=nCol-1; i>=0; i--){ 17180: pTab->azlCol[i] = shellMPrintf(pRc, "%s, NULL", pTab->azlCol[i+1]); 17181: } 17182: } 17183: } 17184: 17185: if( *pRc!=SQLITE_OK ){ 17186: recoverFreeTable(pTab); 17187: pTab = 0; 17188: }else{ 17189: raw_printf(pState->out, 17190: "CREATE TABLE %s(rootpgno INTEGER, " 17191: "pgno INTEGER, nfield INTEGER, id INTEGER", pTab->zQuoted 17192: ); 17193: for(i=0; i<nCol; i++){ 17194: raw_printf(pState->out, ", c%d", i); 17195: } 17196: raw_printf(pState->out, ");\n"); 17197: } 17198: } 17199: sqlite3_free(zTab); 17200: } 17201: return pTab; 1.4 misho 17202: } 17203: 17204: /* 1.5 misho 17205: ** This function is called to recover data from the database. A script 17206: ** to construct a new database containing all recovered data is output 17207: ** on stream pState->out. 1.4 misho 17208: */ 1.5 misho 17209: static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){ 17210: int rc = SQLITE_OK; 17211: sqlite3_stmt *pLoop = 0; /* Loop through all root pages */ 17212: sqlite3_stmt *pPages = 0; /* Loop through all pages in a group */ 17213: sqlite3_stmt *pCells = 0; /* Loop through all cells in a page */ 17214: const char *zRecoveryDb = ""; /* Name of "recovery" database */ 17215: const char *zLostAndFound = "lost_and_found"; 17216: int i; 17217: int nOrphan = -1; 17218: RecoverTable *pOrphan = 0; 17219: 17220: int bFreelist = 1; /* 0 if --freelist-corrupt is specified */ 17221: int bRowids = 1; /* 0 if --no-rowids */ 17222: for(i=1; i<nArg; i++){ 17223: char *z = azArg[i]; 17224: int n; 17225: if( z[0]=='-' && z[1]=='-' ) z++; 17226: n = strlen30(z); 17227: if( n<=17 && memcmp("-freelist-corrupt", z, n)==0 ){ 17228: bFreelist = 0; 17229: }else 17230: if( n<=12 && memcmp("-recovery-db", z, n)==0 && i<(nArg-1) ){ 17231: i++; 17232: zRecoveryDb = azArg[i]; 17233: }else 17234: if( n<=15 && memcmp("-lost-and-found", z, n)==0 && i<(nArg-1) ){ 17235: i++; 17236: zLostAndFound = azArg[i]; 17237: }else 17238: if( n<=10 && memcmp("-no-rowids", z, n)==0 ){ 17239: bRowids = 0; 17240: } 17241: else{ 17242: utf8_printf(stderr, "unexpected option: %s\n", azArg[i]); 17243: showHelp(pState->out, azArg[0]); 17244: return 1; 17245: } 17246: } 17247: 17248: shellExecPrintf(pState->db, &rc, 17249: /* Attach an in-memory database named 'recovery'. Create an indexed 17250: ** cache of the sqlite_dbptr virtual table. */ 17251: "PRAGMA writable_schema = on;" 17252: "ATTACH %Q AS recovery;" 17253: "DROP TABLE IF EXISTS recovery.dbptr;" 17254: "DROP TABLE IF EXISTS recovery.freelist;" 17255: "DROP TABLE IF EXISTS recovery.map;" 17256: "DROP TABLE IF EXISTS recovery.schema;" 17257: "CREATE TABLE recovery.freelist(pgno INTEGER PRIMARY KEY);", zRecoveryDb 17258: ); 17259: 17260: if( bFreelist ){ 17261: shellExec(pState->db, &rc, 17262: "WITH trunk(pgno) AS (" 17263: " SELECT shell_int32(" 17264: " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 8) AS x " 17265: " WHERE x>0" 17266: " UNION" 17267: " SELECT shell_int32(" 17268: " (SELECT data FROM sqlite_dbpage WHERE pgno=trunk.pgno), 0) AS x " 17269: " FROM trunk WHERE x>0" 17270: ")," 17271: "freelist(data, n, freepgno) AS (" 17272: " SELECT data, min(16384, shell_int32(data, 1)-1), t.pgno " 17273: " FROM trunk t, sqlite_dbpage s WHERE s.pgno=t.pgno" 17274: " UNION ALL" 17275: " SELECT data, n-1, shell_int32(data, 2+n) " 17276: " FROM freelist WHERE n>=0" 17277: ")" 17278: "REPLACE INTO recovery.freelist SELECT freepgno FROM freelist;" 17279: ); 17280: } 17281: 17282: /* If this is an auto-vacuum database, add all pointer-map pages to 17283: ** the freelist table. Do this regardless of whether or not 17284: ** --freelist-corrupt was specified. */ 17285: shellExec(pState->db, &rc, 17286: "WITH ptrmap(pgno) AS (" 17287: " SELECT 2 WHERE shell_int32(" 17288: " (SELECT data FROM sqlite_dbpage WHERE pgno=1), 13" 17289: " )" 17290: " UNION ALL " 17291: " SELECT pgno+1+(SELECT page_size FROM pragma_page_size)/5 AS pp " 17292: " FROM ptrmap WHERE pp<=(SELECT page_count FROM pragma_page_count)" 17293: ")" 17294: "REPLACE INTO recovery.freelist SELECT pgno FROM ptrmap" 17295: ); 17296: 17297: shellExec(pState->db, &rc, 17298: "CREATE TABLE recovery.dbptr(" 17299: " pgno, child, PRIMARY KEY(child, pgno)" 17300: ") WITHOUT ROWID;" 17301: "INSERT OR IGNORE INTO recovery.dbptr(pgno, child) " 17302: " SELECT * FROM sqlite_dbptr" 17303: " WHERE pgno NOT IN freelist AND child NOT IN freelist;" 17304: 17305: /* Delete any pointer to page 1. This ensures that page 1 is considered 17306: ** a root page, regardless of how corrupt the db is. */ 17307: "DELETE FROM recovery.dbptr WHERE child = 1;" 17308: 17309: /* Delete all pointers to any pages that have more than one pointer 17310: ** to them. Such pages will be treated as root pages when recovering 17311: ** data. */ 17312: "DELETE FROM recovery.dbptr WHERE child IN (" 17313: " SELECT child FROM recovery.dbptr GROUP BY child HAVING count(*)>1" 17314: ");" 17315: 17316: /* Create the "map" table that will (eventually) contain instructions 17317: ** for dealing with each page in the db that contains one or more 17318: ** records. */ 17319: "CREATE TABLE recovery.map(" 17320: "pgno INTEGER PRIMARY KEY, maxlen INT, intkey, root INT" 17321: ");" 17322: 17323: /* Populate table [map]. If there are circular loops of pages in the 17324: ** database, the following adds all pages in such a loop to the map 17325: ** as individual root pages. This could be handled better. */ 17326: "WITH pages(i, maxlen) AS (" 17327: " SELECT page_count, (" 17328: " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=page_count" 17329: " ) FROM pragma_page_count WHERE page_count>0" 17330: " UNION ALL" 17331: " SELECT i-1, (" 17332: " SELECT max(field+1) FROM sqlite_dbdata WHERE pgno=i-1" 17333: " ) FROM pages WHERE i>=2" 17334: ")" 17335: "INSERT INTO recovery.map(pgno, maxlen, intkey, root) " 17336: " SELECT i, maxlen, NULL, (" 17337: " WITH p(orig, pgno, parent) AS (" 17338: " SELECT 0, i, (SELECT pgno FROM recovery.dbptr WHERE child=i)" 17339: " UNION " 17340: " SELECT i, p.parent, " 17341: " (SELECT pgno FROM recovery.dbptr WHERE child=p.parent) FROM p" 17342: " )" 17343: " SELECT pgno FROM p WHERE (parent IS NULL OR pgno = orig)" 17344: ") " 17345: "FROM pages WHERE maxlen IS NOT NULL AND i NOT IN freelist;" 17346: "UPDATE recovery.map AS o SET intkey = (" 17347: " SELECT substr(data, 1, 1)==X'0D' FROM sqlite_dbpage WHERE pgno=o.pgno" 17348: ");" 17349: 17350: /* Extract data from page 1 and any linked pages into table 17351: ** recovery.schema. With the same schema as an sqlite_schema table. */ 17352: "CREATE TABLE recovery.schema(type, name, tbl_name, rootpage, sql);" 17353: "INSERT INTO recovery.schema SELECT " 17354: " max(CASE WHEN field=0 THEN value ELSE NULL END)," 17355: " max(CASE WHEN field=1 THEN value ELSE NULL END)," 17356: " max(CASE WHEN field=2 THEN value ELSE NULL END)," 17357: " max(CASE WHEN field=3 THEN value ELSE NULL END)," 17358: " max(CASE WHEN field=4 THEN value ELSE NULL END)" 17359: "FROM sqlite_dbdata WHERE pgno IN (" 17360: " SELECT pgno FROM recovery.map WHERE root=1" 17361: ")" 17362: "GROUP BY pgno, cell;" 17363: "CREATE INDEX recovery.schema_rootpage ON schema(rootpage);" 17364: ); 17365: 17366: /* Open a transaction, then print out all non-virtual, non-"sqlite_%" 17367: ** CREATE TABLE statements that extracted from the existing schema. */ 17368: if( rc==SQLITE_OK ){ 17369: sqlite3_stmt *pStmt = 0; 17370: /* ".recover" might output content in an order which causes immediate 17371: ** foreign key constraints to be violated. So disable foreign-key 17372: ** constraint enforcement to prevent problems when running the output 17373: ** script. */ 17374: raw_printf(pState->out, "PRAGMA foreign_keys=OFF;\n"); 17375: raw_printf(pState->out, "BEGIN;\n"); 17376: raw_printf(pState->out, "PRAGMA writable_schema = on;\n"); 17377: shellPrepare(pState->db, &rc, 17378: "SELECT sql FROM recovery.schema " 17379: "WHERE type='table' AND sql LIKE 'create table%'", &pStmt 17380: ); 17381: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 17382: const char *zCreateTable = (const char*)sqlite3_column_text(pStmt, 0); 17383: raw_printf(pState->out, "CREATE TABLE IF NOT EXISTS %s;\n", 17384: &zCreateTable[12] 17385: ); 17386: } 17387: shellFinalize(&rc, pStmt); 17388: } 17389: 17390: /* Figure out if an orphan table will be required. And if so, how many 17391: ** user columns it should contain */ 17392: shellPrepare(pState->db, &rc, 17393: "SELECT coalesce(max(maxlen), -2) FROM recovery.map WHERE root>1" 17394: , &pLoop 17395: ); 17396: if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){ 17397: nOrphan = sqlite3_column_int(pLoop, 0); 17398: } 17399: shellFinalize(&rc, pLoop); 17400: pLoop = 0; 17401: 17402: shellPrepare(pState->db, &rc, 17403: "SELECT pgno FROM recovery.map WHERE root=?", &pPages 17404: ); 17405: 17406: shellPrepare(pState->db, &rc, 17407: "SELECT max(field), group_concat(shell_escape_crnl(quote" 17408: "(case when (? AND field<0) then NULL else value end)" 17409: "), ', ')" 17410: ", min(field) " 17411: "FROM sqlite_dbdata WHERE pgno = ? AND field != ?" 17412: "GROUP BY cell", &pCells 17413: ); 17414: 17415: /* Loop through each root page. */ 17416: shellPrepare(pState->db, &rc, 17417: "SELECT root, intkey, max(maxlen) FROM recovery.map" 17418: " WHERE root>1 GROUP BY root, intkey ORDER BY root=(" 17419: " SELECT rootpage FROM recovery.schema WHERE name='sqlite_sequence'" 17420: ")", &pLoop 17421: ); 17422: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pLoop) ){ 17423: int iRoot = sqlite3_column_int(pLoop, 0); 17424: int bIntkey = sqlite3_column_int(pLoop, 1); 17425: int nCol = sqlite3_column_int(pLoop, 2); 17426: int bNoop = 0; 17427: RecoverTable *pTab; 17428: 17429: assert( bIntkey==0 || bIntkey==1 ); 17430: pTab = recoverFindTable(pState, &rc, iRoot, bIntkey, nCol, &bNoop); 17431: if( bNoop || rc ) continue; 17432: if( pTab==0 ){ 17433: if( pOrphan==0 ){ 17434: pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan); 17435: } 17436: pTab = pOrphan; 17437: if( pTab==0 ) break; 17438: } 17439: 17440: if( 0==sqlite3_stricmp(pTab->zQuoted, "\"sqlite_sequence\"") ){ 17441: raw_printf(pState->out, "DELETE FROM sqlite_sequence;\n"); 17442: } 17443: sqlite3_bind_int(pPages, 1, iRoot); 17444: if( bRowids==0 && pTab->iPk<0 ){ 17445: sqlite3_bind_int(pCells, 1, 1); 17446: }else{ 17447: sqlite3_bind_int(pCells, 1, 0); 17448: } 17449: sqlite3_bind_int(pCells, 3, pTab->iPk); 17450: 17451: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPages) ){ 17452: int iPgno = sqlite3_column_int(pPages, 0); 17453: sqlite3_bind_int(pCells, 2, iPgno); 17454: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pCells) ){ 17455: int nField = sqlite3_column_int(pCells, 0); 17456: int iMin = sqlite3_column_int(pCells, 2); 17457: const char *zVal = (const char*)sqlite3_column_text(pCells, 1); 17458: 17459: RecoverTable *pTab2 = pTab; 17460: if( pTab!=pOrphan && (iMin<0)!=bIntkey ){ 17461: if( pOrphan==0 ){ 17462: pOrphan = recoverOrphanTable(pState, &rc, zLostAndFound, nOrphan); 17463: } 17464: pTab2 = pOrphan; 17465: if( pTab2==0 ) break; 17466: } 17467: 17468: nField = nField+1; 17469: if( pTab2==pOrphan ){ 17470: raw_printf(pState->out, 17471: "INSERT INTO %s VALUES(%d, %d, %d, %s%s%s);\n", 17472: pTab2->zQuoted, iRoot, iPgno, nField, 17473: iMin<0 ? "" : "NULL, ", zVal, pTab2->azlCol[nField] 17474: ); 17475: }else{ 17476: raw_printf(pState->out, "INSERT INTO %s(%s) VALUES( %s );\n", 17477: pTab2->zQuoted, pTab2->azlCol[nField], zVal 17478: ); 17479: } 17480: } 17481: shellReset(&rc, pCells); 17482: } 17483: shellReset(&rc, pPages); 17484: if( pTab!=pOrphan ) recoverFreeTable(pTab); 17485: } 17486: shellFinalize(&rc, pLoop); 17487: shellFinalize(&rc, pPages); 17488: shellFinalize(&rc, pCells); 17489: recoverFreeTable(pOrphan); 17490: 17491: /* The rest of the schema */ 17492: if( rc==SQLITE_OK ){ 17493: sqlite3_stmt *pStmt = 0; 17494: shellPrepare(pState->db, &rc, 17495: "SELECT sql, name FROM recovery.schema " 17496: "WHERE sql NOT LIKE 'create table%'", &pStmt 17497: ); 17498: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 17499: const char *zSql = (const char*)sqlite3_column_text(pStmt, 0); 17500: if( sqlite3_strnicmp(zSql, "create virt", 11)==0 ){ 17501: const char *zName = (const char*)sqlite3_column_text(pStmt, 1); 17502: char *zPrint = shellMPrintf(&rc, 17503: "INSERT INTO sqlite_schema VALUES('table', %Q, %Q, 0, %Q)", 17504: zName, zName, zSql 17505: ); 17506: raw_printf(pState->out, "%s;\n", zPrint); 17507: sqlite3_free(zPrint); 17508: }else{ 17509: raw_printf(pState->out, "%s;\n", zSql); 17510: } 17511: } 17512: shellFinalize(&rc, pStmt); 17513: } 17514: 17515: if( rc==SQLITE_OK ){ 17516: raw_printf(pState->out, "PRAGMA writable_schema = off;\n"); 17517: raw_printf(pState->out, "COMMIT;\n"); 17518: } 17519: sqlite3_exec(pState->db, "DETACH recovery", 0, 0, 0); 17520: return rc; 1.4 misho 17521: } 1.5 misho 17522: #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */ 17523: 1.4 misho 17524: 17525: /* 1.2 misho 17526: ** If an input line begins with "." then invoke this routine to 17527: ** process that line. 17528: ** 17529: ** Return 1 on error, 2 to exit, and 0 otherwise. 17530: */ 1.4 misho 17531: static int do_meta_command(char *zLine, ShellState *p){ 17532: int h = 1; 1.2 misho 17533: int nArg = 0; 17534: int n, c; 17535: int rc = 0; 1.5 misho 17536: char *azArg[52]; 17537: 17538: #ifndef SQLITE_OMIT_VIRTUALTABLE 17539: if( p->expert.pExpert ){ 17540: expertFinish(p, 1, 0); 17541: } 17542: #endif 1.2 misho 17543: 17544: /* Parse the input line into tokens. 17545: */ 1.5 misho 17546: while( zLine[h] && nArg<ArraySize(azArg)-1 ){ 1.4 misho 17547: while( IsSpace(zLine[h]) ){ h++; } 17548: if( zLine[h]==0 ) break; 17549: if( zLine[h]=='\'' || zLine[h]=='"' ){ 17550: int delim = zLine[h++]; 17551: azArg[nArg++] = &zLine[h]; 17552: while( zLine[h] && zLine[h]!=delim ){ 17553: if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++; 17554: h++; 17555: } 17556: if( zLine[h]==delim ){ 17557: zLine[h++] = 0; 1.2 misho 17558: } 17559: if( delim=='"' ) resolve_backslashes(azArg[nArg-1]); 17560: }else{ 1.4 misho 17561: azArg[nArg++] = &zLine[h]; 17562: while( zLine[h] && !IsSpace(zLine[h]) ){ h++; } 17563: if( zLine[h] ) zLine[h++] = 0; 1.2 misho 17564: resolve_backslashes(azArg[nArg-1]); 17565: } 17566: } 1.5 misho 17567: azArg[nArg] = 0; 1.2 misho 17568: 17569: /* Process the input line. 17570: */ 17571: if( nArg==0 ) return 0; /* no tokens, no error */ 17572: n = strlen30(azArg[0]); 17573: c = azArg[0][0]; 1.5 misho 17574: clearTempFile(p); 1.4 misho 17575: 1.5 misho 17576: #ifndef SQLITE_OMIT_AUTHORIZATION 1.4 misho 17577: if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){ 17578: if( nArg!=2 ){ 17579: raw_printf(stderr, "Usage: .auth ON|OFF\n"); 17580: rc = 1; 17581: goto meta_command_exit; 17582: } 17583: open_db(p, 0); 17584: if( booleanValue(azArg[1]) ){ 17585: sqlite3_set_authorizer(p->db, shellAuth, p); 17586: }else{ 17587: sqlite3_set_authorizer(p->db, 0, 0); 17588: } 17589: }else 1.5 misho 17590: #endif 17591: 17592: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 17593: if( c=='a' && strncmp(azArg[0], "archive", n)==0 ){ 17594: open_db(p, 0); 17595: rc = arDotCommand(p, 0, azArg, nArg); 17596: }else 17597: #endif 1.4 misho 17598: 17599: if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0) 17600: || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0) 17601: ){ 17602: const char *zDestFile = 0; 17603: const char *zDb = 0; 1.2 misho 17604: sqlite3 *pDest; 17605: sqlite3_backup *pBackup; 1.4 misho 17606: int j; 1.5 misho 17607: int bAsync = 0; 17608: const char *zVfs = 0; 1.4 misho 17609: for(j=1; j<nArg; j++){ 17610: const char *z = azArg[j]; 17611: if( z[0]=='-' ){ 1.5 misho 17612: if( z[1]=='-' ) z++; 17613: if( strcmp(z, "-append")==0 ){ 17614: zVfs = "apndvfs"; 17615: }else 17616: if( strcmp(z, "-async")==0 ){ 17617: bAsync = 1; 17618: }else 1.4 misho 17619: { 17620: utf8_printf(stderr, "unknown option: %s\n", azArg[j]); 17621: return 1; 17622: } 17623: }else if( zDestFile==0 ){ 17624: zDestFile = azArg[j]; 17625: }else if( zDb==0 ){ 17626: zDb = zDestFile; 17627: zDestFile = azArg[j]; 17628: }else{ 1.5 misho 17629: raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n"); 1.4 misho 17630: return 1; 17631: } 17632: } 17633: if( zDestFile==0 ){ 17634: raw_printf(stderr, "missing FILENAME argument on .backup\n"); 17635: return 1; 1.2 misho 17636: } 1.4 misho 17637: if( zDb==0 ) zDb = "main"; 1.5 misho 17638: rc = sqlite3_open_v2(zDestFile, &pDest, 17639: SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs); 1.2 misho 17640: if( rc!=SQLITE_OK ){ 1.4 misho 17641: utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile); 1.5 misho 17642: close_db(pDest); 1.2 misho 17643: return 1; 17644: } 1.5 misho 17645: if( bAsync ){ 17646: sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;", 17647: 0, 0, 0); 17648: } 1.4 misho 17649: open_db(p, 0); 1.2 misho 17650: pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb); 17651: if( pBackup==0 ){ 1.4 misho 17652: utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 1.5 misho 17653: close_db(pDest); 1.2 misho 17654: return 1; 17655: } 17656: while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} 17657: sqlite3_backup_finish(pBackup); 17658: if( rc==SQLITE_DONE ){ 17659: rc = 0; 17660: }else{ 1.4 misho 17661: utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); 1.2 misho 17662: rc = 1; 17663: } 1.5 misho 17664: close_db(pDest); 1.2 misho 17665: }else 17666: 1.4 misho 17667: if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){ 17668: if( nArg==2 ){ 17669: bail_on_error = booleanValue(azArg[1]); 17670: }else{ 17671: raw_printf(stderr, "Usage: .bail on|off\n"); 17672: rc = 1; 17673: } 17674: }else 17675: 17676: if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){ 17677: if( nArg==2 ){ 17678: if( booleanValue(azArg[1]) ){ 17679: setBinaryMode(p->out, 1); 17680: }else{ 17681: setTextMode(p->out, 1); 17682: } 17683: }else{ 17684: raw_printf(stderr, "Usage: .binary on|off\n"); 17685: rc = 1; 17686: } 1.2 misho 17687: }else 17688: 1.5 misho 17689: if( c=='c' && strcmp(azArg[0],"cd")==0 ){ 17690: if( nArg==2 ){ 17691: #if defined(_WIN32) || defined(WIN32) 17692: wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]); 17693: rc = !SetCurrentDirectoryW(z); 17694: sqlite3_free(z); 17695: #else 17696: rc = chdir(azArg[1]); 17697: #endif 17698: if( rc ){ 17699: utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]); 17700: rc = 1; 17701: } 17702: }else{ 17703: raw_printf(stderr, "Usage: .cd DIRECTORY\n"); 17704: rc = 1; 17705: } 17706: }else 17707: 1.3 misho 17708: /* The undocumented ".breakpoint" command causes a call to the no-op 17709: ** routine named test_breakpoint(). 17710: */ 17711: if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){ 17712: test_breakpoint(); 17713: }else 17714: 1.4 misho 17715: if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){ 17716: if( nArg==2 ){ 1.5 misho 17717: setOrClearFlag(p, SHFLG_CountChanges, azArg[1]); 1.4 misho 17718: }else{ 17719: raw_printf(stderr, "Usage: .changes on|off\n"); 17720: rc = 1; 17721: } 17722: }else 17723: 1.5 misho 17724: /* Cancel output redirection, if it is currently set (by .testcase) 17725: ** Then read the content of the testcase-out.txt file and compare against 17726: ** azArg[1]. If there are differences, report an error and exit. 17727: */ 17728: if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){ 17729: char *zRes = 0; 17730: output_reset(p); 17731: if( nArg!=2 ){ 17732: raw_printf(stderr, "Usage: .check GLOB-PATTERN\n"); 17733: rc = 2; 17734: }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){ 17735: raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n"); 17736: rc = 2; 17737: }else if( testcase_glob(azArg[1],zRes)==0 ){ 17738: utf8_printf(stderr, 17739: "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n", 17740: p->zTestcase, azArg[1], zRes); 17741: rc = 1; 17742: }else{ 17743: utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase); 17744: p->nCheck++; 17745: } 17746: sqlite3_free(zRes); 17747: }else 17748: 1.4 misho 17749: if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){ 17750: if( nArg==2 ){ 17751: tryToClone(p, azArg[1]); 17752: }else{ 17753: raw_printf(stderr, "Usage: .clone FILENAME\n"); 17754: rc = 1; 17755: } 17756: }else 17757: 17758: if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){ 1.6 ! misho 17759: char **azName = 0; ! 17760: int nName = 0; ! 17761: sqlite3_stmt *pStmt; ! 17762: int i; 1.4 misho 17763: open_db(p, 0); 1.6 ! misho 17764: rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); ! 17765: if( rc ){ ! 17766: utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 1.2 misho 17767: rc = 1; 1.6 ! misho 17768: }else{ ! 17769: while( sqlite3_step(pStmt)==SQLITE_ROW ){ ! 17770: const char *zSchema = (const char *)sqlite3_column_text(pStmt,1); ! 17771: const char *zFile = (const char*)sqlite3_column_text(pStmt,2); ! 17772: azName = sqlite3_realloc(azName, (nName+1)*2*sizeof(char*)); ! 17773: if( azName==0 ){ shell_out_of_memory(); /* Does not return */ } ! 17774: azName[nName*2] = strdup(zSchema); ! 17775: azName[nName*2+1] = strdup(zFile); ! 17776: nName++; ! 17777: } ! 17778: } ! 17779: sqlite3_finalize(pStmt); ! 17780: for(i=0; i<nName; i++){ ! 17781: int eTxn = sqlite3_txn_state(p->db, azName[i*2]); ! 17782: int bRdonly = sqlite3_db_readonly(p->db, azName[i*2]); ! 17783: const char *z = azName[i*2+1]; ! 17784: utf8_printf(p->out, "%s: %s %s%s\n", ! 17785: azName[i*2], ! 17786: z && z[0] ? z : "\"\"", ! 17787: bRdonly ? "r/o" : "r/w", ! 17788: eTxn==SQLITE_TXN_NONE ? "" : ! 17789: eTxn==SQLITE_TXN_READ ? " read-txn" : " write-txn"); ! 17790: free(azName[i*2]); ! 17791: free(azName[i*2+1]); 1.2 misho 17792: } 1.6 ! misho 17793: sqlite3_free(azName); 1.2 misho 17794: }else 17795: 1.5 misho 17796: if( c=='d' && n>=3 && strncmp(azArg[0], "dbconfig", n)==0 ){ 17797: static const struct DbConfigChoices { 17798: const char *zName; 17799: int op; 17800: } aDbConfig[] = { 17801: { "defensive", SQLITE_DBCONFIG_DEFENSIVE }, 17802: { "dqs_ddl", SQLITE_DBCONFIG_DQS_DDL }, 17803: { "dqs_dml", SQLITE_DBCONFIG_DQS_DML }, 17804: { "enable_fkey", SQLITE_DBCONFIG_ENABLE_FKEY }, 17805: { "enable_qpsg", SQLITE_DBCONFIG_ENABLE_QPSG }, 17806: { "enable_trigger", SQLITE_DBCONFIG_ENABLE_TRIGGER }, 17807: { "enable_view", SQLITE_DBCONFIG_ENABLE_VIEW }, 17808: { "fts3_tokenizer", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER }, 17809: { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE }, 17810: { "legacy_file_format", SQLITE_DBCONFIG_LEGACY_FILE_FORMAT }, 17811: { "load_extension", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION }, 17812: { "no_ckpt_on_close", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE }, 17813: { "reset_database", SQLITE_DBCONFIG_RESET_DATABASE }, 17814: { "trigger_eqp", SQLITE_DBCONFIG_TRIGGER_EQP }, 17815: { "trusted_schema", SQLITE_DBCONFIG_TRUSTED_SCHEMA }, 17816: { "writable_schema", SQLITE_DBCONFIG_WRITABLE_SCHEMA }, 17817: }; 17818: int ii, v; 17819: open_db(p, 0); 17820: for(ii=0; ii<ArraySize(aDbConfig); ii++){ 17821: if( nArg>1 && strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue; 17822: if( nArg>=3 ){ 17823: sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0); 17824: } 17825: sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v); 17826: utf8_printf(p->out, "%19s %s\n", aDbConfig[ii].zName, v ? "on" : "off"); 17827: if( nArg>1 ) break; 17828: } 17829: if( nArg>1 && ii==ArraySize(aDbConfig) ){ 17830: utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]); 17831: utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n"); 17832: } 17833: }else 17834: 17835: if( c=='d' && n>=3 && strncmp(azArg[0], "dbinfo", n)==0 ){ 1.4 misho 17836: rc = shell_dbinfo_command(p, nArg, azArg); 17837: }else 17838: 1.5 misho 17839: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) 17840: if( c=='r' && strncmp(azArg[0], "recover", n)==0 ){ 17841: open_db(p, 0); 17842: rc = recoverDatabaseCmd(p, nArg, azArg); 17843: }else 17844: #endif /* !(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB) */ 17845: 1.4 misho 17846: if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ 1.5 misho 17847: char *zLike = 0; 17848: char *zSql; 17849: int i; 17850: int savedShowHeader = p->showHeader; 17851: int savedShellFlags = p->shellFlgs; 1.6 ! misho 17852: ShellClearFlag(p, ! 17853: SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo ! 17854: |SHFLG_DumpDataOnly|SHFLG_DumpNoSys); 1.5 misho 17855: for(i=1; i<nArg; i++){ 17856: if( azArg[i][0]=='-' ){ 17857: const char *z = azArg[i]+1; 17858: if( z[0]=='-' ) z++; 17859: if( strcmp(z,"preserve-rowids")==0 ){ 17860: #ifdef SQLITE_OMIT_VIRTUALTABLE 17861: raw_printf(stderr, "The --preserve-rowids option is not compatible" 17862: " with SQLITE_OMIT_VIRTUALTABLE\n"); 17863: rc = 1; 17864: sqlite3_free(zLike); 17865: goto meta_command_exit; 17866: #else 17867: ShellSetFlag(p, SHFLG_PreserveRowid); 17868: #endif 17869: }else 17870: if( strcmp(z,"newlines")==0 ){ 17871: ShellSetFlag(p, SHFLG_Newlines); 17872: }else 1.6 ! misho 17873: if( strcmp(z,"data-only")==0 ){ ! 17874: ShellSetFlag(p, SHFLG_DumpDataOnly); ! 17875: }else ! 17876: if( strcmp(z,"nosys")==0 ){ ! 17877: ShellSetFlag(p, SHFLG_DumpNoSys); ! 17878: }else 1.5 misho 17879: { 17880: raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]); 17881: rc = 1; 17882: sqlite3_free(zLike); 17883: goto meta_command_exit; 17884: } 17885: }else if( zLike ){ 17886: zLike = sqlite3_mprintf("%z OR name LIKE %Q ESCAPE '\\'", 17887: zLike, azArg[i]); 17888: }else{ 17889: zLike = sqlite3_mprintf("name LIKE %Q ESCAPE '\\'", azArg[i]); 17890: } 17891: } 17892: 1.4 misho 17893: open_db(p, 0); 1.5 misho 17894: 1.6 ! misho 17895: if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){ ! 17896: /* When playing back a "dump", the content might appear in an order ! 17897: ** which causes immediate foreign key constraints to be violated. ! 17898: ** So disable foreign-key constraint enforcement to prevent problems. */ ! 17899: raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n"); ! 17900: raw_printf(p->out, "BEGIN TRANSACTION;\n"); ! 17901: } 1.2 misho 17902: p->writableSchema = 0; 1.5 misho 17903: p->showHeader = 0; 17904: /* Set writable_schema=ON since doing so forces SQLite to initialize 17905: ** as much of the schema as it can even if the sqlite_schema table is 17906: ** corrupt. */ 1.2 misho 17907: sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0); 17908: p->nErr = 0; 1.5 misho 17909: if( zLike==0 ) zLike = sqlite3_mprintf("true"); 17910: zSql = sqlite3_mprintf( 17911: "SELECT name, type, sql FROM sqlite_schema " 17912: "WHERE (%s) AND type=='table'" 17913: " AND sql NOT NULL" 17914: " ORDER BY tbl_name='sqlite_sequence', rowid", 17915: zLike 17916: ); 17917: run_schema_dump_query(p,zSql); 17918: sqlite3_free(zSql); 1.6 ! misho 17919: if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){ ! 17920: zSql = sqlite3_mprintf( ! 17921: "SELECT sql FROM sqlite_schema " ! 17922: "WHERE (%s) AND sql NOT NULL" ! 17923: " AND type IN ('index','trigger','view')", ! 17924: zLike ! 17925: ); ! 17926: run_table_dump_query(p, zSql); ! 17927: sqlite3_free(zSql); ! 17928: } 1.5 misho 17929: sqlite3_free(zLike); 1.2 misho 17930: if( p->writableSchema ){ 1.4 misho 17931: raw_printf(p->out, "PRAGMA writable_schema=OFF;\n"); 1.2 misho 17932: p->writableSchema = 0; 17933: } 17934: sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); 17935: sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0); 1.6 ! misho 17936: if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){ ! 17937: raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n"); ! 17938: } 1.5 misho 17939: p->showHeader = savedShowHeader; 17940: p->shellFlgs = savedShellFlags; 1.4 misho 17941: }else 17942: 17943: if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){ 17944: if( nArg==2 ){ 1.5 misho 17945: setOrClearFlag(p, SHFLG_Echo, azArg[1]); 1.4 misho 17946: }else{ 17947: raw_printf(stderr, "Usage: .echo on|off\n"); 17948: rc = 1; 17949: } 1.2 misho 17950: }else 17951: 1.4 misho 17952: if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){ 17953: if( nArg==2 ){ 1.5 misho 17954: p->autoEQPtest = 0; 17955: if( p->autoEQPtrace ){ 17956: if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0); 17957: p->autoEQPtrace = 0; 17958: } 1.4 misho 17959: if( strcmp(azArg[1],"full")==0 ){ 1.5 misho 17960: p->autoEQP = AUTOEQP_full; 17961: }else if( strcmp(azArg[1],"trigger")==0 ){ 17962: p->autoEQP = AUTOEQP_trigger; 17963: #ifdef SQLITE_DEBUG 17964: }else if( strcmp(azArg[1],"test")==0 ){ 17965: p->autoEQP = AUTOEQP_on; 17966: p->autoEQPtest = 1; 17967: }else if( strcmp(azArg[1],"trace")==0 ){ 17968: p->autoEQP = AUTOEQP_full; 17969: p->autoEQPtrace = 1; 17970: open_db(p, 0); 17971: sqlite3_exec(p->db, "SELECT name FROM sqlite_schema LIMIT 1", 0, 0, 0); 17972: sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0); 17973: #endif 1.4 misho 17974: }else{ 1.5 misho 17975: p->autoEQP = (u8)booleanValue(azArg[1]); 1.4 misho 17976: } 17977: }else{ 1.5 misho 17978: raw_printf(stderr, "Usage: .eqp off|on|trace|trigger|full\n"); 1.4 misho 17979: rc = 1; 17980: } 1.2 misho 17981: }else 17982: 1.4 misho 17983: if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){ 17984: if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc); 1.2 misho 17985: rc = 2; 17986: }else 17987: 1.5 misho 17988: /* The ".explain" command is automatic now. It is largely pointless. It 17989: ** retained purely for backwards compatibility */ 1.4 misho 17990: if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ 17991: int val = 1; 17992: if( nArg>=2 ){ 17993: if( strcmp(azArg[1],"auto")==0 ){ 17994: val = 99; 17995: }else{ 17996: val = booleanValue(azArg[1]); 17997: } 17998: } 17999: if( val==1 && p->mode!=MODE_Explain ){ 18000: p->normalMode = p->mode; 1.2 misho 18001: p->mode = MODE_Explain; 1.4 misho 18002: p->autoExplain = 0; 18003: }else if( val==0 ){ 18004: if( p->mode==MODE_Explain ) p->mode = p->normalMode; 18005: p->autoExplain = 0; 18006: }else if( val==99 ){ 18007: if( p->mode==MODE_Explain ) p->mode = p->normalMode; 18008: p->autoExplain = 1; 18009: } 18010: }else 18011: 1.5 misho 18012: #ifndef SQLITE_OMIT_VIRTUALTABLE 18013: if( c=='e' && strncmp(azArg[0], "expert", n)==0 ){ 18014: open_db(p, 0); 18015: expertDotCommand(p, azArg, nArg); 18016: }else 18017: #endif 18018: 18019: if( c=='f' && strncmp(azArg[0], "filectrl", n)==0 ){ 18020: static const struct { 18021: const char *zCtrlName; /* Name of a test-control option */ 18022: int ctrlCode; /* Integer code for that option */ 18023: const char *zUsage; /* Usage notes */ 18024: } aCtrl[] = { 18025: { "chunk_size", SQLITE_FCNTL_CHUNK_SIZE, "SIZE" }, 1.6 ! misho 18026: { "data_version", SQLITE_FCNTL_DATA_VERSION, "" }, ! 18027: { "has_moved", SQLITE_FCNTL_HAS_MOVED, "" }, ! 18028: { "lock_timeout", SQLITE_FCNTL_LOCK_TIMEOUT, "MILLISEC" }, 1.5 misho 18029: { "persist_wal", SQLITE_FCNTL_PERSIST_WAL, "[BOOLEAN]" }, 1.6 ! misho 18030: /* { "pragma", SQLITE_FCNTL_PRAGMA, "NAME ARG" },*/ 1.5 misho 18031: { "psow", SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]" }, 1.6 ! misho 18032: { "reserve_bytes", SQLITE_FCNTL_RESERVE_BYTES, "[N]" }, ! 18033: { "size_limit", SQLITE_FCNTL_SIZE_LIMIT, "[LIMIT]" }, 1.5 misho 18034: { "tempfilename", SQLITE_FCNTL_TEMPFILENAME, "" }, 1.6 ! misho 18035: /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY, "COUNT DELAY" },*/ 1.5 misho 18036: }; 18037: int filectrl = -1; 18038: int iCtrl = -1; 18039: sqlite3_int64 iRes = 0; /* Integer result to display if rc2==1 */ 18040: int isOk = 0; /* 0: usage 1: %lld 2: no-result */ 18041: int n2, i; 18042: const char *zCmd = 0; 18043: const char *zSchema = 0; 18044: 18045: open_db(p, 0); 18046: zCmd = nArg>=2 ? azArg[1] : "help"; 18047: 18048: if( zCmd[0]=='-' 18049: && (strcmp(zCmd,"--schema")==0 || strcmp(zCmd,"-schema")==0) 18050: && nArg>=4 18051: ){ 18052: zSchema = azArg[2]; 18053: for(i=3; i<nArg; i++) azArg[i-2] = azArg[i]; 18054: nArg -= 2; 18055: zCmd = azArg[1]; 18056: } 18057: 18058: /* The argument can optionally begin with "-" or "--" */ 18059: if( zCmd[0]=='-' && zCmd[1] ){ 18060: zCmd++; 18061: if( zCmd[0]=='-' && zCmd[1] ) zCmd++; 18062: } 18063: 18064: /* --help lists all file-controls */ 18065: if( strcmp(zCmd,"help")==0 ){ 18066: utf8_printf(p->out, "Available file-controls:\n"); 18067: for(i=0; i<ArraySize(aCtrl); i++){ 18068: utf8_printf(p->out, " .filectrl %s %s\n", 18069: aCtrl[i].zCtrlName, aCtrl[i].zUsage); 18070: } 18071: rc = 1; 18072: goto meta_command_exit; 18073: } 18074: 18075: /* convert filectrl text option to value. allow any unique prefix 18076: ** of the option name, or a numerical value. */ 18077: n2 = strlen30(zCmd); 18078: for(i=0; i<ArraySize(aCtrl); i++){ 18079: if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){ 18080: if( filectrl<0 ){ 18081: filectrl = aCtrl[i].ctrlCode; 18082: iCtrl = i; 18083: }else{ 18084: utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n" 18085: "Use \".filectrl --help\" for help\n", zCmd); 18086: rc = 1; 18087: goto meta_command_exit; 18088: } 18089: } 18090: } 18091: if( filectrl<0 ){ 18092: utf8_printf(stderr,"Error: unknown file-control: %s\n" 18093: "Use \".filectrl --help\" for help\n", zCmd); 18094: }else{ 18095: switch(filectrl){ 18096: case SQLITE_FCNTL_SIZE_LIMIT: { 18097: if( nArg!=2 && nArg!=3 ) break; 18098: iRes = nArg==3 ? integerValue(azArg[2]) : -1; 18099: sqlite3_file_control(p->db, zSchema, SQLITE_FCNTL_SIZE_LIMIT, &iRes); 18100: isOk = 1; 18101: break; 18102: } 18103: case SQLITE_FCNTL_LOCK_TIMEOUT: 18104: case SQLITE_FCNTL_CHUNK_SIZE: { 18105: int x; 18106: if( nArg!=3 ) break; 18107: x = (int)integerValue(azArg[2]); 18108: sqlite3_file_control(p->db, zSchema, filectrl, &x); 18109: isOk = 2; 18110: break; 18111: } 18112: case SQLITE_FCNTL_PERSIST_WAL: 18113: case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { 18114: int x; 18115: if( nArg!=2 && nArg!=3 ) break; 18116: x = nArg==3 ? booleanValue(azArg[2]) : -1; 18117: sqlite3_file_control(p->db, zSchema, filectrl, &x); 18118: iRes = x; 18119: isOk = 1; 18120: break; 18121: } 1.6 ! misho 18122: case SQLITE_FCNTL_DATA_VERSION: 1.5 misho 18123: case SQLITE_FCNTL_HAS_MOVED: { 18124: int x; 18125: if( nArg!=2 ) break; 18126: sqlite3_file_control(p->db, zSchema, filectrl, &x); 18127: iRes = x; 18128: isOk = 1; 18129: break; 18130: } 18131: case SQLITE_FCNTL_TEMPFILENAME: { 18132: char *z = 0; 18133: if( nArg!=2 ) break; 18134: sqlite3_file_control(p->db, zSchema, filectrl, &z); 18135: if( z ){ 18136: utf8_printf(p->out, "%s\n", z); 18137: sqlite3_free(z); 18138: } 18139: isOk = 2; 18140: break; 18141: } 18142: case SQLITE_FCNTL_RESERVE_BYTES: { 18143: int x; 18144: if( nArg>=3 ){ 18145: x = atoi(azArg[2]); 18146: sqlite3_file_control(p->db, zSchema, filectrl, &x); 18147: } 18148: x = -1; 18149: sqlite3_file_control(p->db, zSchema, filectrl, &x); 18150: utf8_printf(p->out,"%d\n", x); 18151: isOk = 2; 18152: break; 18153: } 18154: } 18155: } 18156: if( isOk==0 && iCtrl>=0 ){ 18157: utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage); 18158: rc = 1; 18159: }else if( isOk==1 ){ 18160: char zBuf[100]; 18161: sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes); 18162: raw_printf(p->out, "%s\n", zBuf); 18163: } 18164: }else 18165: 1.4 misho 18166: if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){ 18167: ShellState data; 18168: char *zErrMsg = 0; 18169: int doStats = 0; 18170: memcpy(&data, p, sizeof(data)); 18171: data.showHeader = 0; 18172: data.cMode = data.mode = MODE_Semi; 18173: if( nArg==2 && optionMatch(azArg[1], "indent") ){ 18174: data.cMode = data.mode = MODE_Pretty; 18175: nArg = 1; 18176: } 18177: if( nArg!=1 ){ 18178: raw_printf(stderr, "Usage: .fullschema ?--indent?\n"); 18179: rc = 1; 18180: goto meta_command_exit; 18181: } 18182: open_db(p, 0); 18183: rc = sqlite3_exec(p->db, 18184: "SELECT sql FROM" 18185: " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" 1.5 misho 18186: " FROM sqlite_schema UNION ALL" 18187: " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_schema) " 1.4 misho 18188: "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " 18189: "ORDER BY rowid", 18190: callback, &data, &zErrMsg 18191: ); 18192: if( rc==SQLITE_OK ){ 18193: sqlite3_stmt *pStmt; 18194: rc = sqlite3_prepare_v2(p->db, 1.5 misho 18195: "SELECT rowid FROM sqlite_schema" 1.4 misho 18196: " WHERE name GLOB 'sqlite_stat[134]'", 18197: -1, &pStmt, 0); 18198: doStats = sqlite3_step(pStmt)==SQLITE_ROW; 18199: sqlite3_finalize(pStmt); 18200: } 18201: if( doStats==0 ){ 18202: raw_printf(p->out, "/* No STAT tables available */\n"); 18203: }else{ 1.5 misho 18204: raw_printf(p->out, "ANALYZE sqlite_schema;\n"); 18205: sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_schema'", 1.4 misho 18206: callback, &data, &zErrMsg); 18207: data.cMode = data.mode = MODE_Insert; 18208: data.zDestTable = "sqlite_stat1"; 1.5 misho 18209: shell_exec(&data, "SELECT * FROM sqlite_stat1", &zErrMsg); 1.4 misho 18210: data.zDestTable = "sqlite_stat4"; 1.5 misho 18211: shell_exec(&data, "SELECT * FROM sqlite_stat4", &zErrMsg); 18212: raw_printf(p->out, "ANALYZE sqlite_schema;\n"); 1.2 misho 18213: } 18214: }else 18215: 1.4 misho 18216: if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){ 18217: if( nArg==2 ){ 18218: p->showHeader = booleanValue(azArg[1]); 1.5 misho 18219: p->shellFlgs |= SHFLG_HeaderSet; 1.4 misho 18220: }else{ 18221: raw_printf(stderr, "Usage: .headers on|off\n"); 18222: rc = 1; 18223: } 1.2 misho 18224: }else 18225: 1.5 misho 18226: if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ 18227: if( nArg>=2 ){ 18228: n = showHelp(p->out, azArg[1]); 18229: if( n==0 ){ 18230: utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]); 18231: } 18232: }else{ 18233: showHelp(p->out, 0); 18234: } 18235: }else 18236: 18237: if( c=='i' && strncmp(azArg[0], "import", n)==0 ){ 18238: char *zTable = 0; /* Insert data into this table */ 18239: char *zFile = 0; /* Name of file to extra content from */ 18240: sqlite3_stmt *pStmt = NULL; /* A statement */ 18241: int nCol; /* Number of columns in the table */ 18242: int nByte; /* Number of bytes in an SQL string */ 18243: int i, j; /* Loop counters */ 18244: int needCommit; /* True to COMMIT or ROLLBACK at end */ 18245: int nSep; /* Number of bytes in p->colSeparator[] */ 18246: char *zSql; /* An SQL statement */ 18247: ImportCtx sCtx; /* Reader context */ 18248: char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */ 18249: int eVerbose = 0; /* Larger for more console output */ 18250: int nSkip = 0; /* Initial lines to skip */ 18251: int useOutputMode = 1; /* Use output mode to determine separators */ 18252: 18253: memset(&sCtx, 0, sizeof(sCtx)); 18254: if( p->mode==MODE_Ascii ){ 18255: xRead = ascii_read_one_field; 18256: }else{ 18257: xRead = csv_read_one_field; 18258: } 18259: for(i=1; i<nArg; i++){ 18260: char *z = azArg[i]; 18261: if( z[0]=='-' && z[1]=='-' ) z++; 18262: if( z[0]!='-' ){ 18263: if( zFile==0 ){ 18264: zFile = z; 18265: }else if( zTable==0 ){ 18266: zTable = z; 18267: }else{ 18268: utf8_printf(p->out, "ERROR: extra argument: \"%s\". Usage:\n", z); 18269: showHelp(p->out, "import"); 18270: rc = 1; 18271: goto meta_command_exit; 18272: } 18273: }else if( strcmp(z,"-v")==0 ){ 18274: eVerbose++; 18275: }else if( strcmp(z,"-skip")==0 && i<nArg-1 ){ 18276: nSkip = integerValue(azArg[++i]); 18277: }else if( strcmp(z,"-ascii")==0 ){ 18278: sCtx.cColSep = SEP_Unit[0]; 18279: sCtx.cRowSep = SEP_Record[0]; 18280: xRead = ascii_read_one_field; 18281: useOutputMode = 0; 18282: }else if( strcmp(z,"-csv")==0 ){ 18283: sCtx.cColSep = ','; 18284: sCtx.cRowSep = '\n'; 18285: xRead = csv_read_one_field; 18286: useOutputMode = 0; 18287: }else{ 18288: utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n", z); 18289: showHelp(p->out, "import"); 18290: rc = 1; 18291: goto meta_command_exit; 18292: } 18293: } 18294: if( zTable==0 ){ 18295: utf8_printf(p->out, "ERROR: missing %s argument. Usage:\n", 18296: zFile==0 ? "FILE" : "TABLE"); 18297: showHelp(p->out, "import"); 18298: rc = 1; 1.4 misho 18299: goto meta_command_exit; 18300: } 18301: seenInterrupt = 0; 18302: open_db(p, 0); 1.5 misho 18303: if( useOutputMode ){ 18304: /* If neither the --csv or --ascii options are specified, then set 18305: ** the column and row separator characters from the output mode. */ 18306: nSep = strlen30(p->colSeparator); 18307: if( nSep==0 ){ 18308: raw_printf(stderr, 18309: "Error: non-null column separator required for import\n"); 18310: rc = 1; 18311: goto meta_command_exit; 18312: } 18313: if( nSep>1 ){ 18314: raw_printf(stderr, 18315: "Error: multi-character column separators not allowed" 18316: " for import\n"); 18317: rc = 1; 18318: goto meta_command_exit; 18319: } 1.4 misho 18320: nSep = strlen30(p->rowSeparator); 1.5 misho 18321: if( nSep==0 ){ 18322: raw_printf(stderr, 18323: "Error: non-null row separator required for import\n"); 18324: rc = 1; 18325: goto meta_command_exit; 18326: } 18327: if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator,SEP_CrLf)==0 ){ 18328: /* When importing CSV (only), if the row separator is set to the 18329: ** default output row separator, change it to the default input 18330: ** row separator. This avoids having to maintain different input 18331: ** and output row separators. */ 18332: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 18333: nSep = strlen30(p->rowSeparator); 18334: } 18335: if( nSep>1 ){ 18336: raw_printf(stderr, "Error: multi-character row separators not allowed" 18337: " for import\n"); 18338: rc = 1; 18339: goto meta_command_exit; 18340: } 18341: sCtx.cColSep = p->colSeparator[0]; 18342: sCtx.cRowSep = p->rowSeparator[0]; 1.4 misho 18343: } 18344: sCtx.zFile = zFile; 18345: sCtx.nLine = 1; 18346: if( sCtx.zFile[0]=='|' ){ 18347: #ifdef SQLITE_OMIT_POPEN 18348: raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 1.5 misho 18349: rc = 1; 18350: goto meta_command_exit; 1.4 misho 18351: #else 18352: sCtx.in = popen(sCtx.zFile+1, "r"); 18353: sCtx.zFile = "<pipe>"; 1.5 misho 18354: sCtx.xCloser = pclose; 1.4 misho 18355: #endif 18356: }else{ 18357: sCtx.in = fopen(sCtx.zFile, "rb"); 1.5 misho 18358: sCtx.xCloser = fclose; 1.4 misho 18359: } 18360: if( sCtx.in==0 ){ 18361: utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile); 1.5 misho 18362: rc = 1; 18363: goto meta_command_exit; 18364: } 18365: if( eVerbose>=2 || (eVerbose>=1 && useOutputMode) ){ 18366: char zSep[2]; 18367: zSep[1] = 0; 18368: zSep[0] = sCtx.cColSep; 18369: utf8_printf(p->out, "Column separator "); 18370: output_c_string(p->out, zSep); 18371: utf8_printf(p->out, ", row separator "); 18372: zSep[0] = sCtx.cRowSep; 18373: output_c_string(p->out, zSep); 18374: utf8_printf(p->out, "\n"); 18375: } 18376: while( (nSkip--)>0 ){ 18377: while( xRead(&sCtx) && sCtx.cTerm==sCtx.cColSep ){} 1.4 misho 18378: } 1.6 ! misho 18379: zSql = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); 1.2 misho 18380: if( zSql==0 ){ 1.5 misho 18381: import_cleanup(&sCtx); 18382: shell_out_of_memory(); 1.2 misho 18383: } 18384: nByte = strlen30(zSql); 1.4 misho 18385: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 18386: import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */ 18387: if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){ 1.6 ! misho 18388: char *zCreate = sqlite3_mprintf("CREATE TABLE \"%w\"", zTable); 1.4 misho 18389: char cSep = '('; 18390: while( xRead(&sCtx) ){ 18391: zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z); 18392: cSep = ','; 18393: if( sCtx.cTerm!=sCtx.cColSep ) break; 18394: } 18395: if( cSep=='(' ){ 18396: sqlite3_free(zCreate); 1.5 misho 18397: import_cleanup(&sCtx); 1.4 misho 18398: utf8_printf(stderr,"%s: empty file\n", sCtx.zFile); 1.5 misho 18399: rc = 1; 18400: goto meta_command_exit; 1.4 misho 18401: } 18402: zCreate = sqlite3_mprintf("%z\n)", zCreate); 1.5 misho 18403: if( eVerbose>=1 ){ 18404: utf8_printf(p->out, "%s\n", zCreate); 18405: } 1.4 misho 18406: rc = sqlite3_exec(p->db, zCreate, 0, 0, 0); 18407: sqlite3_free(zCreate); 18408: if( rc ){ 1.6 ! misho 18409: utf8_printf(stderr, "CREATE TABLE \"%s\"(...) failed: %s\n", zTable, 1.4 misho 18410: sqlite3_errmsg(p->db)); 1.5 misho 18411: import_cleanup(&sCtx); 18412: rc = 1; 18413: goto meta_command_exit; 1.4 misho 18414: } 18415: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 18416: } 1.2 misho 18417: sqlite3_free(zSql); 18418: if( rc ){ 18419: if (pStmt) sqlite3_finalize(pStmt); 1.4 misho 18420: utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db)); 1.5 misho 18421: import_cleanup(&sCtx); 18422: rc = 1; 18423: goto meta_command_exit; 1.2 misho 18424: } 18425: nCol = sqlite3_column_count(pStmt); 18426: sqlite3_finalize(pStmt); 18427: pStmt = 0; 18428: if( nCol==0 ) return 0; /* no columns, no error */ 1.4 misho 18429: zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 ); 1.2 misho 18430: if( zSql==0 ){ 1.5 misho 18431: import_cleanup(&sCtx); 18432: shell_out_of_memory(); 1.2 misho 18433: } 1.4 misho 18434: sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable); 1.2 misho 18435: j = strlen30(zSql); 18436: for(i=1; i<nCol; i++){ 18437: zSql[j++] = ','; 18438: zSql[j++] = '?'; 18439: } 18440: zSql[j++] = ')'; 18441: zSql[j] = 0; 1.5 misho 18442: if( eVerbose>=2 ){ 18443: utf8_printf(p->out, "Insert using: %s\n", zSql); 18444: } 1.4 misho 18445: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 18446: sqlite3_free(zSql); 1.2 misho 18447: if( rc ){ 1.4 misho 18448: utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 1.2 misho 18449: if (pStmt) sqlite3_finalize(pStmt); 1.5 misho 18450: import_cleanup(&sCtx); 18451: rc = 1; 18452: goto meta_command_exit; 1.2 misho 18453: } 1.4 misho 18454: needCommit = sqlite3_get_autocommit(p->db); 18455: if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0); 18456: do{ 18457: int startLine = sCtx.nLine; 18458: for(i=0; i<nCol; i++){ 18459: char *z = xRead(&sCtx); 18460: /* 18461: ** Did we reach end-of-file before finding any columns? 18462: ** If so, stop instead of NULL filling the remaining columns. 18463: */ 18464: if( z==0 && i==0 ) break; 18465: /* 18466: ** Did we reach end-of-file OR end-of-line before finding any 18467: ** columns in ASCII mode? If so, stop instead of NULL filling 18468: ** the remaining columns. 18469: */ 18470: if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break; 18471: sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT); 18472: if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){ 18473: utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 18474: "filling the rest with NULL\n", 18475: sCtx.zFile, startLine, nCol, i+1); 18476: i += 2; 18477: while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; } 18478: } 18479: } 18480: if( sCtx.cTerm==sCtx.cColSep ){ 18481: do{ 18482: xRead(&sCtx); 1.2 misho 18483: i++; 1.4 misho 18484: }while( sCtx.cTerm==sCtx.cColSep ); 18485: utf8_printf(stderr, "%s:%d: expected %d columns but found %d - " 18486: "extras ignored\n", 18487: sCtx.zFile, startLine, nCol, i); 18488: } 18489: if( i>=nCol ){ 18490: sqlite3_step(pStmt); 18491: rc = sqlite3_reset(pStmt); 18492: if( rc!=SQLITE_OK ){ 18493: utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, 18494: startLine, sqlite3_errmsg(p->db)); 1.5 misho 18495: sCtx.nErr++; 18496: }else{ 18497: sCtx.nRow++; 1.2 misho 18498: } 18499: } 1.4 misho 18500: }while( sCtx.cTerm!=EOF ); 18501: 1.5 misho 18502: import_cleanup(&sCtx); 1.2 misho 18503: sqlite3_finalize(pStmt); 1.4 misho 18504: if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0); 1.5 misho 18505: if( eVerbose>0 ){ 18506: utf8_printf(p->out, 18507: "Added %d rows with %d errors using %d lines of input\n", 18508: sCtx.nRow, sCtx.nErr, sCtx.nLine-1); 18509: } 1.2 misho 18510: }else 18511: 1.5 misho 18512: #ifndef SQLITE_UNTESTABLE 18513: if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){ 18514: char *zSql; 18515: char *zCollist = 0; 18516: sqlite3_stmt *pStmt; 18517: int tnum = 0; 18518: int isWO = 0; /* True if making an imposter of a WITHOUT ROWID table */ 18519: int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */ 18520: int i; 18521: if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){ 18522: utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n" 18523: " .imposter off\n"); 18524: /* Also allowed, but not documented: 18525: ** 18526: ** .imposter TABLE IMPOSTER 18527: ** 18528: ** where TABLE is a WITHOUT ROWID table. In that case, the 18529: ** imposter is another WITHOUT ROWID table with the columns in 18530: ** storage order. */ 18531: rc = 1; 18532: goto meta_command_exit; 18533: } 1.4 misho 18534: open_db(p, 0); 1.5 misho 18535: if( nArg==2 ){ 18536: sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1); 18537: goto meta_command_exit; 18538: } 18539: zSql = sqlite3_mprintf( 18540: "SELECT rootpage, 0 FROM sqlite_schema" 18541: " WHERE name='%q' AND type='index'" 18542: "UNION ALL " 18543: "SELECT rootpage, 1 FROM sqlite_schema" 18544: " WHERE name='%q' AND type='table'" 18545: " AND sql LIKE '%%without%%rowid%%'", 18546: azArg[1], azArg[1] 18547: ); 18548: sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 18549: sqlite3_free(zSql); 18550: if( sqlite3_step(pStmt)==SQLITE_ROW ){ 18551: tnum = sqlite3_column_int(pStmt, 0); 18552: isWO = sqlite3_column_int(pStmt, 1); 18553: } 18554: sqlite3_finalize(pStmt); 18555: zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]); 18556: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 18557: sqlite3_free(zSql); 18558: i = 0; 18559: while( sqlite3_step(pStmt)==SQLITE_ROW ){ 18560: char zLabel[20]; 18561: const char *zCol = (const char*)sqlite3_column_text(pStmt,2); 18562: i++; 18563: if( zCol==0 ){ 18564: if( sqlite3_column_int(pStmt,1)==-1 ){ 18565: zCol = "_ROWID_"; 18566: }else{ 18567: sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i); 18568: zCol = zLabel; 18569: } 18570: } 18571: if( isWO && lenPK==0 && sqlite3_column_int(pStmt,5)==0 && zCollist ){ 18572: lenPK = (int)strlen(zCollist); 18573: } 18574: if( zCollist==0 ){ 18575: zCollist = sqlite3_mprintf("\"%w\"", zCol); 18576: }else{ 18577: zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol); 18578: } 18579: } 18580: sqlite3_finalize(pStmt); 18581: if( i==0 || tnum==0 ){ 18582: utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]); 1.4 misho 18583: rc = 1; 1.5 misho 18584: sqlite3_free(zCollist); 1.4 misho 18585: goto meta_command_exit; 1.2 misho 18586: } 1.5 misho 18587: if( lenPK==0 ) lenPK = 100000; 18588: zSql = sqlite3_mprintf( 18589: "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%.*s))WITHOUT ROWID", 18590: azArg[2], zCollist, lenPK, zCollist); 18591: sqlite3_free(zCollist); 18592: rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum); 18593: if( rc==SQLITE_OK ){ 18594: rc = sqlite3_exec(p->db, zSql, 0, 0, 0); 18595: sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0); 18596: if( rc ){ 18597: utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db)); 18598: }else{ 18599: utf8_printf(stdout, "%s;\n", zSql); 18600: raw_printf(stdout, 18601: "WARNING: writing to an imposter table will corrupt the \"%s\" %s!\n", 18602: azArg[1], isWO ? "table" : "index" 18603: ); 18604: } 18605: }else{ 18606: raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc); 1.2 misho 18607: rc = 1; 18608: } 1.5 misho 18609: sqlite3_free(zSql); 1.2 misho 18610: }else 1.5 misho 18611: #endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */ 1.2 misho 18612: 18613: #ifdef SQLITE_ENABLE_IOTRACE 18614: if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ 1.4 misho 18615: SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...); 1.2 misho 18616: if( iotrace && iotrace!=stdout ) fclose(iotrace); 18617: iotrace = 0; 18618: if( nArg<2 ){ 18619: sqlite3IoTrace = 0; 18620: }else if( strcmp(azArg[1], "-")==0 ){ 18621: sqlite3IoTrace = iotracePrintf; 18622: iotrace = stdout; 1.4 misho 18623: }else{ 18624: iotrace = fopen(azArg[1], "w"); 18625: if( iotrace==0 ){ 18626: utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); 18627: sqlite3IoTrace = 0; 18628: rc = 1; 18629: }else{ 18630: sqlite3IoTrace = iotracePrintf; 18631: } 18632: } 18633: }else 18634: #endif 1.5 misho 18635: 1.4 misho 18636: if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){ 18637: static const struct { 18638: const char *zLimitName; /* Name of a limit */ 18639: int limitCode; /* Integer code for that limit */ 18640: } aLimit[] = { 18641: { "length", SQLITE_LIMIT_LENGTH }, 18642: { "sql_length", SQLITE_LIMIT_SQL_LENGTH }, 18643: { "column", SQLITE_LIMIT_COLUMN }, 18644: { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH }, 18645: { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT }, 18646: { "vdbe_op", SQLITE_LIMIT_VDBE_OP }, 18647: { "function_arg", SQLITE_LIMIT_FUNCTION_ARG }, 18648: { "attached", SQLITE_LIMIT_ATTACHED }, 18649: { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH }, 18650: { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER }, 18651: { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH }, 18652: { "worker_threads", SQLITE_LIMIT_WORKER_THREADS }, 18653: }; 18654: int i, n2; 18655: open_db(p, 0); 18656: if( nArg==1 ){ 18657: for(i=0; i<ArraySize(aLimit); i++){ 18658: printf("%20s %d\n", aLimit[i].zLimitName, 18659: sqlite3_limit(p->db, aLimit[i].limitCode, -1)); 18660: } 18661: }else if( nArg>3 ){ 18662: raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n"); 18663: rc = 1; 18664: goto meta_command_exit; 18665: }else{ 18666: int iLimit = -1; 18667: n2 = strlen30(azArg[1]); 18668: for(i=0; i<ArraySize(aLimit); i++){ 18669: if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){ 18670: if( iLimit<0 ){ 18671: iLimit = i; 18672: }else{ 18673: utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]); 18674: rc = 1; 18675: goto meta_command_exit; 18676: } 18677: } 18678: } 18679: if( iLimit<0 ){ 18680: utf8_printf(stderr, "unknown limit: \"%s\"\n" 18681: "enter \".limits\" with no arguments for a list.\n", 18682: azArg[1]); 1.2 misho 18683: rc = 1; 1.4 misho 18684: goto meta_command_exit; 18685: } 18686: if( nArg==3 ){ 18687: sqlite3_limit(p->db, aLimit[iLimit].limitCode, 18688: (int)integerValue(azArg[2])); 1.2 misho 18689: } 1.4 misho 18690: printf("%20s %d\n", aLimit[iLimit].zLimitName, 18691: sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1)); 1.2 misho 18692: } 18693: }else 18694: 1.5 misho 18695: if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){ 18696: open_db(p, 0); 18697: lintDotCommand(p, azArg, nArg); 18698: }else 18699: 1.2 misho 18700: #ifndef SQLITE_OMIT_LOAD_EXTENSION 1.4 misho 18701: if( c=='l' && strncmp(azArg[0], "load", n)==0 ){ 1.2 misho 18702: const char *zFile, *zProc; 18703: char *zErrMsg = 0; 1.4 misho 18704: if( nArg<2 ){ 18705: raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n"); 18706: rc = 1; 18707: goto meta_command_exit; 18708: } 1.2 misho 18709: zFile = azArg[1]; 18710: zProc = nArg>=3 ? azArg[2] : 0; 1.4 misho 18711: open_db(p, 0); 1.2 misho 18712: rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); 18713: if( rc!=SQLITE_OK ){ 1.4 misho 18714: utf8_printf(stderr, "Error: %s\n", zErrMsg); 1.2 misho 18715: sqlite3_free(zErrMsg); 18716: rc = 1; 18717: } 18718: }else 18719: #endif 18720: 1.4 misho 18721: if( c=='l' && strncmp(azArg[0], "log", n)==0 ){ 18722: if( nArg!=2 ){ 18723: raw_printf(stderr, "Usage: .log FILENAME\n"); 18724: rc = 1; 18725: }else{ 18726: const char *zFile = azArg[1]; 18727: output_file_close(p->pLog); 1.5 misho 18728: p->pLog = output_file_open(zFile, 0); 1.4 misho 18729: } 1.2 misho 18730: }else 18731: 1.4 misho 18732: if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){ 18733: const char *zMode = nArg>=2 ? azArg[1] : ""; 1.5 misho 18734: int n2 = strlen30(zMode); 1.4 misho 18735: int c2 = zMode[0]; 18736: if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){ 1.2 misho 18737: p->mode = MODE_Line; 1.5 misho 18738: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 1.4 misho 18739: }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){ 1.2 misho 18740: p->mode = MODE_Column; 1.5 misho 18741: if( (p->shellFlgs & SHFLG_HeaderSet)==0 ){ 18742: p->showHeader = 1; 18743: } 18744: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 1.4 misho 18745: }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){ 1.2 misho 18746: p->mode = MODE_List; 1.5 misho 18747: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column); 18748: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 1.4 misho 18749: }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){ 1.2 misho 18750: p->mode = MODE_Html; 1.4 misho 18751: }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){ 1.2 misho 18752: p->mode = MODE_Tcl; 1.4 misho 18753: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space); 1.5 misho 18754: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 1.4 misho 18755: }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){ 1.2 misho 18756: p->mode = MODE_Csv; 1.4 misho 18757: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 18758: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 18759: }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){ 1.2 misho 18760: p->mode = MODE_List; 1.4 misho 18761: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab); 18762: }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){ 1.2 misho 18763: p->mode = MODE_Insert; 1.4 misho 18764: set_table_name(p, nArg>=3 ? azArg[2] : "table"); 1.5 misho 18765: }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){ 18766: p->mode = MODE_Quote; 18767: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 18768: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); 1.4 misho 18769: }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){ 18770: p->mode = MODE_Ascii; 18771: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit); 18772: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record); 1.5 misho 18773: }else if( c2=='m' && strncmp(azArg[1],"markdown",n2)==0 ){ 18774: p->mode = MODE_Markdown; 18775: }else if( c2=='t' && strncmp(azArg[1],"table",n2)==0 ){ 18776: p->mode = MODE_Table; 18777: }else if( c2=='b' && strncmp(azArg[1],"box",n2)==0 ){ 18778: p->mode = MODE_Box; 18779: }else if( c2=='j' && strncmp(azArg[1],"json",n2)==0 ){ 18780: p->mode = MODE_Json; 18781: }else if( nArg==1 ){ 18782: raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]); 18783: }else{ 1.4 misho 18784: raw_printf(stderr, "Error: mode should be one of: " 1.5 misho 18785: "ascii box column csv html insert json line list markdown " 18786: "quote table tabs tcl\n"); 1.2 misho 18787: rc = 1; 18788: } 1.4 misho 18789: p->cMode = p->mode; 1.2 misho 18790: }else 18791: 1.4 misho 18792: if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){ 18793: if( nArg==2 ){ 18794: sqlite3_snprintf(sizeof(p->nullValue), p->nullValue, 18795: "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]); 18796: }else{ 18797: raw_printf(stderr, "Usage: .nullvalue STRING\n"); 1.2 misho 18798: rc = 1; 18799: } 18800: }else 18801: 1.5 misho 18802: #ifdef SQLITE_DEBUG 18803: if( c=='o' && strcmp(azArg[0],"oom")==0 ){ 18804: int i; 18805: for(i=1; i<nArg; i++){ 18806: const char *z = azArg[i]; 18807: if( z[0]=='-' && z[1]=='-' ) z++; 18808: if( strcmp(z,"-repeat")==0 ){ 18809: if( i==nArg-1 ){ 18810: raw_printf(p->out, "missing argument on \"%s\"\n", azArg[i]); 18811: rc = 1; 18812: }else{ 18813: oomRepeat = (int)integerValue(azArg[++i]); 18814: } 18815: }else if( IsDigit(z[0]) ){ 18816: oomCounter = (int)integerValue(azArg[i]); 18817: }else{ 18818: raw_printf(p->out, "unknown argument: \"%s\"\n", azArg[i]); 18819: raw_printf(p->out, "Usage: .oom [--repeat N] [M]\n"); 18820: rc = 1; 18821: } 18822: } 18823: if( rc==0 ){ 18824: raw_printf(p->out, "oomCounter = %d\n", oomCounter); 18825: raw_printf(p->out, "oomRepeat = %d\n", oomRepeat); 18826: } 18827: }else 18828: #endif /* SQLITE_DEBUG */ 18829: 1.4 misho 18830: if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){ 1.6 ! misho 18831: char *zNewFilename = 0; /* Name of the database file to open */ ! 18832: int iName = 1; /* Index in azArg[] of the filename */ ! 18833: int newFlag = 0; /* True to delete file before opening */ 1.5 misho 18834: /* Close the existing database */ 18835: session_close_all(p); 18836: close_db(p->db); 1.4 misho 18837: p->db = 0; 1.5 misho 18838: p->zDbFilename = 0; 18839: sqlite3_free(p->zFreeOnClose); 18840: p->zFreeOnClose = 0; 18841: p->openMode = SHELL_OPEN_UNSPEC; 18842: p->openFlags = 0; 18843: p->szMax = 0; 18844: /* Check for command-line arguments */ 1.6 ! misho 18845: for(iName=1; iName<nArg; iName++){ 1.5 misho 18846: const char *z = azArg[iName]; 18847: if( optionMatch(z,"new") ){ 18848: newFlag = 1; 18849: #ifdef SQLITE_HAVE_ZLIB 18850: }else if( optionMatch(z, "zip") ){ 18851: p->openMode = SHELL_OPEN_ZIPFILE; 18852: #endif 18853: }else if( optionMatch(z, "append") ){ 18854: p->openMode = SHELL_OPEN_APPENDVFS; 18855: }else if( optionMatch(z, "readonly") ){ 18856: p->openMode = SHELL_OPEN_READONLY; 18857: }else if( optionMatch(z, "nofollow") ){ 18858: p->openFlags |= SQLITE_OPEN_NOFOLLOW; 18859: #ifdef SQLITE_ENABLE_DESERIALIZE 18860: }else if( optionMatch(z, "deserialize") ){ 18861: p->openMode = SHELL_OPEN_DESERIALIZE; 18862: }else if( optionMatch(z, "hexdb") ){ 18863: p->openMode = SHELL_OPEN_HEXDB; 18864: }else if( optionMatch(z, "maxsize") && iName+1<nArg ){ 18865: p->szMax = integerValue(azArg[++iName]); 18866: #endif /* SQLITE_ENABLE_DESERIALIZE */ 18867: }else if( z[0]=='-' ){ 18868: utf8_printf(stderr, "unknown option: %s\n", z); 18869: rc = 1; 18870: goto meta_command_exit; 1.6 ! misho 18871: }else if( zNewFilename ){ ! 18872: utf8_printf(stderr, "extra argument: \"%s\"\n", z); ! 18873: rc = 1; ! 18874: goto meta_command_exit; ! 18875: }else{ ! 18876: zNewFilename = sqlite3_mprintf("%s", z); 1.5 misho 18877: } 18878: } 18879: /* If a filename is specified, try to open it first */ 18880: if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){ 18881: if( newFlag ) shellDeleteFile(zNewFilename); 18882: p->zDbFilename = zNewFilename; 18883: open_db(p, OPEN_DB_KEEPALIVE); 18884: if( p->db==0 ){ 18885: utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename); 18886: sqlite3_free(zNewFilename); 18887: }else{ 18888: p->zFreeOnClose = zNewFilename; 18889: } 18890: } 18891: if( p->db==0 ){ 18892: /* As a fall-back open a TEMP database */ 18893: p->zDbFilename = 0; 18894: open_db(p, 0); 1.4 misho 18895: } 1.2 misho 18896: }else 18897: 1.5 misho 18898: if( (c=='o' 18899: && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0)) 18900: || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0) 1.4 misho 18901: ){ 1.6 ! misho 18902: char *zFile = 0; 1.5 misho 18903: int bTxtMode = 0; 18904: int i; 18905: int eMode = 0; 18906: int bBOM = 0; 18907: int bOnce = 0; /* 0: .output, 1: .once, 2: .excel */ 18908: 18909: if( c=='e' ){ 18910: eMode = 'x'; 18911: bOnce = 2; 18912: }else if( strncmp(azArg[0],"once",n)==0 ){ 18913: bOnce = 1; 1.4 misho 18914: } 1.5 misho 18915: for(i=1; i<nArg; i++){ 18916: char *z = azArg[i]; 18917: if( z[0]=='-' ){ 18918: if( z[1]=='-' ) z++; 18919: if( strcmp(z,"-bom")==0 ){ 18920: bBOM = 1; 18921: }else if( c!='e' && strcmp(z,"-x")==0 ){ 18922: eMode = 'x'; /* spreadsheet */ 18923: }else if( c!='e' && strcmp(z,"-e")==0 ){ 18924: eMode = 'e'; /* text editor */ 18925: }else{ 18926: utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n", 18927: azArg[i]); 18928: showHelp(p->out, azArg[0]); 18929: rc = 1; 18930: goto meta_command_exit; 18931: } 1.6 ! misho 18932: }else if( zFile==0 && eMode!='e' && eMode!='x' ){ ! 18933: zFile = sqlite3_mprintf("%s", z); ! 18934: if( zFile[0]=='|' ){ ! 18935: while( i+1<nArg ) zFile = sqlite3_mprintf("%z %s", zFile, azArg[++i]); ! 18936: break; ! 18937: } 1.5 misho 18938: }else{ 18939: utf8_printf(p->out,"ERROR: extra parameter: \"%s\". Usage:\n", 18940: azArg[i]); 18941: showHelp(p->out, azArg[0]); 1.4 misho 18942: rc = 1; 1.6 ! misho 18943: sqlite3_free(zFile); 1.4 misho 18944: goto meta_command_exit; 18945: } 1.5 misho 18946: } 1.6 ! misho 18947: if( zFile==0 ) zFile = sqlite3_mprintf("stdout"); 1.5 misho 18948: if( bOnce ){ 1.4 misho 18949: p->outCount = 2; 1.3 misho 18950: }else{ 1.4 misho 18951: p->outCount = 0; 1.2 misho 18952: } 1.4 misho 18953: output_reset(p); 1.5 misho 18954: #ifndef SQLITE_NOHAVE_SYSTEM 18955: if( eMode=='e' || eMode=='x' ){ 18956: p->doXdgOpen = 1; 18957: outputModePush(p); 18958: if( eMode=='x' ){ 18959: /* spreadsheet mode. Output as CSV. */ 18960: newTempFile(p, "csv"); 18961: ShellClearFlag(p, SHFLG_Echo); 18962: p->mode = MODE_Csv; 18963: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); 18964: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); 18965: }else{ 18966: /* text editor mode */ 18967: newTempFile(p, "txt"); 18968: bTxtMode = 1; 18969: } 1.6 ! misho 18970: sqlite3_free(zFile); ! 18971: zFile = sqlite3_mprintf("%s", p->zTempFile); 1.5 misho 18972: } 18973: #endif /* SQLITE_NOHAVE_SYSTEM */ 1.4 misho 18974: if( zFile[0]=='|' ){ 18975: #ifdef SQLITE_OMIT_POPEN 18976: raw_printf(stderr, "Error: pipes are not supported in this OS\n"); 18977: rc = 1; 18978: p->out = stdout; 18979: #else 18980: p->out = popen(zFile + 1, "w"); 1.3 misho 18981: if( p->out==0 ){ 1.4 misho 18982: utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1); 1.3 misho 18983: p->out = stdout; 18984: rc = 1; 18985: }else{ 1.5 misho 18986: if( bBOM ) fprintf(p->out,"\357\273\277"); 1.4 misho 18987: sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 1.3 misho 18988: } 1.4 misho 18989: #endif 1.2 misho 18990: }else{ 1.5 misho 18991: p->out = output_file_open(zFile, bTxtMode); 1.2 misho 18992: if( p->out==0 ){ 1.4 misho 18993: if( strcmp(zFile,"off")!=0 ){ 18994: utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile); 1.3 misho 18995: } 1.2 misho 18996: p->out = stdout; 18997: rc = 1; 18998: } else { 1.5 misho 18999: if( bBOM ) fprintf(p->out,"\357\273\277"); 1.4 misho 19000: sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); 1.2 misho 19001: } 19002: } 1.6 ! misho 19003: sqlite3_free(zFile); 1.2 misho 19004: }else 19005: 1.5 misho 19006: if( c=='p' && n>=3 && strncmp(azArg[0], "parameter", n)==0 ){ 19007: open_db(p,0); 19008: if( nArg<=1 ) goto parameter_syntax_error; 19009: 19010: /* .parameter clear 19011: ** Clear all bind parameters by dropping the TEMP table that holds them. 19012: */ 19013: if( nArg==2 && strcmp(azArg[1],"clear")==0 ){ 19014: sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;", 19015: 0, 0, 0); 19016: }else 19017: 19018: /* .parameter list 19019: ** List all bind parameters. 19020: */ 19021: if( nArg==2 && strcmp(azArg[1],"list")==0 ){ 19022: sqlite3_stmt *pStmt = 0; 19023: int rx; 19024: int len = 0; 19025: rx = sqlite3_prepare_v2(p->db, 19026: "SELECT max(length(key)) " 19027: "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 19028: if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ 19029: len = sqlite3_column_int(pStmt, 0); 19030: if( len>40 ) len = 40; 19031: } 19032: sqlite3_finalize(pStmt); 19033: pStmt = 0; 19034: if( len ){ 19035: rx = sqlite3_prepare_v2(p->db, 19036: "SELECT key, quote(value) " 19037: "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 19038: while( sqlite3_step(pStmt)==SQLITE_ROW ){ 19039: utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0), 19040: sqlite3_column_text(pStmt,1)); 19041: } 19042: sqlite3_finalize(pStmt); 19043: } 19044: }else 19045: 19046: /* .parameter init 19047: ** Make sure the TEMP table used to hold bind parameters exists. 19048: ** Create it if necessary. 19049: */ 19050: if( nArg==2 && strcmp(azArg[1],"init")==0 ){ 19051: bind_table_init(p); 19052: }else 19053: 19054: /* .parameter set NAME VALUE 19055: ** Set or reset a bind parameter. NAME should be the full parameter 19056: ** name exactly as it appears in the query. (ex: $abc, @def). The 19057: ** VALUE can be in either SQL literal notation, or if not it will be 19058: ** understood to be a text string. 19059: */ 19060: if( nArg==4 && strcmp(azArg[1],"set")==0 ){ 19061: int rx; 19062: char *zSql; 19063: sqlite3_stmt *pStmt; 19064: const char *zKey = azArg[2]; 19065: const char *zValue = azArg[3]; 19066: bind_table_init(p); 19067: zSql = sqlite3_mprintf( 19068: "REPLACE INTO temp.sqlite_parameters(key,value)" 19069: "VALUES(%Q,%s);", zKey, zValue); 19070: if( zSql==0 ) shell_out_of_memory(); 19071: pStmt = 0; 19072: rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 19073: sqlite3_free(zSql); 19074: if( rx!=SQLITE_OK ){ 19075: sqlite3_finalize(pStmt); 19076: pStmt = 0; 19077: zSql = sqlite3_mprintf( 19078: "REPLACE INTO temp.sqlite_parameters(key,value)" 19079: "VALUES(%Q,%Q);", zKey, zValue); 19080: if( zSql==0 ) shell_out_of_memory(); 19081: rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 19082: sqlite3_free(zSql); 19083: if( rx!=SQLITE_OK ){ 19084: utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db)); 19085: sqlite3_finalize(pStmt); 19086: pStmt = 0; 19087: rc = 1; 19088: } 19089: } 19090: sqlite3_step(pStmt); 19091: sqlite3_finalize(pStmt); 19092: }else 19093: 19094: /* .parameter unset NAME 19095: ** Remove the NAME binding from the parameter binding table, if it 19096: ** exists. 19097: */ 19098: if( nArg==3 && strcmp(azArg[1],"unset")==0 ){ 19099: char *zSql = sqlite3_mprintf( 19100: "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]); 19101: if( zSql==0 ) shell_out_of_memory(); 19102: sqlite3_exec(p->db, zSql, 0, 0, 0); 19103: sqlite3_free(zSql); 19104: }else 19105: /* If no command name matches, show a syntax error */ 19106: parameter_syntax_error: 19107: showHelp(p->out, "parameter"); 19108: }else 19109: 1.3 misho 19110: if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){ 19111: int i; 19112: for(i=1; i<nArg; i++){ 1.4 misho 19113: if( i>1 ) raw_printf(p->out, " "); 19114: utf8_printf(p->out, "%s", azArg[i]); 1.3 misho 19115: } 1.4 misho 19116: raw_printf(p->out, "\n"); 1.3 misho 19117: }else 19118: 1.5 misho 19119: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 19120: if( c=='p' && n>=3 && strncmp(azArg[0], "progress", n)==0 ){ 19121: int i; 19122: int nn = 0; 19123: p->flgProgress = 0; 19124: p->mxProgress = 0; 19125: p->nProgress = 0; 19126: for(i=1; i<nArg; i++){ 19127: const char *z = azArg[i]; 19128: if( z[0]=='-' ){ 19129: z++; 19130: if( z[0]=='-' ) z++; 19131: if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){ 19132: p->flgProgress |= SHELL_PROGRESS_QUIET; 19133: continue; 19134: } 19135: if( strcmp(z,"reset")==0 ){ 19136: p->flgProgress |= SHELL_PROGRESS_RESET; 19137: continue; 19138: } 19139: if( strcmp(z,"once")==0 ){ 19140: p->flgProgress |= SHELL_PROGRESS_ONCE; 19141: continue; 19142: } 19143: if( strcmp(z,"limit")==0 ){ 19144: if( i+1>=nArg ){ 19145: utf8_printf(stderr, "Error: missing argument on --limit\n"); 19146: rc = 1; 19147: goto meta_command_exit; 19148: }else{ 19149: p->mxProgress = (int)integerValue(azArg[++i]); 19150: } 19151: continue; 19152: } 19153: utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]); 19154: rc = 1; 19155: goto meta_command_exit; 19156: }else{ 19157: nn = (int)integerValue(z); 19158: } 19159: } 19160: open_db(p, 0); 19161: sqlite3_progress_handler(p->db, nn, progress_handler, p); 19162: }else 19163: #endif /* SQLITE_OMIT_PROGRESS_CALLBACK */ 19164: 1.4 misho 19165: if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){ 1.2 misho 19166: if( nArg >= 2) { 19167: strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); 19168: } 19169: if( nArg >= 3) { 19170: strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); 19171: } 19172: }else 19173: 1.4 misho 19174: if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){ 1.2 misho 19175: rc = 2; 19176: }else 19177: 1.4 misho 19178: if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){ 1.5 misho 19179: FILE *inSaved = p->in; 19180: int savedLineno = p->lineno; 1.4 misho 19181: if( nArg!=2 ){ 19182: raw_printf(stderr, "Usage: .read FILE\n"); 19183: rc = 1; 19184: goto meta_command_exit; 19185: } 1.6 ! misho 19186: if( azArg[1][0]=='|' ){ ! 19187: #ifdef SQLITE_OMIT_POPEN ! 19188: raw_printf(stderr, "Error: pipes are not supported in this OS\n"); ! 19189: rc = 1; ! 19190: p->out = stdout; ! 19191: #else ! 19192: p->in = popen(azArg[1]+1, "r"); ! 19193: if( p->in==0 ){ ! 19194: utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); ! 19195: rc = 1; ! 19196: }else{ ! 19197: rc = process_input(p); ! 19198: pclose(p->in); ! 19199: } ! 19200: #endif ! 19201: }else if( notNormalFile(azArg[1]) || (p->in = fopen(azArg[1], "rb"))==0 ){ 1.4 misho 19202: utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); 1.2 misho 19203: rc = 1; 19204: }else{ 1.5 misho 19205: rc = process_input(p); 19206: fclose(p->in); 1.2 misho 19207: } 1.5 misho 19208: p->in = inSaved; 19209: p->lineno = savedLineno; 1.2 misho 19210: }else 19211: 1.4 misho 19212: if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){ 1.2 misho 19213: const char *zSrcFile; 19214: const char *zDb; 19215: sqlite3 *pSrc; 19216: sqlite3_backup *pBackup; 19217: int nTimeout = 0; 19218: 19219: if( nArg==2 ){ 19220: zSrcFile = azArg[1]; 19221: zDb = "main"; 1.4 misho 19222: }else if( nArg==3 ){ 1.2 misho 19223: zSrcFile = azArg[2]; 19224: zDb = azArg[1]; 1.4 misho 19225: }else{ 19226: raw_printf(stderr, "Usage: .restore ?DB? FILE\n"); 19227: rc = 1; 19228: goto meta_command_exit; 1.2 misho 19229: } 19230: rc = sqlite3_open(zSrcFile, &pSrc); 19231: if( rc!=SQLITE_OK ){ 1.4 misho 19232: utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); 1.5 misho 19233: close_db(pSrc); 1.2 misho 19234: return 1; 19235: } 1.4 misho 19236: open_db(p, 0); 1.2 misho 19237: pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); 19238: if( pBackup==0 ){ 1.4 misho 19239: utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 1.5 misho 19240: close_db(pSrc); 1.2 misho 19241: return 1; 19242: } 19243: while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK 19244: || rc==SQLITE_BUSY ){ 19245: if( rc==SQLITE_BUSY ){ 19246: if( nTimeout++ >= 3 ) break; 19247: sqlite3_sleep(100); 19248: } 19249: } 19250: sqlite3_backup_finish(pBackup); 19251: if( rc==SQLITE_DONE ){ 19252: rc = 0; 19253: }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ 1.4 misho 19254: raw_printf(stderr, "Error: source database is busy\n"); 1.2 misho 19255: rc = 1; 19256: }else{ 1.4 misho 19257: utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 1.2 misho 19258: rc = 1; 19259: } 1.5 misho 19260: close_db(pSrc); 1.2 misho 19261: }else 19262: 1.4 misho 19263: if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){ 19264: if( nArg==2 ){ 1.5 misho 19265: p->scanstatsOn = (u8)booleanValue(azArg[1]); 1.4 misho 19266: #ifndef SQLITE_ENABLE_STMT_SCANSTATUS 19267: raw_printf(stderr, "Warning: .scanstats not available in this build.\n"); 19268: #endif 19269: }else{ 19270: raw_printf(stderr, "Usage: .scanstats on|off\n"); 19271: rc = 1; 19272: } 19273: }else 19274: 19275: if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){ 1.5 misho 19276: ShellText sSelect; 1.4 misho 19277: ShellState data; 1.2 misho 19278: char *zErrMsg = 0; 1.5 misho 19279: const char *zDiv = "("; 19280: const char *zName = 0; 19281: int iSchema = 0; 19282: int bDebug = 0; 1.6 ! misho 19283: int bNoSystemTabs = 0; 1.5 misho 19284: int ii; 19285: 1.4 misho 19286: open_db(p, 0); 1.2 misho 19287: memcpy(&data, p, sizeof(data)); 19288: data.showHeader = 0; 1.4 misho 19289: data.cMode = data.mode = MODE_Semi; 1.5 misho 19290: initText(&sSelect); 19291: for(ii=1; ii<nArg; ii++){ 19292: if( optionMatch(azArg[ii],"indent") ){ 19293: data.cMode = data.mode = MODE_Pretty; 19294: }else if( optionMatch(azArg[ii],"debug") ){ 19295: bDebug = 1; 1.6 ! misho 19296: }else if( optionMatch(azArg[ii],"nosys") ){ ! 19297: bNoSystemTabs = 1; ! 19298: }else if( azArg[ii][0]=='-' ){ ! 19299: utf8_printf(stderr, "Unknown option: \"%s\"\n", azArg[ii]); ! 19300: rc = 1; ! 19301: goto meta_command_exit; 1.5 misho 19302: }else if( zName==0 ){ 19303: zName = azArg[ii]; 19304: }else{ 1.6 ! misho 19305: raw_printf(stderr, "Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n"); 1.5 misho 19306: rc = 1; 19307: goto meta_command_exit; 19308: } 1.4 misho 19309: } 1.5 misho 19310: if( zName!=0 ){ 19311: int isSchema = sqlite3_strlike(zName, "sqlite_master", '\\')==0 19312: || sqlite3_strlike(zName, "sqlite_schema", '\\')==0 19313: || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0 19314: || sqlite3_strlike(zName,"sqlite_temp_schema", '\\')==0; 19315: if( isSchema ){ 1.2 misho 19316: char *new_argv[2], *new_colv[2]; 1.5 misho 19317: new_argv[0] = sqlite3_mprintf( 19318: "CREATE TABLE %s (\n" 1.2 misho 19319: " type text,\n" 19320: " name text,\n" 19321: " tbl_name text,\n" 19322: " rootpage integer,\n" 19323: " sql text\n" 1.5 misho 19324: ")", zName); 1.2 misho 19325: new_argv[1] = 0; 19326: new_colv[0] = "sql"; 19327: new_colv[1] = 0; 19328: callback(&data, 1, new_argv, new_colv); 1.5 misho 19329: sqlite3_free(new_argv[0]); 19330: } 19331: } 19332: if( zDiv ){ 19333: sqlite3_stmt *pStmt = 0; 19334: rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list", 19335: -1, &pStmt, 0); 19336: if( rc ){ 19337: utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); 19338: sqlite3_finalize(pStmt); 19339: rc = 1; 19340: goto meta_command_exit; 19341: } 19342: appendText(&sSelect, "SELECT sql FROM", 0); 19343: iSchema = 0; 19344: while( sqlite3_step(pStmt)==SQLITE_ROW ){ 19345: const char *zDb = (const char*)sqlite3_column_text(pStmt, 0); 19346: char zScNum[30]; 19347: sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema); 19348: appendText(&sSelect, zDiv, 0); 19349: zDiv = " UNION ALL "; 19350: appendText(&sSelect, "SELECT shell_add_schema(sql,", 0); 19351: if( sqlite3_stricmp(zDb, "main")!=0 ){ 19352: appendText(&sSelect, zDb, '\''); 19353: }else{ 19354: appendText(&sSelect, "NULL", 0); 19355: } 19356: appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0); 19357: appendText(&sSelect, zScNum, 0); 19358: appendText(&sSelect, " AS snum, ", 0); 19359: appendText(&sSelect, zDb, '\''); 19360: appendText(&sSelect, " AS sname FROM ", 0); 19361: appendText(&sSelect, zDb, quoteChar(zDb)); 19362: appendText(&sSelect, ".sqlite_schema", 0); 19363: } 19364: sqlite3_finalize(pStmt); 19365: #ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS 19366: if( zName ){ 19367: appendText(&sSelect, 19368: " UNION ALL SELECT shell_module_schema(name)," 19369: " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list", 19370: 0); 19371: } 19372: #endif 19373: appendText(&sSelect, ") WHERE ", 0); 19374: if( zName ){ 19375: char *zQarg = sqlite3_mprintf("%Q", zName); 19376: int bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 || 19377: strchr(zName, '[') != 0; 19378: if( strchr(zName, '.') ){ 19379: appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0); 19380: }else{ 19381: appendText(&sSelect, "lower(tbl_name)", 0); 19382: } 19383: appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0); 19384: appendText(&sSelect, zQarg, 0); 19385: if( !bGlob ){ 19386: appendText(&sSelect, " ESCAPE '\\' ", 0); 19387: } 19388: appendText(&sSelect, " AND ", 0); 19389: sqlite3_free(zQarg); 19390: } 1.6 ! misho 19391: if( bNoSystemTabs ){ ! 19392: appendText(&sSelect, "name NOT LIKE 'sqlite_%%' AND ", 0); ! 19393: } ! 19394: appendText(&sSelect, "sql IS NOT NULL" 1.5 misho 19395: " ORDER BY snum, rowid", 0); 19396: if( bDebug ){ 19397: utf8_printf(p->out, "SQL: %s;\n", sSelect.z); 1.2 misho 19398: }else{ 1.5 misho 19399: rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg); 1.2 misho 19400: } 1.5 misho 19401: freeText(&sSelect); 1.2 misho 19402: } 19403: if( zErrMsg ){ 1.4 misho 19404: utf8_printf(stderr,"Error: %s\n", zErrMsg); 1.2 misho 19405: sqlite3_free(zErrMsg); 19406: rc = 1; 19407: }else if( rc != SQLITE_OK ){ 1.4 misho 19408: raw_printf(stderr,"Error: querying schema information\n"); 1.2 misho 19409: rc = 1; 19410: }else{ 19411: rc = 0; 19412: } 19413: }else 19414: 1.4 misho 19415: if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){ 1.6 ! misho 19416: unsigned int x = nArg>=2 ? (unsigned int)integerValue(azArg[1]) : 0xffffffff; ! 19417: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &x); 1.4 misho 19418: }else 19419: 19420: #if defined(SQLITE_ENABLE_SESSION) 19421: if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){ 19422: OpenSession *pSession = &p->aSession[0]; 19423: char **azCmd = &azArg[1]; 19424: int iSes = 0; 19425: int nCmd = nArg - 1; 19426: int i; 19427: if( nArg<=1 ) goto session_syntax_error; 19428: open_db(p, 0); 19429: if( nArg>=3 ){ 19430: for(iSes=0; iSes<p->nSession; iSes++){ 19431: if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break; 19432: } 19433: if( iSes<p->nSession ){ 19434: pSession = &p->aSession[iSes]; 19435: azCmd++; 19436: nCmd--; 19437: }else{ 19438: pSession = &p->aSession[0]; 19439: iSes = 0; 19440: } 19441: } 19442: 19443: /* .session attach TABLE 19444: ** Invoke the sqlite3session_attach() interface to attach a particular 19445: ** table so that it is never filtered. 19446: */ 19447: if( strcmp(azCmd[0],"attach")==0 ){ 19448: if( nCmd!=2 ) goto session_syntax_error; 19449: if( pSession->p==0 ){ 19450: session_not_open: 19451: raw_printf(stderr, "ERROR: No sessions are open\n"); 19452: }else{ 19453: rc = sqlite3session_attach(pSession->p, azCmd[1]); 19454: if( rc ){ 19455: raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc); 19456: rc = 0; 19457: } 19458: } 19459: }else 19460: 19461: /* .session changeset FILE 19462: ** .session patchset FILE 19463: ** Write a changeset or patchset into a file. The file is overwritten. 19464: */ 19465: if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){ 19466: FILE *out = 0; 19467: if( nCmd!=2 ) goto session_syntax_error; 19468: if( pSession->p==0 ) goto session_not_open; 19469: out = fopen(azCmd[1], "wb"); 19470: if( out==0 ){ 1.5 misho 19471: utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n", 19472: azCmd[1]); 1.4 misho 19473: }else{ 19474: int szChng; 19475: void *pChng; 19476: if( azCmd[0][0]=='c' ){ 19477: rc = sqlite3session_changeset(pSession->p, &szChng, &pChng); 19478: }else{ 19479: rc = sqlite3session_patchset(pSession->p, &szChng, &pChng); 19480: } 19481: if( rc ){ 19482: printf("Error: error code %d\n", rc); 19483: rc = 0; 19484: } 19485: if( pChng 19486: && fwrite(pChng, szChng, 1, out)!=1 ){ 19487: raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n", 19488: szChng); 19489: } 19490: sqlite3_free(pChng); 19491: fclose(out); 19492: } 19493: }else 19494: 19495: /* .session close 19496: ** Close the identified session 19497: */ 19498: if( strcmp(azCmd[0], "close")==0 ){ 19499: if( nCmd!=1 ) goto session_syntax_error; 19500: if( p->nSession ){ 19501: session_close(pSession); 19502: p->aSession[iSes] = p->aSession[--p->nSession]; 19503: } 19504: }else 19505: 19506: /* .session enable ?BOOLEAN? 19507: ** Query or set the enable flag 19508: */ 19509: if( strcmp(azCmd[0], "enable")==0 ){ 19510: int ii; 19511: if( nCmd>2 ) goto session_syntax_error; 19512: ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 19513: if( p->nSession ){ 19514: ii = sqlite3session_enable(pSession->p, ii); 19515: utf8_printf(p->out, "session %s enable flag = %d\n", 19516: pSession->zName, ii); 19517: } 19518: }else 19519: 19520: /* .session filter GLOB .... 19521: ** Set a list of GLOB patterns of table names to be excluded. 19522: */ 19523: if( strcmp(azCmd[0], "filter")==0 ){ 19524: int ii, nByte; 19525: if( nCmd<2 ) goto session_syntax_error; 19526: if( p->nSession ){ 19527: for(ii=0; ii<pSession->nFilter; ii++){ 19528: sqlite3_free(pSession->azFilter[ii]); 19529: } 19530: sqlite3_free(pSession->azFilter); 19531: nByte = sizeof(pSession->azFilter[0])*(nCmd-1); 19532: pSession->azFilter = sqlite3_malloc( nByte ); 19533: if( pSession->azFilter==0 ){ 19534: raw_printf(stderr, "Error: out or memory\n"); 19535: exit(1); 19536: } 19537: for(ii=1; ii<nCmd; ii++){ 19538: pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]); 19539: } 19540: pSession->nFilter = ii-1; 19541: } 19542: }else 19543: 19544: /* .session indirect ?BOOLEAN? 19545: ** Query or set the indirect flag 19546: */ 19547: if( strcmp(azCmd[0], "indirect")==0 ){ 19548: int ii; 19549: if( nCmd>2 ) goto session_syntax_error; 19550: ii = nCmd==1 ? -1 : booleanValue(azCmd[1]); 19551: if( p->nSession ){ 19552: ii = sqlite3session_indirect(pSession->p, ii); 19553: utf8_printf(p->out, "session %s indirect flag = %d\n", 19554: pSession->zName, ii); 19555: } 19556: }else 19557: 19558: /* .session isempty 19559: ** Determine if the session is empty 19560: */ 19561: if( strcmp(azCmd[0], "isempty")==0 ){ 19562: int ii; 19563: if( nCmd!=1 ) goto session_syntax_error; 19564: if( p->nSession ){ 19565: ii = sqlite3session_isempty(pSession->p); 19566: utf8_printf(p->out, "session %s isempty flag = %d\n", 19567: pSession->zName, ii); 19568: } 19569: }else 19570: 19571: /* .session list 19572: ** List all currently open sessions 19573: */ 19574: if( strcmp(azCmd[0],"list")==0 ){ 19575: for(i=0; i<p->nSession; i++){ 19576: utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName); 19577: } 19578: }else 19579: 19580: /* .session open DB NAME 19581: ** Open a new session called NAME on the attached database DB. 19582: ** DB is normally "main". 19583: */ 19584: if( strcmp(azCmd[0],"open")==0 ){ 19585: char *zName; 19586: if( nCmd!=3 ) goto session_syntax_error; 19587: zName = azCmd[2]; 19588: if( zName[0]==0 ) goto session_syntax_error; 19589: for(i=0; i<p->nSession; i++){ 19590: if( strcmp(p->aSession[i].zName,zName)==0 ){ 19591: utf8_printf(stderr, "Session \"%s\" already exists\n", zName); 19592: goto meta_command_exit; 19593: } 19594: } 19595: if( p->nSession>=ArraySize(p->aSession) ){ 19596: raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession)); 19597: goto meta_command_exit; 19598: } 19599: pSession = &p->aSession[p->nSession]; 19600: rc = sqlite3session_create(p->db, azCmd[1], &pSession->p); 19601: if( rc ){ 19602: raw_printf(stderr, "Cannot open session: error code=%d\n", rc); 19603: rc = 0; 19604: goto meta_command_exit; 19605: } 19606: pSession->nFilter = 0; 19607: sqlite3session_table_filter(pSession->p, session_filter, pSession); 19608: p->nSession++; 19609: pSession->zName = sqlite3_mprintf("%s", zName); 19610: }else 19611: /* If no command name matches, show a syntax error */ 19612: session_syntax_error: 1.5 misho 19613: showHelp(p->out, "session"); 1.4 misho 19614: }else 19615: #endif 19616: 19617: #ifdef SQLITE_DEBUG 19618: /* Undocumented commands for internal testing. Subject to change 19619: ** without notice. */ 19620: if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){ 19621: if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){ 19622: int i, v; 19623: for(i=1; i<nArg; i++){ 19624: v = booleanValue(azArg[i]); 19625: utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v); 19626: } 19627: } 19628: if( strncmp(azArg[0]+9, "integer", n-9)==0 ){ 19629: int i; sqlite3_int64 v; 19630: for(i=1; i<nArg; i++){ 19631: char zBuf[200]; 19632: v = integerValue(azArg[i]); 19633: sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v); 19634: utf8_printf(p->out, "%s", zBuf); 19635: } 19636: } 19637: }else 19638: #endif 19639: 1.5 misho 19640: if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){ 19641: int bIsInit = 0; /* True to initialize the SELFTEST table */ 19642: int bVerbose = 0; /* Verbose output */ 19643: int bSelftestExists; /* True if SELFTEST already exists */ 19644: int i, k; /* Loop counters */ 19645: int nTest = 0; /* Number of tests runs */ 19646: int nErr = 0; /* Number of errors seen */ 19647: ShellText str; /* Answer for a query */ 19648: sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */ 19649: 19650: open_db(p,0); 19651: for(i=1; i<nArg; i++){ 19652: const char *z = azArg[i]; 19653: if( z[0]=='-' && z[1]=='-' ) z++; 19654: if( strcmp(z,"-init")==0 ){ 19655: bIsInit = 1; 19656: }else 19657: if( strcmp(z,"-v")==0 ){ 19658: bVerbose++; 19659: }else 19660: { 19661: utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 19662: azArg[i], azArg[0]); 19663: raw_printf(stderr, "Should be one of: --init -v\n"); 19664: rc = 1; 19665: goto meta_command_exit; 19666: } 19667: } 19668: if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0) 19669: != SQLITE_OK ){ 19670: bSelftestExists = 0; 19671: }else{ 19672: bSelftestExists = 1; 19673: } 19674: if( bIsInit ){ 19675: createSelftestTable(p); 19676: bSelftestExists = 1; 19677: } 19678: initText(&str); 19679: appendText(&str, "x", 0); 19680: for(k=bSelftestExists; k>=0; k--){ 19681: if( k==1 ){ 19682: rc = sqlite3_prepare_v2(p->db, 19683: "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno", 19684: -1, &pStmt, 0); 19685: }else{ 19686: rc = sqlite3_prepare_v2(p->db, 19687: "VALUES(0,'memo','Missing SELFTEST table - default checks only','')," 19688: " (1,'run','PRAGMA integrity_check','ok')", 19689: -1, &pStmt, 0); 19690: } 19691: if( rc ){ 19692: raw_printf(stderr, "Error querying the selftest table\n"); 19693: rc = 1; 19694: sqlite3_finalize(pStmt); 19695: goto meta_command_exit; 19696: } 19697: for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){ 19698: int tno = sqlite3_column_int(pStmt, 0); 19699: const char *zOp = (const char*)sqlite3_column_text(pStmt, 1); 19700: const char *zSql = (const char*)sqlite3_column_text(pStmt, 2); 19701: const char *zAns = (const char*)sqlite3_column_text(pStmt, 3); 19702: 19703: k = 0; 19704: if( bVerbose>0 ){ 19705: char *zQuote = sqlite3_mprintf("%q", zSql); 19706: printf("%d: %s %s\n", tno, zOp, zSql); 19707: sqlite3_free(zQuote); 19708: } 19709: if( strcmp(zOp,"memo")==0 ){ 19710: utf8_printf(p->out, "%s\n", zSql); 19711: }else 19712: if( strcmp(zOp,"run")==0 ){ 19713: char *zErrMsg = 0; 19714: str.n = 0; 19715: str.z[0] = 0; 19716: rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg); 19717: nTest++; 19718: if( bVerbose ){ 19719: utf8_printf(p->out, "Result: %s\n", str.z); 19720: } 19721: if( rc || zErrMsg ){ 19722: nErr++; 19723: rc = 1; 19724: utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg); 19725: sqlite3_free(zErrMsg); 19726: }else if( strcmp(zAns,str.z)!=0 ){ 19727: nErr++; 19728: rc = 1; 19729: utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns); 19730: utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z); 19731: } 19732: }else 19733: { 19734: utf8_printf(stderr, 19735: "Unknown operation \"%s\" on selftest line %d\n", zOp, tno); 19736: rc = 1; 19737: break; 19738: } 19739: } /* End loop over rows of content from SELFTEST */ 19740: sqlite3_finalize(pStmt); 19741: } /* End loop over k */ 19742: freeText(&str); 19743: utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest); 19744: }else 19745: 1.4 misho 19746: if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){ 19747: if( nArg<2 || nArg>3 ){ 19748: raw_printf(stderr, "Usage: .separator COL ?ROW?\n"); 19749: rc = 1; 19750: } 19751: if( nArg>=2 ){ 19752: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, 19753: "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]); 19754: } 19755: if( nArg>=3 ){ 19756: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, 19757: "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]); 19758: } 19759: }else 19760: 1.5 misho 19761: if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){ 19762: const char *zLike = 0; /* Which table to checksum. 0 means everything */ 19763: int i; /* Loop counter */ 19764: int bSchema = 0; /* Also hash the schema */ 19765: int bSeparate = 0; /* Hash each table separately */ 19766: int iSize = 224; /* Hash algorithm to use */ 19767: int bDebug = 0; /* Only show the query that would have run */ 19768: sqlite3_stmt *pStmt; /* For querying tables names */ 19769: char *zSql; /* SQL to be run */ 19770: char *zSep; /* Separator */ 19771: ShellText sSql; /* Complete SQL for the query to run the hash */ 19772: ShellText sQuery; /* Set of queries used to read all content */ 19773: open_db(p, 0); 19774: for(i=1; i<nArg; i++){ 19775: const char *z = azArg[i]; 19776: if( z[0]=='-' ){ 19777: z++; 19778: if( z[0]=='-' ) z++; 19779: if( strcmp(z,"schema")==0 ){ 19780: bSchema = 1; 19781: }else 19782: if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0 19783: || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0 19784: ){ 19785: iSize = atoi(&z[5]); 19786: }else 19787: if( strcmp(z,"debug")==0 ){ 19788: bDebug = 1; 19789: }else 19790: { 19791: utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n", 19792: azArg[i], azArg[0]); 19793: showHelp(p->out, azArg[0]); 19794: rc = 1; 19795: goto meta_command_exit; 19796: } 19797: }else if( zLike ){ 19798: raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n"); 19799: rc = 1; 19800: goto meta_command_exit; 19801: }else{ 19802: zLike = z; 19803: bSeparate = 1; 19804: if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1; 19805: } 19806: } 19807: if( bSchema ){ 19808: zSql = "SELECT lower(name) FROM sqlite_schema" 19809: " WHERE type='table' AND coalesce(rootpage,0)>1" 19810: " UNION ALL SELECT 'sqlite_schema'" 19811: " ORDER BY 1 collate nocase"; 19812: }else{ 19813: zSql = "SELECT lower(name) FROM sqlite_schema" 19814: " WHERE type='table' AND coalesce(rootpage,0)>1" 19815: " AND name NOT LIKE 'sqlite_%'" 19816: " ORDER BY 1 collate nocase"; 19817: } 19818: sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 19819: initText(&sQuery); 19820: initText(&sSql); 19821: appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0); 19822: zSep = "VALUES("; 19823: while( SQLITE_ROW==sqlite3_step(pStmt) ){ 19824: const char *zTab = (const char*)sqlite3_column_text(pStmt,0); 19825: if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue; 19826: if( strncmp(zTab, "sqlite_",7)!=0 ){ 19827: appendText(&sQuery,"SELECT * FROM ", 0); 19828: appendText(&sQuery,zTab,'"'); 19829: appendText(&sQuery," NOT INDEXED;", 0); 19830: }else if( strcmp(zTab, "sqlite_schema")==0 ){ 19831: appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_schema" 19832: " ORDER BY name;", 0); 19833: }else if( strcmp(zTab, "sqlite_sequence")==0 ){ 19834: appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence" 19835: " ORDER BY name;", 0); 19836: }else if( strcmp(zTab, "sqlite_stat1")==0 ){ 19837: appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1" 19838: " ORDER BY tbl,idx;", 0); 19839: }else if( strcmp(zTab, "sqlite_stat4")==0 ){ 19840: appendText(&sQuery, "SELECT * FROM ", 0); 19841: appendText(&sQuery, zTab, 0); 19842: appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0); 19843: } 19844: appendText(&sSql, zSep, 0); 19845: appendText(&sSql, sQuery.z, '\''); 19846: sQuery.n = 0; 19847: appendText(&sSql, ",", 0); 19848: appendText(&sSql, zTab, '\''); 19849: zSep = "),("; 19850: } 19851: sqlite3_finalize(pStmt); 19852: if( bSeparate ){ 19853: zSql = sqlite3_mprintf( 19854: "%s))" 19855: " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label" 19856: " FROM [sha3sum$query]", 19857: sSql.z, iSize); 19858: }else{ 19859: zSql = sqlite3_mprintf( 19860: "%s))" 19861: " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash" 19862: " FROM [sha3sum$query]", 19863: sSql.z, iSize); 19864: } 19865: freeText(&sQuery); 19866: freeText(&sSql); 19867: if( bDebug ){ 19868: utf8_printf(p->out, "%s\n", zSql); 19869: }else{ 19870: shell_exec(p, zSql, 0); 19871: } 19872: sqlite3_free(zSql); 19873: }else 19874: 19875: #ifndef SQLITE_NOHAVE_SYSTEM 1.4 misho 19876: if( c=='s' 19877: && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0) 19878: ){ 19879: char *zCmd; 19880: int i, x; 19881: if( nArg<2 ){ 19882: raw_printf(stderr, "Usage: .system COMMAND\n"); 19883: rc = 1; 19884: goto meta_command_exit; 19885: } 19886: zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]); 19887: for(i=2; i<nArg; i++){ 19888: zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"", 19889: zCmd, azArg[i]); 19890: } 19891: x = system(zCmd); 19892: sqlite3_free(zCmd); 19893: if( x ) raw_printf(stderr, "System command returns %d\n", x); 1.2 misho 19894: }else 1.5 misho 19895: #endif /* !defined(SQLITE_NOHAVE_SYSTEM) */ 1.2 misho 19896: 1.4 misho 19897: if( c=='s' && strncmp(azArg[0], "show", n)==0 ){ 1.5 misho 19898: static const char *azBool[] = { "off", "on", "trigger", "full"}; 1.6 ! misho 19899: const char *zOut; 1.2 misho 19900: int i; 1.4 misho 19901: if( nArg!=1 ){ 19902: raw_printf(stderr, "Usage: .show\n"); 19903: rc = 1; 19904: goto meta_command_exit; 19905: } 1.5 misho 19906: utf8_printf(p->out, "%12.12s: %s\n","echo", 19907: azBool[ShellHasFlag(p, SHFLG_Echo)]); 1.4 misho 19908: utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]); 19909: utf8_printf(p->out, "%12.12s: %s\n","explain", 19910: p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off"); 19911: utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]); 19912: utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]); 19913: utf8_printf(p->out, "%12.12s: ", "nullvalue"); 19914: output_c_string(p->out, p->nullValue); 19915: raw_printf(p->out, "\n"); 19916: utf8_printf(p->out,"%12.12s: %s\n","output", 1.2 misho 19917: strlen30(p->outfile) ? p->outfile : "stdout"); 1.4 misho 19918: utf8_printf(p->out,"%12.12s: ", "colseparator"); 19919: output_c_string(p->out, p->colSeparator); 19920: raw_printf(p->out, "\n"); 19921: utf8_printf(p->out,"%12.12s: ", "rowseparator"); 19922: output_c_string(p->out, p->rowSeparator); 19923: raw_printf(p->out, "\n"); 1.6 ! misho 19924: switch( p->statsOn ){ ! 19925: case 0: zOut = "off"; break; ! 19926: default: zOut = "on"; break; ! 19927: case 2: zOut = "stmt"; break; ! 19928: case 3: zOut = "vmstep"; break; ! 19929: } ! 19930: utf8_printf(p->out, "%12.12s: %s\n","stats", zOut); 1.4 misho 19931: utf8_printf(p->out, "%12.12s: ", "width"); 1.5 misho 19932: for (i=0;i<p->nWidth;i++) { 1.4 misho 19933: raw_printf(p->out, "%d ", p->colWidth[i]); 1.2 misho 19934: } 1.4 misho 19935: raw_printf(p->out, "\n"); 1.5 misho 19936: utf8_printf(p->out, "%12.12s: %s\n", "filename", 19937: p->zDbFilename ? p->zDbFilename : ""); 1.2 misho 19938: }else 19939: 1.4 misho 19940: if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){ 19941: if( nArg==2 ){ 1.6 ! misho 19942: if( strcmp(azArg[1],"stmt")==0 ){ ! 19943: p->statsOn = 2; ! 19944: }else if( strcmp(azArg[1],"vmstep")==0 ){ ! 19945: p->statsOn = 3; ! 19946: }else{ ! 19947: p->statsOn = (u8)booleanValue(azArg[1]); ! 19948: } 1.4 misho 19949: }else if( nArg==1 ){ 19950: display_stats(p->db, p, 0); 19951: }else{ 1.6 ! misho 19952: raw_printf(stderr, "Usage: .stats ?on|off|stmt|vmstep?\n"); 1.4 misho 19953: rc = 1; 19954: } 1.2 misho 19955: }else 19956: 1.5 misho 19957: if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0) 19958: || (c=='i' && (strncmp(azArg[0], "indices", n)==0 19959: || strncmp(azArg[0], "indexes", n)==0) ) 19960: ){ 1.3 misho 19961: sqlite3_stmt *pStmt; 1.2 misho 19962: char **azResult; 1.3 misho 19963: int nRow, nAlloc; 19964: int ii; 1.5 misho 19965: ShellText s; 19966: initText(&s); 1.4 misho 19967: open_db(p, 0); 1.3 misho 19968: rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); 1.5 misho 19969: if( rc ){ 19970: sqlite3_finalize(pStmt); 19971: return shellDatabaseError(p->db); 19972: } 1.4 misho 19973: 1.5 misho 19974: if( nArg>2 && c=='i' ){ 19975: /* It is an historical accident that the .indexes command shows an error 19976: ** when called with the wrong number of arguments whereas the .tables 19977: ** command does not. */ 19978: raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n"); 19979: rc = 1; 19980: sqlite3_finalize(pStmt); 19981: goto meta_command_exit; 19982: } 19983: for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){ 1.3 misho 19984: const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1); 1.5 misho 19985: if( zDbName==0 ) continue; 19986: if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0); 19987: if( sqlite3_stricmp(zDbName, "main")==0 ){ 19988: appendText(&s, "SELECT name FROM ", 0); 19989: }else{ 19990: appendText(&s, "SELECT ", 0); 19991: appendText(&s, zDbName, '\''); 19992: appendText(&s, "||'.'||name FROM ", 0); 19993: } 19994: appendText(&s, zDbName, '"'); 19995: appendText(&s, ".sqlite_schema ", 0); 19996: if( c=='t' ){ 19997: appendText(&s," WHERE type IN ('table','view')" 19998: " AND name NOT LIKE 'sqlite_%'" 19999: " AND name LIKE ?1", 0); 1.3 misho 20000: }else{ 1.5 misho 20001: appendText(&s," WHERE type='index'" 20002: " AND tbl_name LIKE ?1", 0); 1.3 misho 20003: } 20004: } 1.4 misho 20005: rc = sqlite3_finalize(pStmt); 1.5 misho 20006: appendText(&s, " ORDER BY 1", 0); 20007: rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0); 20008: freeText(&s); 1.4 misho 20009: if( rc ) return shellDatabaseError(p->db); 20010: 20011: /* Run the SQL statement prepared by the above block. Store the results 20012: ** as an array of nul-terminated strings in azResult[]. */ 1.3 misho 20013: nRow = nAlloc = 0; 20014: azResult = 0; 20015: if( nArg>1 ){ 20016: sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT); 1.2 misho 20017: }else{ 1.3 misho 20018: sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC); 20019: } 20020: while( sqlite3_step(pStmt)==SQLITE_ROW ){ 20021: if( nRow>=nAlloc ){ 20022: char **azNew; 1.4 misho 20023: int n2 = nAlloc*2 + 10; 20024: azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2); 1.5 misho 20025: if( azNew==0 ) shell_out_of_memory(); 1.4 misho 20026: nAlloc = n2; 1.3 misho 20027: azResult = azNew; 20028: } 20029: azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0)); 1.5 misho 20030: if( 0==azResult[nRow] ) shell_out_of_memory(); 1.4 misho 20031: nRow++; 1.2 misho 20032: } 1.4 misho 20033: if( sqlite3_finalize(pStmt)!=SQLITE_OK ){ 20034: rc = shellDatabaseError(p->db); 20035: } 20036: 20037: /* Pretty-print the contents of array azResult[] to the output */ 20038: if( rc==0 && nRow>0 ){ 1.2 misho 20039: int len, maxlen = 0; 20040: int i, j; 20041: int nPrintCol, nPrintRow; 1.3 misho 20042: for(i=0; i<nRow; i++){ 1.2 misho 20043: len = strlen30(azResult[i]); 20044: if( len>maxlen ) maxlen = len; 20045: } 20046: nPrintCol = 80/(maxlen+2); 20047: if( nPrintCol<1 ) nPrintCol = 1; 20048: nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; 20049: for(i=0; i<nPrintRow; i++){ 1.3 misho 20050: for(j=i; j<nRow; j+=nPrintRow){ 20051: char *zSp = j<nPrintRow ? "" : " "; 1.4 misho 20052: utf8_printf(p->out, "%s%-*s", zSp, maxlen, 20053: azResult[j] ? azResult[j]:""); 1.2 misho 20054: } 1.4 misho 20055: raw_printf(p->out, "\n"); 1.2 misho 20056: } 20057: } 1.4 misho 20058: 1.3 misho 20059: for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]); 20060: sqlite3_free(azResult); 1.2 misho 20061: }else 20062: 1.5 misho 20063: /* Begin redirecting output to the file "testcase-out.txt" */ 20064: if( c=='t' && strcmp(azArg[0],"testcase")==0 ){ 20065: output_reset(p); 20066: p->out = output_file_open("testcase-out.txt", 0); 20067: if( p->out==0 ){ 20068: raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n"); 20069: } 20070: if( nArg>=2 ){ 20071: sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]); 20072: }else{ 20073: sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?"); 20074: } 20075: }else 20076: 20077: #ifndef SQLITE_UNTESTABLE 20078: if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 ){ 1.2 misho 20079: static const struct { 20080: const char *zCtrlName; /* Name of a test-control option */ 20081: int ctrlCode; /* Integer code for that option */ 1.5 misho 20082: const char *zUsage; /* Usage notes */ 1.2 misho 20083: } aCtrl[] = { 1.5 misho 20084: { "always", SQLITE_TESTCTRL_ALWAYS, "BOOLEAN" }, 20085: { "assert", SQLITE_TESTCTRL_ASSERT, "BOOLEAN" }, 20086: /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, "" },*/ 20087: /*{ "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST, "" },*/ 20088: { "byteorder", SQLITE_TESTCTRL_BYTEORDER, "" }, 20089: { "extra_schema_checks",SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS,"BOOLEAN" }, 20090: /*{ "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL, "" },*/ 20091: { "imposter", SQLITE_TESTCTRL_IMPOSTER, "SCHEMA ON/OFF ROOTPAGE"}, 20092: { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "" }, 20093: { "localtime_fault", SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN" }, 20094: { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN" }, 20095: { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK" }, 20096: #ifdef YYCOVERAGE 20097: { "parser_coverage", SQLITE_TESTCTRL_PARSER_COVERAGE, "" }, 20098: #endif 20099: { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE, "OFFSET " }, 20100: { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE, "" }, 20101: { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE, "" }, 20102: { "prng_seed", SQLITE_TESTCTRL_PRNG_SEED, "SEED ?db?" }, 1.6 ! misho 20103: { "seek_count", SQLITE_TESTCTRL_SEEK_COUNT, "" }, 1.2 misho 20104: }; 20105: int testctrl = -1; 1.5 misho 20106: int iCtrl = -1; 20107: int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */ 20108: int isOk = 0; 1.4 misho 20109: int i, n2; 1.5 misho 20110: const char *zCmd = 0; 20111: 1.4 misho 20112: open_db(p, 0); 1.5 misho 20113: zCmd = nArg>=2 ? azArg[1] : "help"; 20114: 20115: /* The argument can optionally begin with "-" or "--" */ 20116: if( zCmd[0]=='-' && zCmd[1] ){ 20117: zCmd++; 20118: if( zCmd[0]=='-' && zCmd[1] ) zCmd++; 20119: } 20120: 20121: /* --help lists all test-controls */ 20122: if( strcmp(zCmd,"help")==0 ){ 20123: utf8_printf(p->out, "Available test-controls:\n"); 20124: for(i=0; i<ArraySize(aCtrl); i++){ 20125: utf8_printf(p->out, " .testctrl %s %s\n", 20126: aCtrl[i].zCtrlName, aCtrl[i].zUsage); 20127: } 20128: rc = 1; 20129: goto meta_command_exit; 20130: } 1.2 misho 20131: 20132: /* convert testctrl text option to value. allow any unique prefix 20133: ** of the option name, or a numerical value. */ 1.5 misho 20134: n2 = strlen30(zCmd); 1.4 misho 20135: for(i=0; i<ArraySize(aCtrl); i++){ 1.5 misho 20136: if( strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){ 1.2 misho 20137: if( testctrl<0 ){ 20138: testctrl = aCtrl[i].ctrlCode; 1.5 misho 20139: iCtrl = i; 1.2 misho 20140: }else{ 1.5 misho 20141: utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n" 20142: "Use \".testctrl --help\" for help\n", zCmd); 20143: rc = 1; 20144: goto meta_command_exit; 1.2 misho 20145: } 20146: } 20147: } 1.5 misho 20148: if( testctrl<0 ){ 20149: utf8_printf(stderr,"Error: unknown test-control: %s\n" 20150: "Use \".testctrl --help\" for help\n", zCmd); 1.2 misho 20151: }else{ 20152: switch(testctrl){ 20153: 20154: /* sqlite3_test_control(int, db, int) */ 20155: case SQLITE_TESTCTRL_OPTIMIZATIONS: 20156: if( nArg==3 ){ 1.6 ! misho 20157: unsigned int opt = (unsigned int)strtol(azArg[2], 0, 0); 1.4 misho 20158: rc2 = sqlite3_test_control(testctrl, p->db, opt); 1.5 misho 20159: isOk = 3; 1.2 misho 20160: } 20161: break; 20162: 20163: /* sqlite3_test_control(int) */ 1.4 misho 20164: case SQLITE_TESTCTRL_PRNG_SAVE: 20165: case SQLITE_TESTCTRL_PRNG_RESTORE: 20166: case SQLITE_TESTCTRL_BYTEORDER: 1.2 misho 20167: if( nArg==2 ){ 1.4 misho 20168: rc2 = sqlite3_test_control(testctrl); 1.5 misho 20169: isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3; 1.2 misho 20170: } 20171: break; 20172: 20173: /* sqlite3_test_control(int, uint) */ 1.4 misho 20174: case SQLITE_TESTCTRL_PENDING_BYTE: 1.2 misho 20175: if( nArg==3 ){ 1.4 misho 20176: unsigned int opt = (unsigned int)integerValue(azArg[2]); 20177: rc2 = sqlite3_test_control(testctrl, opt); 1.5 misho 20178: isOk = 3; 20179: } 20180: break; 20181: 20182: /* sqlite3_test_control(int, int, sqlite3*) */ 20183: case SQLITE_TESTCTRL_PRNG_SEED: 20184: if( nArg==3 || nArg==4 ){ 20185: int ii = (int)integerValue(azArg[2]); 20186: sqlite3 *db; 20187: if( ii==0 && strcmp(azArg[2],"random")==0 ){ 20188: sqlite3_randomness(sizeof(ii),&ii); 20189: printf("-- random seed: %d\n", ii); 20190: } 20191: if( nArg==3 ){ 20192: db = 0; 20193: }else{ 20194: db = p->db; 20195: /* Make sure the schema has been loaded */ 20196: sqlite3_table_column_metadata(db, 0, "x", 0, 0, 0, 0, 0, 0); 20197: } 20198: rc2 = sqlite3_test_control(testctrl, ii, db); 20199: isOk = 3; 1.2 misho 20200: } 20201: break; 1.4 misho 20202: 1.2 misho 20203: /* sqlite3_test_control(int, int) */ 1.4 misho 20204: case SQLITE_TESTCTRL_ASSERT: 20205: case SQLITE_TESTCTRL_ALWAYS: 1.2 misho 20206: if( nArg==3 ){ 1.4 misho 20207: int opt = booleanValue(azArg[2]); 20208: rc2 = sqlite3_test_control(testctrl, opt); 1.5 misho 20209: isOk = 1; 1.2 misho 20210: } 20211: break; 20212: 1.5 misho 20213: /* sqlite3_test_control(int, int) */ 20214: case SQLITE_TESTCTRL_LOCALTIME_FAULT: 20215: case SQLITE_TESTCTRL_NEVER_CORRUPT: 1.2 misho 20216: if( nArg==3 ){ 1.5 misho 20217: int opt = booleanValue(azArg[2]); 1.4 misho 20218: rc2 = sqlite3_test_control(testctrl, opt); 1.5 misho 20219: isOk = 3; 1.2 misho 20220: } 20221: break; 1.5 misho 20222: 20223: /* sqlite3_test_control(sqlite3*) */ 20224: case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: 20225: rc2 = sqlite3_test_control(testctrl, p->db); 20226: isOk = 3; 20227: break; 1.2 misho 20228: 1.4 misho 20229: case SQLITE_TESTCTRL_IMPOSTER: 20230: if( nArg==5 ){ 20231: rc2 = sqlite3_test_control(testctrl, p->db, 20232: azArg[2], 20233: integerValue(azArg[3]), 20234: integerValue(azArg[4])); 1.5 misho 20235: isOk = 3; 1.4 misho 20236: } 20237: break; 20238: 1.6 ! misho 20239: case SQLITE_TESTCTRL_SEEK_COUNT: { ! 20240: u64 x = 0; ! 20241: rc2 = sqlite3_test_control(testctrl, p->db, &x); ! 20242: utf8_printf(p->out, "%llu\n", x); ! 20243: isOk = 3; ! 20244: break; ! 20245: } ! 20246: 1.5 misho 20247: #ifdef YYCOVERAGE 20248: case SQLITE_TESTCTRL_PARSER_COVERAGE: 20249: if( nArg==2 ){ 20250: sqlite3_test_control(testctrl, p->out); 20251: isOk = 3; 20252: } 20253: #endif 1.2 misho 20254: } 20255: } 1.5 misho 20256: if( isOk==0 && iCtrl>=0 ){ 20257: utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage); 20258: rc = 1; 20259: }else if( isOk==1 ){ 20260: raw_printf(p->out, "%d\n", rc2); 20261: }else if( isOk==2 ){ 20262: raw_printf(p->out, "0x%08x\n", rc2); 20263: } 1.2 misho 20264: }else 1.5 misho 20265: #endif /* !defined(SQLITE_UNTESTABLE) */ 1.2 misho 20266: 1.4 misho 20267: if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){ 20268: open_db(p, 0); 20269: sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0); 20270: }else 20271: 20272: if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){ 20273: if( nArg==2 ){ 20274: enableTimer = booleanValue(azArg[1]); 20275: if( enableTimer && !HAS_TIMER ){ 20276: raw_printf(stderr, "Error: timer not available on this system.\n"); 20277: enableTimer = 0; 20278: } 20279: }else{ 20280: raw_printf(stderr, "Usage: .timer on|off\n"); 20281: rc = 1; 20282: } 1.2 misho 20283: }else 1.4 misho 20284: 1.5 misho 20285: #ifndef SQLITE_OMIT_TRACE 1.4 misho 20286: if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){ 1.5 misho 20287: int mType = 0; 20288: int jj; 1.4 misho 20289: open_db(p, 0); 1.5 misho 20290: for(jj=1; jj<nArg; jj++){ 20291: const char *z = azArg[jj]; 20292: if( z[0]=='-' ){ 20293: if( optionMatch(z, "expanded") ){ 20294: p->eTraceType = SHELL_TRACE_EXPANDED; 20295: } 20296: #ifdef SQLITE_ENABLE_NORMALIZE 20297: else if( optionMatch(z, "normalized") ){ 20298: p->eTraceType = SHELL_TRACE_NORMALIZED; 20299: } 20300: #endif 20301: else if( optionMatch(z, "plain") ){ 20302: p->eTraceType = SHELL_TRACE_PLAIN; 20303: } 20304: else if( optionMatch(z, "profile") ){ 20305: mType |= SQLITE_TRACE_PROFILE; 20306: } 20307: else if( optionMatch(z, "row") ){ 20308: mType |= SQLITE_TRACE_ROW; 20309: } 20310: else if( optionMatch(z, "stmt") ){ 20311: mType |= SQLITE_TRACE_STMT; 20312: } 20313: else if( optionMatch(z, "close") ){ 20314: mType |= SQLITE_TRACE_CLOSE; 20315: } 20316: else { 20317: raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z); 20318: rc = 1; 20319: goto meta_command_exit; 20320: } 20321: }else{ 20322: output_file_close(p->traceOut); 20323: p->traceOut = output_file_open(azArg[1], 0); 20324: } 20325: } 20326: if( p->traceOut==0 ){ 20327: sqlite3_trace_v2(p->db, 0, 0, 0); 20328: }else{ 20329: if( mType==0 ) mType = SQLITE_TRACE_STMT; 20330: sqlite3_trace_v2(p->db, mType, sql_trace_callback, p); 20331: } 20332: }else 20333: #endif /* !defined(SQLITE_OMIT_TRACE) */ 20334: 20335: #if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_VIRTUALTABLE) 20336: if( c=='u' && strncmp(azArg[0], "unmodule", n)==0 ){ 20337: int ii; 20338: int lenOpt; 20339: char *zOpt; 20340: if( nArg<2 ){ 20341: raw_printf(stderr, "Usage: .unmodule [--allexcept] NAME ...\n"); 1.4 misho 20342: rc = 1; 20343: goto meta_command_exit; 20344: } 1.5 misho 20345: open_db(p, 0); 20346: zOpt = azArg[1]; 20347: if( zOpt[0]=='-' && zOpt[1]=='-' && zOpt[2]!=0 ) zOpt++; 20348: lenOpt = (int)strlen(zOpt); 20349: if( lenOpt>=3 && strncmp(zOpt, "-allexcept",lenOpt)==0 ){ 20350: assert( azArg[nArg]==0 ); 20351: sqlite3_drop_modules(p->db, nArg>2 ? (const char**)(azArg+2) : 0); 1.3 misho 20352: }else{ 1.5 misho 20353: for(ii=1; ii<nArg; ii++){ 20354: sqlite3_create_module(p->db, azArg[ii], 0, 0); 20355: } 1.3 misho 20356: } 1.5 misho 20357: }else 1.3 misho 20358: #endif 20359: 1.4 misho 20360: #if SQLITE_USER_AUTHENTICATION 20361: if( c=='u' && strncmp(azArg[0], "user", n)==0 ){ 20362: if( nArg<2 ){ 20363: raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n"); 20364: rc = 1; 20365: goto meta_command_exit; 20366: } 20367: open_db(p, 0); 20368: if( strcmp(azArg[1],"login")==0 ){ 20369: if( nArg!=4 ){ 20370: raw_printf(stderr, "Usage: .user login USER PASSWORD\n"); 20371: rc = 1; 20372: goto meta_command_exit; 20373: } 20374: rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3], 1.5 misho 20375: strlen30(azArg[3])); 1.4 misho 20376: if( rc ){ 20377: utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]); 20378: rc = 1; 20379: } 20380: }else if( strcmp(azArg[1],"add")==0 ){ 20381: if( nArg!=5 ){ 20382: raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n"); 20383: rc = 1; 20384: goto meta_command_exit; 20385: } 1.5 misho 20386: rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 1.4 misho 20387: booleanValue(azArg[4])); 20388: if( rc ){ 20389: raw_printf(stderr, "User-Add failed: %d\n", rc); 20390: rc = 1; 20391: } 20392: }else if( strcmp(azArg[1],"edit")==0 ){ 20393: if( nArg!=5 ){ 20394: raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n"); 20395: rc = 1; 20396: goto meta_command_exit; 20397: } 1.5 misho 20398: rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]), 1.4 misho 20399: booleanValue(azArg[4])); 20400: if( rc ){ 20401: raw_printf(stderr, "User-Edit failed: %d\n", rc); 20402: rc = 1; 20403: } 20404: }else if( strcmp(azArg[1],"delete")==0 ){ 20405: if( nArg!=3 ){ 20406: raw_printf(stderr, "Usage: .user delete USER\n"); 20407: rc = 1; 20408: goto meta_command_exit; 20409: } 20410: rc = sqlite3_user_delete(p->db, azArg[2]); 20411: if( rc ){ 20412: raw_printf(stderr, "User-Delete failed: %d\n", rc); 20413: rc = 1; 20414: } 20415: }else{ 20416: raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n"); 20417: rc = 1; 20418: goto meta_command_exit; 20419: } 20420: }else 20421: #endif /* SQLITE_USER_AUTHENTICATION */ 20422: 1.2 misho 20423: if( c=='v' && strncmp(azArg[0], "version", n)==0 ){ 1.4 misho 20424: utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/, 1.2 misho 20425: sqlite3_libversion(), sqlite3_sourceid()); 1.5 misho 20426: #if SQLITE_HAVE_ZLIB 20427: utf8_printf(p->out, "zlib version %s\n", zlibVersion()); 20428: #endif 20429: #define CTIMEOPT_VAL_(opt) #opt 20430: #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) 20431: #if defined(__clang__) && defined(__clang_major__) 20432: utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "." 20433: CTIMEOPT_VAL(__clang_minor__) "." 20434: CTIMEOPT_VAL(__clang_patchlevel__) "\n"); 20435: #elif defined(_MSC_VER) 20436: utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) "\n"); 20437: #elif defined(__GNUC__) && defined(__VERSION__) 20438: utf8_printf(p->out, "gcc-" __VERSION__ "\n"); 20439: #endif 1.2 misho 20440: }else 20441: 1.4 misho 20442: if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){ 20443: const char *zDbName = nArg==2 ? azArg[1] : "main"; 1.5 misho 20444: sqlite3_vfs *pVfs = 0; 1.4 misho 20445: if( p->db ){ 20446: sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs); 20447: if( pVfs ){ 20448: utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName); 20449: raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 20450: raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 20451: raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 20452: } 20453: } 20454: }else 20455: 20456: if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){ 20457: sqlite3_vfs *pVfs; 20458: sqlite3_vfs *pCurrent = 0; 20459: if( p->db ){ 20460: sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent); 20461: } 20462: for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){ 20463: utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName, 20464: pVfs==pCurrent ? " <--- CURRENT" : ""); 20465: raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion); 20466: raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile); 20467: raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname); 20468: if( pVfs->pNext ){ 20469: raw_printf(p->out, "-----------------------------------\n"); 20470: } 20471: } 20472: }else 20473: 1.2 misho 20474: if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){ 20475: const char *zDbName = nArg==2 ? azArg[1] : "main"; 20476: char *zVfsName = 0; 20477: if( p->db ){ 20478: sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName); 20479: if( zVfsName ){ 1.4 misho 20480: utf8_printf(p->out, "%s\n", zVfsName); 1.2 misho 20481: sqlite3_free(zVfsName); 20482: } 20483: } 20484: }else 20485: 1.3 misho 20486: if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){ 1.6 ! misho 20487: unsigned int x = nArg>=2 ? (unsigned int)integerValue(azArg[1]) : 0xffffffff; ! 20488: sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &x); 1.3 misho 20489: }else 20490: 1.4 misho 20491: if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ 1.2 misho 20492: int j; 20493: assert( nArg<=ArraySize(azArg) ); 1.5 misho 20494: p->nWidth = nArg-1; 20495: p->colWidth = realloc(p->colWidth, p->nWidth*sizeof(int)*2); 20496: if( p->colWidth==0 && p->nWidth>0 ) shell_out_of_memory(); 20497: if( p->nWidth ) p->actualWidth = &p->colWidth[p->nWidth]; 20498: for(j=1; j<nArg; j++){ 1.4 misho 20499: p->colWidth[j-1] = (int)integerValue(azArg[j]); 1.2 misho 20500: } 20501: }else 20502: 20503: { 1.4 misho 20504: utf8_printf(stderr, "Error: unknown command or invalid arguments: " 1.2 misho 20505: " \"%s\". Enter \".help\" for help\n", azArg[0]); 20506: rc = 1; 20507: } 20508: 1.4 misho 20509: meta_command_exit: 20510: if( p->outCount ){ 20511: p->outCount--; 20512: if( p->outCount==0 ) output_reset(p); 20513: } 1.2 misho 20514: return rc; 20515: } 20516: 20517: /* 20518: ** Return TRUE if a semicolon occurs anywhere in the first N characters 20519: ** of string z[]. 20520: */ 1.4 misho 20521: static int line_contains_semicolon(const char *z, int N){ 1.2 misho 20522: int i; 20523: for(i=0; i<N; i++){ if( z[i]==';' ) return 1; } 20524: return 0; 20525: } 20526: 20527: /* 20528: ** Test to see if a line consists entirely of whitespace. 20529: */ 20530: static int _all_whitespace(const char *z){ 20531: for(; *z; z++){ 20532: if( IsSpace(z[0]) ) continue; 20533: if( *z=='/' && z[1]=='*' ){ 20534: z += 2; 20535: while( *z && (*z!='*' || z[1]!='/') ){ z++; } 20536: if( *z==0 ) return 0; 20537: z++; 20538: continue; 20539: } 20540: if( *z=='-' && z[1]=='-' ){ 20541: z += 2; 20542: while( *z && *z!='\n' ){ z++; } 20543: if( *z==0 ) return 1; 20544: continue; 20545: } 20546: return 0; 20547: } 20548: return 1; 20549: } 20550: 20551: /* 20552: ** Return TRUE if the line typed in is an SQL command terminator other 20553: ** than a semi-colon. The SQL Server style "go" command is understood 20554: ** as is the Oracle "/". 20555: */ 1.4 misho 20556: static int line_is_command_terminator(const char *zLine){ 1.2 misho 20557: while( IsSpace(zLine[0]) ){ zLine++; }; 20558: if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){ 20559: return 1; /* Oracle */ 20560: } 20561: if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' 20562: && _all_whitespace(&zLine[2]) ){ 20563: return 1; /* SQL Server */ 20564: } 20565: return 0; 20566: } 20567: 20568: /* 1.5 misho 20569: ** We need a default sqlite3_complete() implementation to use in case 20570: ** the shell is compiled with SQLITE_OMIT_COMPLETE. The default assumes 20571: ** any arbitrary text is a complete SQL statement. This is not very 20572: ** user-friendly, but it does seem to work. 20573: */ 20574: #ifdef SQLITE_OMIT_COMPLETE 20575: #define sqlite3_complete(x) 1 20576: #endif 20577: 20578: /* 1.2 misho 20579: ** Return true if zSql is a complete SQL statement. Return false if it 20580: ** ends in the middle of a string literal or C-style comment. 20581: */ 1.4 misho 20582: static int line_is_complete(char *zSql, int nSql){ 1.2 misho 20583: int rc; 20584: if( zSql==0 ) return 1; 20585: zSql[nSql] = ';'; 20586: zSql[nSql+1] = 0; 20587: rc = sqlite3_complete(zSql); 20588: zSql[nSql] = 0; 20589: return rc; 20590: } 20591: 20592: /* 1.5 misho 20593: ** Run a single line of SQL. Return the number of errors. 20594: */ 20595: static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){ 20596: int rc; 20597: char *zErrMsg = 0; 20598: 20599: open_db(p, 0); 20600: if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql); 20601: if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0; 20602: BEGIN_TIMER; 20603: rc = shell_exec(p, zSql, &zErrMsg); 20604: END_TIMER; 20605: if( rc || zErrMsg ){ 20606: char zPrefix[100]; 20607: if( in!=0 || !stdin_is_interactive ){ 20608: sqlite3_snprintf(sizeof(zPrefix), zPrefix, 20609: "Error: near line %d:", startline); 20610: }else{ 20611: sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); 20612: } 20613: if( zErrMsg!=0 ){ 20614: utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg); 20615: sqlite3_free(zErrMsg); 20616: zErrMsg = 0; 20617: }else{ 20618: utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); 20619: } 20620: return 1; 20621: }else if( ShellHasFlag(p, SHFLG_CountChanges) ){ 20622: raw_printf(p->out, "changes: %3d total_changes: %d\n", 20623: sqlite3_changes(p->db), sqlite3_total_changes(p->db)); 20624: } 20625: return 0; 20626: } 20627: 20628: 20629: /* 1.2 misho 20630: ** Read input from *in and process it. If *in==0 then input 20631: ** is interactive - the user is typing it it. Otherwise, input 20632: ** is coming from a file or device. A prompt is issued and history 20633: ** is saved only if input is interactive. An interrupt signal will 20634: ** cause this routine to exit immediately, unless input is interactive. 20635: ** 20636: ** Return the number of errors. 20637: */ 1.5 misho 20638: static int process_input(ShellState *p){ 1.4 misho 20639: char *zLine = 0; /* A single input line */ 20640: char *zSql = 0; /* Accumulated SQL text */ 20641: int nLine; /* Length of current line */ 20642: int nSql = 0; /* Bytes of zSql[] used */ 20643: int nAlloc = 0; /* Allocated zSql[] space */ 20644: int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */ 20645: int rc; /* Error code */ 20646: int errCnt = 0; /* Number of errors seen */ 20647: int startline = 0; /* Line number for start of current input */ 1.2 misho 20648: 1.5 misho 20649: p->lineno = 0; 20650: while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){ 1.2 misho 20651: fflush(p->out); 1.5 misho 20652: zLine = one_input_line(p->in, zLine, nSql>0); 1.2 misho 20653: if( zLine==0 ){ 1.3 misho 20654: /* End of input */ 1.5 misho 20655: if( p->in==0 && stdin_is_interactive ) printf("\n"); 1.3 misho 20656: break; 1.2 misho 20657: } 20658: if( seenInterrupt ){ 1.5 misho 20659: if( p->in!=0 ) break; 1.2 misho 20660: seenInterrupt = 0; 20661: } 1.5 misho 20662: p->lineno++; 1.4 misho 20663: if( nSql==0 && _all_whitespace(zLine) ){ 1.5 misho 20664: if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 1.4 misho 20665: continue; 20666: } 1.5 misho 20667: if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){ 20668: if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine); 20669: if( zLine[0]=='.' ){ 20670: rc = do_meta_command(zLine, p); 20671: if( rc==2 ){ /* exit requested */ 20672: break; 20673: }else if( rc ){ 20674: errCnt++; 20675: } 1.2 misho 20676: } 20677: continue; 20678: } 1.4 misho 20679: if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){ 1.2 misho 20680: memcpy(zLine,";",2); 20681: } 1.4 misho 20682: nLine = strlen30(zLine); 20683: if( nSql+nLine+2>=nAlloc ){ 20684: nAlloc = nSql+nLine+100; 20685: zSql = realloc(zSql, nAlloc); 1.5 misho 20686: if( zSql==0 ) shell_out_of_memory(); 1.4 misho 20687: } 1.2 misho 20688: nSqlPrior = nSql; 1.4 misho 20689: if( nSql==0 ){ 1.2 misho 20690: int i; 20691: for(i=0; zLine[i] && IsSpace(zLine[i]); i++){} 1.4 misho 20692: assert( nAlloc>0 && zSql!=0 ); 20693: memcpy(zSql, zLine+i, nLine+1-i); 1.5 misho 20694: startline = p->lineno; 1.4 misho 20695: nSql = nLine-i; 1.2 misho 20696: }else{ 20697: zSql[nSql++] = '\n'; 1.4 misho 20698: memcpy(zSql+nSql, zLine, nLine+1); 20699: nSql += nLine; 1.2 misho 20700: } 1.4 misho 20701: if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) 1.2 misho 20702: && sqlite3_complete(zSql) ){ 1.5 misho 20703: errCnt += runOneSqlLine(p, zSql, p->in, startline); 1.4 misho 20704: nSql = 0; 20705: if( p->outCount ){ 20706: output_reset(p); 20707: p->outCount = 0; 1.5 misho 20708: }else{ 20709: clearTempFile(p); 1.4 misho 20710: } 20711: }else if( nSql && _all_whitespace(zSql) ){ 1.5 misho 20712: if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql); 1.2 misho 20713: nSql = 0; 20714: } 20715: } 1.5 misho 20716: if( nSql && !_all_whitespace(zSql) ){ 20717: errCnt += runOneSqlLine(p, zSql, p->in, startline); 1.2 misho 20718: } 1.4 misho 20719: free(zSql); 1.2 misho 20720: free(zLine); 1.3 misho 20721: return errCnt>0; 1.2 misho 20722: } 20723: 20724: /* 20725: ** Return a pathname which is the user's home directory. A 1.3 misho 20726: ** 0 return indicates an error of some kind. 1.2 misho 20727: */ 1.5 misho 20728: static char *find_home_dir(int clearFlag){ 1.3 misho 20729: static char *home_dir = NULL; 1.5 misho 20730: if( clearFlag ){ 20731: free(home_dir); 20732: home_dir = 0; 20733: return 0; 20734: } 1.3 misho 20735: if( home_dir ) return home_dir; 1.2 misho 20736: 1.4 misho 20737: #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \ 20738: && !defined(__RTP__) && !defined(_WRS_KERNEL) 1.3 misho 20739: { 20740: struct passwd *pwent; 20741: uid_t uid = getuid(); 20742: if( (pwent=getpwuid(uid)) != NULL) { 20743: home_dir = pwent->pw_dir; 20744: } 1.2 misho 20745: } 20746: #endif 20747: 20748: #if defined(_WIN32_WCE) 20749: /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() 20750: */ 1.3 misho 20751: home_dir = "/"; 1.2 misho 20752: #else 20753: 1.3 misho 20754: #if defined(_WIN32) || defined(WIN32) 1.2 misho 20755: if (!home_dir) { 20756: home_dir = getenv("USERPROFILE"); 20757: } 20758: #endif 20759: 20760: if (!home_dir) { 20761: home_dir = getenv("HOME"); 20762: } 20763: 1.3 misho 20764: #if defined(_WIN32) || defined(WIN32) 1.2 misho 20765: if (!home_dir) { 20766: char *zDrive, *zPath; 20767: int n; 20768: zDrive = getenv("HOMEDRIVE"); 20769: zPath = getenv("HOMEPATH"); 20770: if( zDrive && zPath ){ 20771: n = strlen30(zDrive) + strlen30(zPath) + 1; 20772: home_dir = malloc( n ); 20773: if( home_dir==0 ) return 0; 20774: sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); 20775: return home_dir; 20776: } 20777: home_dir = "c:\\"; 20778: } 20779: #endif 20780: 20781: #endif /* !_WIN32_WCE */ 20782: 20783: if( home_dir ){ 20784: int n = strlen30(home_dir) + 1; 20785: char *z = malloc( n ); 20786: if( z ) memcpy(z, home_dir, n); 20787: home_dir = z; 20788: } 20789: 20790: return home_dir; 20791: } 20792: 20793: /* 20794: ** Read input from the file given by sqliterc_override. Or if that 20795: ** parameter is NULL, take input from ~/.sqliterc 20796: ** 20797: ** Returns the number of errors. 20798: */ 1.4 misho 20799: static void process_sqliterc( 20800: ShellState *p, /* Configuration data */ 1.2 misho 20801: const char *sqliterc_override /* Name of config file. NULL to use default */ 20802: ){ 20803: char *home_dir = NULL; 20804: const char *sqliterc = sqliterc_override; 20805: char *zBuf = 0; 1.5 misho 20806: FILE *inSaved = p->in; 20807: int savedLineno = p->lineno; 1.2 misho 20808: 20809: if (sqliterc == NULL) { 1.5 misho 20810: home_dir = find_home_dir(0); 1.2 misho 20811: if( home_dir==0 ){ 1.4 misho 20812: raw_printf(stderr, "-- warning: cannot find home directory;" 20813: " cannot read ~/.sqliterc\n"); 20814: return; 1.2 misho 20815: } 1.3 misho 20816: zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir); 20817: sqliterc = zBuf; 1.2 misho 20818: } 1.5 misho 20819: p->in = fopen(sqliterc,"rb"); 20820: if( p->in ){ 1.2 misho 20821: if( stdin_is_interactive ){ 1.4 misho 20822: utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc); 1.2 misho 20823: } 1.6 ! misho 20824: if( process_input(p) && bail_on_error ) exit(1); 1.5 misho 20825: fclose(p->in); 1.6 ! misho 20826: }else if( sqliterc_override!=0 ){ ! 20827: utf8_printf(stderr,"cannot open: \"%s\"\n", sqliterc); ! 20828: if( bail_on_error ) exit(1); 1.2 misho 20829: } 1.5 misho 20830: p->in = inSaved; 20831: p->lineno = savedLineno; 1.3 misho 20832: sqlite3_free(zBuf); 1.2 misho 20833: } 20834: 20835: /* 20836: ** Show available command line options 20837: */ 1.4 misho 20838: static const char zOptions[] = 1.5 misho 20839: #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 20840: " -A ARGS... run \".archive ARGS\" and exit\n" 20841: #endif 20842: " -append append the database to the end of the file\n" 1.4 misho 20843: " -ascii set output mode to 'ascii'\n" 1.2 misho 20844: " -bail stop after hitting an error\n" 20845: " -batch force batch I/O\n" 1.5 misho 20846: " -box set output mode to 'box'\n" 1.2 misho 20847: " -column set output mode to 'column'\n" 1.3 misho 20848: " -cmd COMMAND run \"COMMAND\" before reading stdin\n" 1.2 misho 20849: " -csv set output mode to 'csv'\n" 1.5 misho 20850: #if defined(SQLITE_ENABLE_DESERIALIZE) 20851: " -deserialize open the database using sqlite3_deserialize()\n" 20852: #endif 1.3 misho 20853: " -echo print commands before execution\n" 20854: " -init FILENAME read/process named file\n" 20855: " -[no]header turn headers on or off\n" 20856: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 20857: " -heap SIZE Size of heap for memsys3 or memsys5\n" 20858: #endif 20859: " -help show this message\n" 1.2 misho 20860: " -html set output mode to HTML\n" 1.3 misho 20861: " -interactive force interactive I/O\n" 1.5 misho 20862: " -json set output mode to 'json'\n" 1.2 misho 20863: " -line set output mode to 'line'\n" 20864: " -list set output mode to 'list'\n" 1.4 misho 20865: " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n" 1.5 misho 20866: " -markdown set output mode to 'markdown'\n" 20867: #if defined(SQLITE_ENABLE_DESERIALIZE) 20868: " -maxsize N maximum size for a --deserialize database\n" 20869: #endif 20870: " -memtrace trace all memory allocations and deallocations\n" 1.4 misho 20871: " -mmap N default mmap size set to N\n" 1.3 misho 20872: #ifdef SQLITE_ENABLE_MULTIPLEX 20873: " -multiplex enable the multiplexor VFS\n" 20874: #endif 1.4 misho 20875: " -newline SEP set output row separator. Default: '\\n'\n" 1.5 misho 20876: " -nofollow refuse to open symbolic links to database files\n" 1.3 misho 20877: " -nullvalue TEXT set text string for NULL values. Default ''\n" 1.4 misho 20878: " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n" 1.5 misho 20879: " -quote set output mode to 'quote'\n" 20880: " -readonly open the database read-only\n" 1.4 misho 20881: " -separator SEP set output column separator. Default: '|'\n" 1.5 misho 20882: #ifdef SQLITE_ENABLE_SORTER_REFERENCES 20883: " -sorterref SIZE sorter references threshold size\n" 20884: #endif 1.2 misho 20885: " -stats print memory stats before each finalize\n" 1.5 misho 20886: " -table set output mode to 'table'\n" 1.6 ! misho 20887: " -tabs set output mode to 'tabs'\n" 1.2 misho 20888: " -version show SQLite version\n" 20889: " -vfs NAME use NAME as the default VFS\n" 20890: #ifdef SQLITE_ENABLE_VFSTRACE 20891: " -vfstrace enable tracing of all VFS calls\n" 20892: #endif 1.5 misho 20893: #ifdef SQLITE_HAVE_ZLIB 20894: " -zip open the file as a ZIP Archive\n" 20895: #endif 1.2 misho 20896: ; 20897: static void usage(int showDetail){ 1.4 misho 20898: utf8_printf(stderr, 20899: "Usage: %s [OPTIONS] FILENAME [SQL]\n" 1.2 misho 20900: "FILENAME is the name of an SQLite database. A new database is created\n" 20901: "if the file does not previously exist.\n", Argv0); 20902: if( showDetail ){ 1.4 misho 20903: utf8_printf(stderr, "OPTIONS include:\n%s", zOptions); 1.2 misho 20904: }else{ 1.4 misho 20905: raw_printf(stderr, "Use the -help option for additional information\n"); 1.2 misho 20906: } 20907: exit(1); 20908: } 20909: 20910: /* 1.5 misho 20911: ** Internal check: Verify that the SQLite is uninitialized. Print a 20912: ** error message if it is initialized. 20913: */ 20914: static void verify_uninitialized(void){ 20915: if( sqlite3_config(-1)==SQLITE_MISUSE ){ 20916: utf8_printf(stdout, "WARNING: attempt to configure SQLite after" 20917: " initialization.\n"); 20918: } 20919: } 20920: 20921: /* 1.2 misho 20922: ** Initialize the state information in data 20923: */ 1.4 misho 20924: static void main_init(ShellState *data) { 1.2 misho 20925: memset(data, 0, sizeof(*data)); 1.4 misho 20926: data->normalMode = data->cMode = data->mode = MODE_List; 20927: data->autoExplain = 1; 20928: memcpy(data->colSeparator,SEP_Column, 2); 20929: memcpy(data->rowSeparator,SEP_Row, 2); 1.2 misho 20930: data->showHeader = 0; 1.4 misho 20931: data->shellFlgs = SHFLG_Lookaside; 1.5 misho 20932: verify_uninitialized(); 1.2 misho 20933: sqlite3_config(SQLITE_CONFIG_URI, 1); 20934: sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); 1.4 misho 20935: sqlite3_config(SQLITE_CONFIG_MULTITHREAD); 1.2 misho 20936: sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); 20937: sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); 20938: } 20939: 1.3 misho 20940: /* 1.4 misho 20941: ** Output text to the console in a font that attracts extra attention. 20942: */ 20943: #ifdef _WIN32 20944: static void printBold(const char *zText){ 1.5 misho 20945: #if !SQLITE_OS_WINRT 1.4 misho 20946: HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); 20947: CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo; 20948: GetConsoleScreenBufferInfo(out, &defaultScreenInfo); 20949: SetConsoleTextAttribute(out, 20950: FOREGROUND_RED|FOREGROUND_INTENSITY 20951: ); 1.5 misho 20952: #endif 1.4 misho 20953: printf("%s", zText); 1.5 misho 20954: #if !SQLITE_OS_WINRT 1.4 misho 20955: SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes); 1.5 misho 20956: #endif 1.4 misho 20957: } 20958: #else 20959: static void printBold(const char *zText){ 20960: printf("\033[1m%s\033[0m", zText); 20961: } 20962: #endif 20963: 20964: /* 1.3 misho 20965: ** Get the argument to an --option. Throw an error and die if no argument 20966: ** is available. 20967: */ 20968: static char *cmdline_option_value(int argc, char **argv, int i){ 20969: if( i==argc ){ 1.4 misho 20970: utf8_printf(stderr, "%s: Error: missing argument to %s\n", 1.3 misho 20971: argv[0], argv[argc-1]); 20972: exit(1); 20973: } 20974: return argv[i]; 20975: } 20976: 1.4 misho 20977: #ifndef SQLITE_SHELL_IS_UTF8 1.6 ! misho 20978: # if (defined(_WIN32) || defined(WIN32)) \ ! 20979: && (defined(_MSC_VER) || (defined(UNICODE) && defined(__GNUC__))) 1.4 misho 20980: # define SQLITE_SHELL_IS_UTF8 (0) 20981: # else 20982: # define SQLITE_SHELL_IS_UTF8 (1) 20983: # endif 20984: #endif 20985: 20986: #if SQLITE_SHELL_IS_UTF8 20987: int SQLITE_CDECL main(int argc, char **argv){ 20988: #else 20989: int SQLITE_CDECL wmain(int argc, wchar_t **wargv){ 20990: char **argv; 20991: #endif 1.2 misho 20992: char *zErrMsg = 0; 1.4 misho 20993: ShellState data; 1.2 misho 20994: const char *zInitFile = 0; 20995: int i; 20996: int rc = 0; 1.4 misho 20997: int warnInmemoryDb = 0; 20998: int readStdin = 1; 20999: int nCmd = 0; 21000: char **azCmd = 0; 1.5 misho 21001: const char *zVfs = 0; /* Value of -vfs command-line option */ 21002: #if !SQLITE_SHELL_IS_UTF8 21003: char **argvToFree = 0; 21004: int argcToFree = 0; 21005: #endif 1.4 misho 21006: 21007: setBinaryMode(stdin, 0); 21008: setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */ 21009: stdin_is_interactive = isatty(0); 21010: stdout_is_console = isatty(1); 1.2 misho 21011: 1.5 misho 21012: #ifdef SQLITE_DEBUG 21013: registerOomSimulator(); 21014: #endif 21015: 21016: #if !defined(_WIN32_WCE) 21017: if( getenv("SQLITE_DEBUG_BREAK") ){ 21018: if( isatty(0) && isatty(2) ){ 21019: fprintf(stderr, 21020: "attach debugger to process %d and press any key to continue.\n", 21021: GETPID()); 21022: fgetc(stdin); 21023: }else{ 21024: #if defined(_WIN32) || defined(WIN32) 21025: #if SQLITE_OS_WINRT 21026: __debugbreak(); 21027: #else 21028: DebugBreak(); 21029: #endif 21030: #elif defined(SIGTRAP) 21031: raise(SIGTRAP); 21032: #endif 21033: } 21034: } 21035: #endif 21036: 1.4 misho 21037: #if USE_SYSTEM_SQLITE+0!=1 1.5 misho 21038: if( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){ 1.4 misho 21039: utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n", 1.2 misho 21040: sqlite3_sourceid(), SQLITE_SOURCE_ID); 21041: exit(1); 21042: } 1.4 misho 21043: #endif 21044: main_init(&data); 1.5 misho 21045: 21046: /* On Windows, we must translate command-line arguments into UTF-8. 21047: ** The SQLite memory allocator subsystem has to be enabled in order to 21048: ** do this. But we want to run an sqlite3_shutdown() afterwards so that 21049: ** subsequent sqlite3_config() calls will work. So copy all results into 21050: ** memory that does not come from the SQLite memory allocator. 21051: */ 1.4 misho 21052: #if !SQLITE_SHELL_IS_UTF8 21053: sqlite3_initialize(); 1.5 misho 21054: argvToFree = malloc(sizeof(argv[0])*argc*2); 21055: argcToFree = argc; 21056: argv = argvToFree + argc; 21057: if( argv==0 ) shell_out_of_memory(); 1.4 misho 21058: for(i=0; i<argc; i++){ 1.5 misho 21059: char *z = sqlite3_win32_unicode_to_utf8(wargv[i]); 21060: int n; 21061: if( z==0 ) shell_out_of_memory(); 21062: n = (int)strlen(z); 21063: argv[i] = malloc( n+1 ); 21064: if( argv[i]==0 ) shell_out_of_memory(); 21065: memcpy(argv[i], z, n+1); 21066: argvToFree[i] = argv[i]; 21067: sqlite3_free(z); 1.4 misho 21068: } 1.5 misho 21069: sqlite3_shutdown(); 1.4 misho 21070: #endif 1.5 misho 21071: 1.4 misho 21072: assert( argc>=1 && argv && argv[0] ); 1.2 misho 21073: Argv0 = argv[0]; 21074: 21075: /* Make sure we have a valid signal handler early, before anything 21076: ** else is done. 21077: */ 21078: #ifdef SIGINT 21079: signal(SIGINT, interrupt_handler); 1.5 misho 21080: #elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE) 21081: SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE); 1.2 misho 21082: #endif 21083: 1.4 misho 21084: #ifdef SQLITE_SHELL_DBNAME_PROC 21085: { 21086: /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name 21087: ** of a C-function that will provide the name of the database file. Use 21088: ** this compile-time option to embed this shell program in larger 21089: ** applications. */ 21090: extern void SQLITE_SHELL_DBNAME_PROC(const char**); 21091: SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename); 21092: warnInmemoryDb = 0; 21093: } 21094: #endif 21095: 1.2 misho 21096: /* Do an initial pass through the command-line argument to locate 21097: ** the name of the database file, the name of the initialization file, 21098: ** the size of the alternative malloc heap, 21099: ** and the first command to execute. 21100: */ 1.5 misho 21101: verify_uninitialized(); 1.3 misho 21102: for(i=1; i<argc; i++){ 1.2 misho 21103: char *z; 21104: z = argv[i]; 1.3 misho 21105: if( z[0]!='-' ){ 21106: if( data.zDbFilename==0 ){ 21107: data.zDbFilename = z; 1.4 misho 21108: }else{ 21109: /* Excesss arguments are interpreted as SQL (or dot-commands) and 21110: ** mean that nothing is read from stdin */ 21111: readStdin = 0; 21112: nCmd++; 21113: azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd); 1.5 misho 21114: if( azCmd==0 ) shell_out_of_memory(); 1.4 misho 21115: azCmd[nCmd-1] = z; 1.3 misho 21116: } 21117: } 21118: if( z[1]=='-' ) z++; 21119: if( strcmp(z,"-separator")==0 21120: || strcmp(z,"-nullvalue")==0 1.4 misho 21121: || strcmp(z,"-newline")==0 1.3 misho 21122: || strcmp(z,"-cmd")==0 21123: ){ 21124: (void)cmdline_option_value(argc, argv, ++i); 21125: }else if( strcmp(z,"-init")==0 ){ 21126: zInitFile = cmdline_option_value(argc, argv, ++i); 21127: }else if( strcmp(z,"-batch")==0 ){ 21128: /* Need to check for batch mode here to so we can avoid printing 1.4 misho 21129: ** informational messages (like from process_sqliterc) before 1.3 misho 21130: ** we do the actual processing of arguments later in a second pass. 21131: */ 1.2 misho 21132: stdin_is_interactive = 0; 1.3 misho 21133: }else if( strcmp(z,"-heap")==0 ){ 1.2 misho 21134: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) 21135: const char *zSize; 21136: sqlite3_int64 szHeap; 21137: 1.3 misho 21138: zSize = cmdline_option_value(argc, argv, ++i); 1.4 misho 21139: szHeap = integerValue(zSize); 1.2 misho 21140: if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000; 21141: sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64); 1.4 misho 21142: #else 21143: (void)cmdline_option_value(argc, argv, ++i); 1.2 misho 21144: #endif 1.4 misho 21145: }else if( strcmp(z,"-pagecache")==0 ){ 1.6 ! misho 21146: sqlite3_int64 n, sz; ! 21147: sz = integerValue(cmdline_option_value(argc,argv,++i)); 1.4 misho 21148: if( sz>70000 ) sz = 70000; 21149: if( sz<0 ) sz = 0; 1.6 ! misho 21150: n = integerValue(cmdline_option_value(argc,argv,++i)); ! 21151: if( sz>0 && n>0 && 0xffffffffffffLL/sz<n ){ ! 21152: n = 0xffffffffffffLL/sz; ! 21153: } 1.4 misho 21154: sqlite3_config(SQLITE_CONFIG_PAGECACHE, 21155: (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n); 21156: data.shellFlgs |= SHFLG_Pagecache; 21157: }else if( strcmp(z,"-lookaside")==0 ){ 21158: int n, sz; 21159: sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); 21160: if( sz<0 ) sz = 0; 21161: n = (int)integerValue(cmdline_option_value(argc,argv,++i)); 21162: if( n<0 ) n = 0; 21163: sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n); 21164: if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside; 1.2 misho 21165: #ifdef SQLITE_ENABLE_VFSTRACE 1.3 misho 21166: }else if( strcmp(z,"-vfstrace")==0 ){ 1.2 misho 21167: extern int vfstrace_register( 21168: const char *zTraceName, 21169: const char *zOldVfsName, 21170: int (*xOut)(const char*,void*), 21171: void *pOutArg, 21172: int makeDefault 21173: ); 21174: vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1); 21175: #endif 21176: #ifdef SQLITE_ENABLE_MULTIPLEX 1.3 misho 21177: }else if( strcmp(z,"-multiplex")==0 ){ 1.2 misho 21178: extern int sqlite3_multiple_initialize(const char*,int); 21179: sqlite3_multiplex_initialize(0, 1); 21180: #endif 1.4 misho 21181: }else if( strcmp(z,"-mmap")==0 ){ 21182: sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 21183: sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz); 1.5 misho 21184: #ifdef SQLITE_ENABLE_SORTER_REFERENCES 21185: }else if( strcmp(z,"-sorterref")==0 ){ 21186: sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); 21187: sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz); 21188: #endif 1.3 misho 21189: }else if( strcmp(z,"-vfs")==0 ){ 1.5 misho 21190: zVfs = cmdline_option_value(argc, argv, ++i); 21191: #ifdef SQLITE_HAVE_ZLIB 21192: }else if( strcmp(z,"-zip")==0 ){ 21193: data.openMode = SHELL_OPEN_ZIPFILE; 21194: #endif 21195: }else if( strcmp(z,"-append")==0 ){ 21196: data.openMode = SHELL_OPEN_APPENDVFS; 21197: #ifdef SQLITE_ENABLE_DESERIALIZE 21198: }else if( strcmp(z,"-deserialize")==0 ){ 21199: data.openMode = SHELL_OPEN_DESERIALIZE; 21200: }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 21201: data.szMax = integerValue(argv[++i]); 21202: #endif 21203: }else if( strcmp(z,"-readonly")==0 ){ 21204: data.openMode = SHELL_OPEN_READONLY; 21205: }else if( strcmp(z,"-nofollow")==0 ){ 21206: data.openFlags = SQLITE_OPEN_NOFOLLOW; 21207: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 21208: }else if( strncmp(z, "-A",2)==0 ){ 21209: /* All remaining command-line arguments are passed to the ".archive" 21210: ** command, so ignore them */ 21211: break; 21212: #endif 21213: }else if( strcmp(z, "-memtrace")==0 ){ 21214: sqlite3MemTraceActivate(stderr); 1.6 ! misho 21215: }else if( strcmp(z,"-bail")==0 ){ ! 21216: bail_on_error = 1; 1.5 misho 21217: } 21218: } 21219: verify_uninitialized(); 21220: 21221: 21222: #ifdef SQLITE_SHELL_INIT_PROC 21223: { 21224: /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name 21225: ** of a C-function that will perform initialization actions on SQLite that 21226: ** occur just before or after sqlite3_initialize(). Use this compile-time 21227: ** option to embed this shell program in larger applications. */ 21228: extern void SQLITE_SHELL_INIT_PROC(void); 21229: SQLITE_SHELL_INIT_PROC(); 21230: } 21231: #else 21232: /* All the sqlite3_config() calls have now been made. So it is safe 21233: ** to call sqlite3_initialize() and process any command line -vfs option. */ 21234: sqlite3_initialize(); 21235: #endif 21236: 21237: if( zVfs ){ 21238: sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs); 21239: if( pVfs ){ 21240: sqlite3_vfs_register(pVfs, 1); 21241: }else{ 21242: utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]); 21243: exit(1); 1.2 misho 21244: } 21245: } 1.5 misho 21246: 1.3 misho 21247: if( data.zDbFilename==0 ){ 1.2 misho 21248: #ifndef SQLITE_OMIT_MEMORYDB 21249: data.zDbFilename = ":memory:"; 1.4 misho 21250: warnInmemoryDb = argc==1; 1.2 misho 21251: #else 1.4 misho 21252: utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0); 1.3 misho 21253: return 1; 1.2 misho 21254: #endif 21255: } 21256: data.out = stdout; 1.5 misho 21257: sqlite3_appendvfs_init(0,0,0); 1.2 misho 21258: 21259: /* Go ahead and open the database file if it already exists. If the 21260: ** file does not exist, delay opening it. This prevents empty database 21261: ** files from being created if a user mistypes the database name argument 21262: ** to the sqlite command-line tool. 21263: */ 21264: if( access(data.zDbFilename, 0)==0 ){ 1.4 misho 21265: open_db(&data, 0); 1.2 misho 21266: } 21267: 21268: /* Process the initialization file if there is one. If no -init option 21269: ** is given on the command line, look for a file named ~/.sqliterc and 21270: ** try to process it. 21271: */ 1.4 misho 21272: process_sqliterc(&data,zInitFile); 1.2 misho 21273: 21274: /* Make a second pass through the command-line argument and set 21275: ** options. This second pass is delayed until after the initialization 21276: ** file is processed so that the command-line arguments will override 21277: ** settings in the initialization file. 21278: */ 1.3 misho 21279: for(i=1; i<argc; i++){ 1.2 misho 21280: char *z = argv[i]; 1.3 misho 21281: if( z[0]!='-' ) continue; 1.2 misho 21282: if( z[1]=='-' ){ z++; } 21283: if( strcmp(z,"-init")==0 ){ 21284: i++; 21285: }else if( strcmp(z,"-html")==0 ){ 21286: data.mode = MODE_Html; 21287: }else if( strcmp(z,"-list")==0 ){ 21288: data.mode = MODE_List; 1.5 misho 21289: }else if( strcmp(z,"-quote")==0 ){ 21290: data.mode = MODE_Quote; 1.6 ! misho 21291: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Comma); ! 21292: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Row); 1.2 misho 21293: }else if( strcmp(z,"-line")==0 ){ 21294: data.mode = MODE_Line; 21295: }else if( strcmp(z,"-column")==0 ){ 21296: data.mode = MODE_Column; 1.5 misho 21297: }else if( strcmp(z,"-json")==0 ){ 21298: data.mode = MODE_Json; 21299: }else if( strcmp(z,"-markdown")==0 ){ 21300: data.mode = MODE_Markdown; 21301: }else if( strcmp(z,"-table")==0 ){ 21302: data.mode = MODE_Table; 21303: }else if( strcmp(z,"-box")==0 ){ 21304: data.mode = MODE_Box; 1.2 misho 21305: }else if( strcmp(z,"-csv")==0 ){ 21306: data.mode = MODE_Csv; 1.4 misho 21307: memcpy(data.colSeparator,",",2); 1.5 misho 21308: #ifdef SQLITE_HAVE_ZLIB 21309: }else if( strcmp(z,"-zip")==0 ){ 21310: data.openMode = SHELL_OPEN_ZIPFILE; 21311: #endif 21312: }else if( strcmp(z,"-append")==0 ){ 21313: data.openMode = SHELL_OPEN_APPENDVFS; 21314: #ifdef SQLITE_ENABLE_DESERIALIZE 21315: }else if( strcmp(z,"-deserialize")==0 ){ 21316: data.openMode = SHELL_OPEN_DESERIALIZE; 21317: }else if( strcmp(z,"-maxsize")==0 && i+1<argc ){ 21318: data.szMax = integerValue(argv[++i]); 21319: #endif 21320: }else if( strcmp(z,"-readonly")==0 ){ 21321: data.openMode = SHELL_OPEN_READONLY; 21322: }else if( strcmp(z,"-nofollow")==0 ){ 21323: data.openFlags |= SQLITE_OPEN_NOFOLLOW; 1.4 misho 21324: }else if( strcmp(z,"-ascii")==0 ){ 21325: data.mode = MODE_Ascii; 1.6 ! misho 21326: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Unit); ! 21327: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Record); ! 21328: }else if( strcmp(z,"-tabs")==0 ){ ! 21329: data.mode = MODE_List; ! 21330: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Tab); ! 21331: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Row); 1.2 misho 21332: }else if( strcmp(z,"-separator")==0 ){ 1.4 misho 21333: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, 21334: "%s",cmdline_option_value(argc,argv,++i)); 21335: }else if( strcmp(z,"-newline")==0 ){ 21336: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, 1.3 misho 21337: "%s",cmdline_option_value(argc,argv,++i)); 1.2 misho 21338: }else if( strcmp(z,"-nullvalue")==0 ){ 1.4 misho 21339: sqlite3_snprintf(sizeof(data.nullValue), data.nullValue, 1.3 misho 21340: "%s",cmdline_option_value(argc,argv,++i)); 1.2 misho 21341: }else if( strcmp(z,"-header")==0 ){ 21342: data.showHeader = 1; 21343: }else if( strcmp(z,"-noheader")==0 ){ 21344: data.showHeader = 0; 21345: }else if( strcmp(z,"-echo")==0 ){ 1.5 misho 21346: ShellSetFlag(&data, SHFLG_Echo); 1.4 misho 21347: }else if( strcmp(z,"-eqp")==0 ){ 1.5 misho 21348: data.autoEQP = AUTOEQP_on; 1.4 misho 21349: }else if( strcmp(z,"-eqpfull")==0 ){ 1.5 misho 21350: data.autoEQP = AUTOEQP_full; 1.2 misho 21351: }else if( strcmp(z,"-stats")==0 ){ 21352: data.statsOn = 1; 1.4 misho 21353: }else if( strcmp(z,"-scanstats")==0 ){ 21354: data.scanstatsOn = 1; 21355: }else if( strcmp(z,"-backslash")==0 ){ 21356: /* Undocumented command-line option: -backslash 21357: ** Causes C-style backslash escapes to be evaluated in SQL statements 21358: ** prior to sending the SQL into SQLite. Useful for injecting 21359: ** crazy bytes in the middle of SQL statements for testing and debugging. 21360: */ 1.5 misho 21361: ShellSetFlag(&data, SHFLG_Backslash); 1.2 misho 21362: }else if( strcmp(z,"-bail")==0 ){ 1.6 ! misho 21363: /* No-op. The bail_on_error flag should already be set. */ 1.2 misho 21364: }else if( strcmp(z,"-version")==0 ){ 21365: printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid()); 21366: return 0; 21367: }else if( strcmp(z,"-interactive")==0 ){ 21368: stdin_is_interactive = 1; 21369: }else if( strcmp(z,"-batch")==0 ){ 21370: stdin_is_interactive = 0; 21371: }else if( strcmp(z,"-heap")==0 ){ 21372: i++; 1.4 misho 21373: }else if( strcmp(z,"-pagecache")==0 ){ 21374: i+=2; 21375: }else if( strcmp(z,"-lookaside")==0 ){ 21376: i+=2; 21377: }else if( strcmp(z,"-mmap")==0 ){ 21378: i++; 1.5 misho 21379: }else if( strcmp(z,"-memtrace")==0 ){ 21380: i++; 21381: #ifdef SQLITE_ENABLE_SORTER_REFERENCES 21382: }else if( strcmp(z,"-sorterref")==0 ){ 21383: i++; 21384: #endif 1.2 misho 21385: }else if( strcmp(z,"-vfs")==0 ){ 21386: i++; 21387: #ifdef SQLITE_ENABLE_VFSTRACE 21388: }else if( strcmp(z,"-vfstrace")==0 ){ 21389: i++; 21390: #endif 21391: #ifdef SQLITE_ENABLE_MULTIPLEX 21392: }else if( strcmp(z,"-multiplex")==0 ){ 21393: i++; 21394: #endif 1.3 misho 21395: }else if( strcmp(z,"-help")==0 ){ 1.2 misho 21396: usage(1); 1.3 misho 21397: }else if( strcmp(z,"-cmd")==0 ){ 1.4 misho 21398: /* Run commands that follow -cmd first and separately from commands 21399: ** that simply appear on the command-line. This seems goofy. It would 21400: ** be better if all commands ran in the order that they appear. But 21401: ** we retain the goofy behavior for historical compatibility. */ 1.3 misho 21402: if( i==argc-1 ) break; 21403: z = cmdline_option_value(argc,argv,++i); 21404: if( z[0]=='.' ){ 21405: rc = do_meta_command(z, &data); 1.4 misho 21406: if( rc && bail_on_error ) return rc==2 ? 0 : rc; 1.3 misho 21407: }else{ 1.4 misho 21408: open_db(&data, 0); 1.5 misho 21409: rc = shell_exec(&data, z, &zErrMsg); 1.3 misho 21410: if( zErrMsg!=0 ){ 1.4 misho 21411: utf8_printf(stderr,"Error: %s\n", zErrMsg); 1.3 misho 21412: if( bail_on_error ) return rc!=0 ? rc : 1; 21413: }else if( rc!=0 ){ 1.4 misho 21414: utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z); 1.3 misho 21415: if( bail_on_error ) return rc; 21416: } 21417: } 1.5 misho 21418: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) 21419: }else if( strncmp(z, "-A", 2)==0 ){ 21420: if( nCmd>0 ){ 21421: utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands" 21422: " with \"%s\"\n", z); 21423: return 1; 21424: } 21425: open_db(&data, OPEN_DB_ZIPFILE); 21426: if( z[2] ){ 21427: argv[i] = &z[2]; 21428: arDotCommand(&data, 1, argv+(i-1), argc-(i-1)); 21429: }else{ 21430: arDotCommand(&data, 1, argv+i, argc-i); 21431: } 21432: readStdin = 0; 21433: break; 21434: #endif 1.2 misho 21435: }else{ 1.4 misho 21436: utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z); 21437: raw_printf(stderr,"Use -help for a list of options.\n"); 1.2 misho 21438: return 1; 21439: } 1.4 misho 21440: data.cMode = data.mode; 1.2 misho 21441: } 21442: 1.4 misho 21443: if( !readStdin ){ 21444: /* Run all arguments that do not begin with '-' as if they were separate 21445: ** command-line inputs, except for the argToSkip argument which contains 21446: ** the database filename. 1.2 misho 21447: */ 1.4 misho 21448: for(i=0; i<nCmd; i++){ 21449: if( azCmd[i][0]=='.' ){ 21450: rc = do_meta_command(azCmd[i], &data); 1.6 ! misho 21451: if( rc ){ ! 21452: free(azCmd); ! 21453: return rc==2 ? 0 : rc; ! 21454: } 1.4 misho 21455: }else{ 21456: open_db(&data, 0); 1.5 misho 21457: rc = shell_exec(&data, azCmd[i], &zErrMsg); 1.6 ! misho 21458: if( zErrMsg || rc ){ ! 21459: if( zErrMsg!=0 ){ ! 21460: utf8_printf(stderr,"Error: %s\n", zErrMsg); ! 21461: }else{ ! 21462: utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]); ! 21463: } ! 21464: sqlite3_free(zErrMsg); ! 21465: free(azCmd); 1.4 misho 21466: return rc!=0 ? rc : 1; 21467: } 1.2 misho 21468: } 21469: } 21470: }else{ 21471: /* Run commands received from standard input 21472: */ 21473: if( stdin_is_interactive ){ 21474: char *zHome; 1.5 misho 21475: char *zHistory; 1.2 misho 21476: int nHistory; 21477: printf( 21478: "SQLite version %s %.19s\n" /*extra-version-info*/ 1.4 misho 21479: "Enter \".help\" for usage hints.\n", 1.2 misho 21480: sqlite3_libversion(), sqlite3_sourceid() 21481: ); 1.4 misho 21482: if( warnInmemoryDb ){ 21483: printf("Connected to a "); 21484: printBold("transient in-memory database"); 21485: printf(".\nUse \".open FILENAME\" to reopen on a " 21486: "persistent database.\n"); 21487: } 1.5 misho 21488: zHistory = getenv("SQLITE_HISTORY"); 21489: if( zHistory ){ 21490: zHistory = strdup(zHistory); 21491: }else if( (zHome = find_home_dir(0))!=0 ){ 1.2 misho 21492: nHistory = strlen30(zHome) + 20; 21493: if( (zHistory = malloc(nHistory))!=0 ){ 21494: sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome); 21495: } 21496: } 1.4 misho 21497: if( zHistory ){ shell_read_history(zHistory); } 1.5 misho 21498: #if HAVE_READLINE || HAVE_EDITLINE 21499: rl_attempted_completion_function = readline_completion; 21500: #elif HAVE_LINENOISE 21501: linenoiseSetCompletionCallback(linenoise_completion); 21502: #endif 21503: data.in = 0; 21504: rc = process_input(&data); 1.2 misho 21505: if( zHistory ){ 1.5 misho 21506: shell_stifle_history(2000); 1.4 misho 21507: shell_write_history(zHistory); 1.2 misho 21508: free(zHistory); 21509: } 21510: }else{ 1.5 misho 21511: data.in = stdin; 21512: rc = process_input(&data); 1.2 misho 21513: } 21514: } 1.6 ! misho 21515: free(azCmd); 1.2 misho 21516: set_table_name(&data, 0); 21517: if( data.db ){ 1.4 misho 21518: session_close_all(&data); 1.5 misho 21519: close_db(data.db); 1.2 misho 21520: } 1.4 misho 21521: sqlite3_free(data.zFreeOnClose); 1.5 misho 21522: find_home_dir(1); 21523: output_reset(&data); 21524: data.doXdgOpen = 0; 21525: clearTempFile(&data); 1.4 misho 21526: #if !SQLITE_SHELL_IS_UTF8 1.5 misho 21527: for(i=0; i<argcToFree; i++) free(argvToFree[i]); 21528: free(argvToFree); 1.4 misho 21529: #endif 1.5 misho 21530: free(data.colWidth); 21531: /* Clear the global data structure so that valgrind will detect memory 21532: ** leaks */ 21533: memset(&data, 0, sizeof(data)); 1.2 misho 21534: return rc; 21535: }